« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: mbp at sourcefrog
- Date: 2005-03-09 04:08:15 UTC
- Revision ID: mbp@sourcefrog.net-20050309040815-13242001617e4a06
import from baz patch-364
- files added:
- bzrlib/tests.py
- files removed:
- .bzrignore
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/elementtree
- bzrlib/util/urlgrabber
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- doc
- notes
- patches
- tools
- files renamed:
- bzrlib/commands.py => bzr.py
- files modified:
- README
added
removed
bzrlib/branch.py
1
# Copyright (C) 2005 Canonical Ltd
1
#! /usr/bin/env python
2
# -*- coding: UTF-8 -*-
2
3
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
15
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
17
17
18
18
import sys
19
import os
19
from sets import Set
20
21
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
22
import traceback, socket, fnmatch, difflib, time
23
from binascii import hexlify
20
24
21
25
import bzrlib
22
from bzrlib.trace import mutter, note
23
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, \
24
splitpath, \
25
sha_file, appendpath, file_kind
26
27
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId
28
import bzrlib.errors
29
from bzrlib.textui import show_status
30
from bzrlib.revision import Revision
31
from bzrlib.xml import unpack_xml
32
from bzrlib.delta import compare_trees
33
from bzrlib.tree import EmptyTree, RevisionTree
34
import bzrlib.ui
35
36
26
from inventory import Inventory
27
from trace import mutter, note
28
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
29
from inventory import InventoryEntry, Inventory
30
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, chomp, \
31
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
32
joinpath, sha_string, file_kind
33
from store import ImmutableStore
34
from revision import Revision
35
from errors import bailout
36
from textui import show_status
37
from diff import diff_trees
37
38
38
39
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
39
40
## TODO: Maybe include checks for common corruption of newlines, etc?
40
41
41
42
42
# TODO: Some operations like log might retrieve the same revisions
43
# repeatedly to calculate deltas. We could perhaps have a weakref
44
# cache in memory to make this faster.
45
46
# TODO: please move the revision-string syntax stuff out of the branch
47
# object; it's clutter
48
49
50
def find_branch(f, **args):
51
if f and (f.startswith('http://') or f.startswith('https://')):
52
import remotebranch
53
return remotebranch.RemoteBranch(f, **args)
54
else:
55
return Branch(f, **args)
56
57
58
def find_cached_branch(f, cache_root, **args):
59
from remotebranch import RemoteBranch
60
br = find_branch(f, **args)
61
def cacheify(br, store_name):
62
from meta_store import CachedStore
63
cache_path = os.path.join(cache_root, store_name)
64
os.mkdir(cache_path)
65
new_store = CachedStore(getattr(br, store_name), cache_path)
66
setattr(br, store_name, new_store)
67
68
if isinstance(br, RemoteBranch):
69
cacheify(br, 'inventory_store')
70
cacheify(br, 'text_store')
71
cacheify(br, 'revision_store')
72
return br
73
74
75
def _relpath(base, path):
76
"""Return path relative to base, or raise exception.
77
78
The path may be either an absolute path or a path relative to the
79
current working directory.
80
81
Lifted out of Branch.relpath for ease of testing.
82
83
os.path.commonprefix (python2.4) has a bad bug that it works just
84
on string prefixes, assuming that '/u' is a prefix of '/u2'. This
85
avoids that problem."""
86
rp = os.path.abspath(path)
87
88
s = []
89
head = rp
90
while len(head) >= len(base):
91
if head == base:
92
break
93
head, tail = os.path.split(head)
94
if tail:
95
s.insert(0, tail)
96
else:
97
from errors import NotBranchError
98
raise NotBranchError("path %r is not within branch %r" % (rp, base))
99
100
return os.sep.join(s)
101
102
103
def find_branch_root(f=None):
104
"""Find the branch root enclosing f, or pwd.
105
106
f may be a filename or a URL.
107
108
It is not necessary that f exists.
109
110
Basically we keep looking up until we find the control directory or
111
run into the root. If there isn't one, raises NotBranchError.
112
"""
113
if f == None:
114
f = os.getcwd()
115
elif hasattr(os.path, 'realpath'):
116
f = os.path.realpath(f)
117
else:
118
f = os.path.abspath(f)
119
if not os.path.exists(f):
120
raise BzrError('%r does not exist' % f)
121
122
123
orig_f = f
124
125
while True:
126
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
127
return f
128
head, tail = os.path.split(f)
129
if head == f:
130
# reached the root, whatever that may be
131
raise bzrlib.errors.NotBranchError('%s is not in a branch' % orig_f)
132
f = head
133
134
135
136
# XXX: move into bzrlib.errors; subclass BzrError
137
class DivergedBranches(Exception):
138
def __init__(self, branch1, branch2):
139
self.branch1 = branch1
140
self.branch2 = branch2
141
Exception.__init__(self, "These branches have diverged.")
43
142
44
143
45
144
46
######################################################################
145
47
# branch objects
146
48
147
class Branch(object):
49
class Branch:
148
50
"""Branch holding a history of revisions.
149
51
150
base
151
Base directory of the branch.
152
153
_lock_mode
154
None, or 'r' or 'w'
155
156
_lock_count
157
If _lock_mode is true, a positive count of the number of times the
158
lock has been taken.
159
160
_lock
161
Lock object from bzrlib.lock.
52
:todo: Perhaps use different stores for different classes of object,
53
so that we can keep track of how much space each one uses,
54
or garbage-collect them.
55
56
:todo: Add a RemoteBranch subclass. For the basic case of read-only
57
HTTP access this should be very easy by,
58
just redirecting controlfile access into HTTP requests.
59
We would need a RemoteStore working similarly.
60
61
:todo: Keep the on-disk branch locked while the object exists.
62
63
:todo: mkdir() method.
162
64
"""
163
base = None
164
_lock_mode = None
165
_lock_count = None
166
_lock = None
167
168
# Map some sort of prefix into a namespace
169
# stuff like "revno:10", "revid:", etc.
170
# This should match a prefix with a function which accepts
171
REVISION_NAMESPACES = {}
172
173
def __init__(self, base, init=False, find_root=True):
65
def __init__(self, base, init=False):
174
66
"""Create new branch object at a particular location.
175
67
176
base -- Base directory for the branch.
177
178
init -- If True, create new control files in a previously
68
:param base: Base directory for the branch.
69
70
:param init: If True, create new control files in a previously
179
71
unversioned directory. If False, the branch must already
180
72
be versioned.
181
73
182
find_root -- If true and init is false, find the root of the
183
existing branch containing base.
184
185
74
In the test suite, creation of new trees is tested using the
186
75
`ScratchBranch` class.
187
76
"""
188
from bzrlib.store import ImmutableStore
77
self.base = os.path.realpath(base)
189
78
if init:
190
self.base = os.path.realpath(base)
191
79
self._make_control()
192
elif find_root:
193
self.base = find_branch_root(base)
194
80
else:
195
self.base = os.path.realpath(base)
196
81
if not isdir(self.controlfilename('.')):
197
from errors import NotBranchError
198
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
199
['use "bzr init" to initialize a new working tree',
200
'current bzr can only operate from top-of-tree'])
201
self._check_format()
82
bailout("not a bzr branch: %s" % quotefn(base),
83
['use "bzr init" to initialize a new working tree',
84
'current bzr can only operate from top-of-tree'])
85
self._check_format()
202
86
203
87
self.text_store = ImmutableStore(self.controlfilename('text-store'))
204
88
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
212
96
__repr__ = __str__
213
97
214
98
215
def __del__(self):
216
if self._lock_mode or self._lock:
217
from warnings import warn
218
warn("branch %r was not explicitly unlocked" % self)
219
self._lock.unlock()
220
221
222
223
def lock_write(self):
224
if self._lock_mode:
225
if self._lock_mode != 'w':
226
from errors import LockError
227
raise LockError("can't upgrade to a write lock from %r" %
228
self._lock_mode)
229
self._lock_count += 1
230
else:
231
from bzrlib.lock import WriteLock
232
233
self._lock = WriteLock(self.controlfilename('branch-lock'))
234
self._lock_mode = 'w'
235
self._lock_count = 1
236
237
238
239
def lock_read(self):
240
if self._lock_mode:
241
assert self._lock_mode in ('r', 'w'), \
242
"invalid lock mode %r" % self._lock_mode
243
self._lock_count += 1
244
else:
245
from bzrlib.lock import ReadLock
246
247
self._lock = ReadLock(self.controlfilename('branch-lock'))
248
self._lock_mode = 'r'
249
self._lock_count = 1
250
251
252
253
def unlock(self):
254
if not self._lock_mode:
255
from errors import LockError
256
raise LockError('branch %r is not locked' % (self))
257
258
if self._lock_count > 1:
259
self._lock_count -= 1
260
else:
261
self._lock.unlock()
262
self._lock = None
263
self._lock_mode = self._lock_count = None
264
265
266
def abspath(self, name):
267
"""Return absolute filename for something in the branch"""
99
def _rel(self, name):
100
"""Return filename relative to branch top"""
268
101
return os.path.join(self.base, name)
269
270
271
def relpath(self, path):
272
"""Return path relative to this branch of something inside it.
273
274
Raises an error if path is not in this branch."""
275
return _relpath(self.base, path)
276
102
277
103
278
104
def controlfilename(self, file_or_path):
279
105
"""Return location relative to branch."""
280
if isinstance(file_or_path, basestring):
106
if isinstance(file_or_path, types.StringTypes):
281
107
file_or_path = [file_or_path]
282
108
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
283
109
284
110
285
111
def controlfile(self, file_or_path, mode='r'):
286
"""Open a control file for this branch.
287
288
There are two classes of file in the control directory: text
289
and binary. binary files are untranslated byte streams. Text
290
control files are stored with Unix newlines and in UTF-8, even
291
if the platform or locale defaults are different.
292
293
Controlfiles should almost never be opened in write mode but
294
rather should be atomically copied and replaced using atomicfile.
295
"""
296
297
fn = self.controlfilename(file_or_path)
298
299
if mode == 'rb' or mode == 'wb':
300
return file(fn, mode)
301
elif mode == 'r' or mode == 'w':
302
# open in binary mode anyhow so there's no newline translation;
303
# codecs uses line buffering by default; don't want that.
304
import codecs
305
return codecs.open(fn, mode + 'b', 'utf-8',
306
buffering=60000)
307
else:
308
raise BzrError("invalid controlfile mode %r" % mode)
309
112
"""Open a control file for this branch"""
113
return file(self.controlfilename(file_or_path), mode)
310
114
311
115
312
116
def _make_control(self):
313
from bzrlib.inventory import Inventory
314
from bzrlib.xml import pack_xml
315
316
117
os.mkdir(self.controlfilename([]))
317
118
self.controlfile('README', 'w').write(
318
119
"This is a Bazaar-NG control directory.\n"
319
"Do not change any files in this directory.\n")
120
"Do not change any files in this directory.")
320
121
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
321
122
for d in ('text-store', 'inventory-store', 'revision-store'):
322
123
os.mkdir(self.controlfilename(d))
323
124
for f in ('revision-history', 'merged-patches',
324
'pending-merged-patches', 'branch-name',
325
'branch-lock',
326
'pending-merges'):
125
'pending-merged-patches', 'branch-name'):
327
126
self.controlfile(f, 'w').write('')
328
127
mutter('created control directory in ' + self.base)
329
330
# if we want per-tree root ids then this is the place to set
331
# them; they're not needed for now and so ommitted for
332
# simplicity.
333
pack_xml(Inventory(), self.controlfile('inventory','w'))
128
Inventory().write_xml(self.controlfile('inventory','w'))
334
129
335
130
336
131
def _check_format(self):
340
135
341
136
In the future, we might need different in-memory Branch
342
137
classes to support downlevel branches. But not yet.
343
"""
344
# This ignores newlines so that we can open branches created
345
# on Windows from Linux and so on. I think it might be better
346
# to always make all internal files in unix format.
347
fmt = self.controlfile('branch-format', 'r').read()
348
fmt.replace('\r\n', '')
138
"""
139
# read in binary mode to detect newline wierdness.
140
fmt = self.controlfile('branch-format', 'rb').read()
349
141
if fmt != BZR_BRANCH_FORMAT:
350
raise BzrError('sorry, branch format %r not supported' % fmt,
351
['use a different bzr version',
352
'or remove the .bzr directory and "bzr init" again'])
353
354
def get_root_id(self):
355
"""Return the id of this branches root"""
356
inv = self.read_working_inventory()
357
return inv.root.file_id
358
359
def set_root_id(self, file_id):
360
inv = self.read_working_inventory()
361
orig_root_id = inv.root.file_id
362
del inv._byid[inv.root.file_id]
363
inv.root.file_id = file_id
364
inv._byid[inv.root.file_id] = inv.root
365
for fid in inv:
366
entry = inv[fid]
367
if entry.parent_id in (None, orig_root_id):
368
entry.parent_id = inv.root.file_id
369
self._write_inventory(inv)
142
bailout('sorry, branch format %r not supported' % fmt,
143
['use a different bzr version',
144
'or remove the .bzr directory and "bzr init" again'])
145
370
146
371
147
def read_working_inventory(self):
372
148
"""Read the working inventory."""
373
from bzrlib.inventory import Inventory
374
from bzrlib.xml import unpack_xml
375
from time import time
376
before = time()
377
self.lock_read()
378
try:
379
# ElementTree does its own conversion from UTF-8, so open in
380
# binary.
381
inv = unpack_xml(Inventory,
382
self.controlfile('inventory', 'rb'))
383
mutter("loaded inventory of %d items in %f"
384
% (len(inv), time() - before))
385
return inv
386
finally:
387
self.unlock()
388
149
before = time.time()
150
inv = Inventory.read_xml(self.controlfile('inventory', 'r'))
151
mutter("loaded inventory of %d items in %f"
152
% (len(inv), time.time() - before))
153
return inv
154
389
155
390
156
def _write_inventory(self, inv):
391
157
"""Update the working inventory.
393
159
That is to say, the inventory describing changes underway, that
394
160
will be committed to the next revision.
395
161
"""
396
from bzrlib.atomicfile import AtomicFile
397
from bzrlib.xml import pack_xml
398
399
self.lock_write()
400
try:
401
f = AtomicFile(self.controlfilename('inventory'), 'wb')
402
try:
403
pack_xml(inv, f)
404
f.commit()
405
finally:
406
f.close()
407
finally:
408
self.unlock()
409
410
mutter('wrote working inventory')
411
162
inv.write_xml(self.controlfile('inventory', 'w'))
163
mutter('wrote inventory to %s' % quotefn(self.controlfilename('inventory')))
164
412
165
413
166
inventory = property(read_working_inventory, _write_inventory, None,
414
167
"""Inventory for the working copy.""")
415
168
416
169
417
def add(self, files, verbose=False, ids=None):
170
def add(self, files, verbose=False):
418
171
"""Make files versioned.
419
172
420
Note that the command line normally calls smart_add instead.
421
422
173
This puts the files in the Added state, so that they will be
423
174
recorded by the next commit.
424
175
425
files
426
List of paths to add, relative to the base of the tree.
427
428
ids
429
If set, use these instead of automatically generated ids.
430
Must be the same length as the list of files, but may
431
contain None for ids that are to be autogenerated.
432
433
TODO: Perhaps have an option to add the ids even if the files do
434
not (yet) exist.
435
436
TODO: Perhaps return the ids of the files? But then again it
437
is easy to retrieve them if they're needed.
438
439
TODO: Adding a directory should optionally recurse down and
440
add all non-ignored children. Perhaps do that in a
441
higher-level method.
176
:todo: Perhaps have an option to add the ids even if the files do
177
not (yet) exist.
178
179
:todo: Perhaps return the ids of the files? But then again it
180
is easy to retrieve them if they're needed.
181
182
:todo: Option to specify file id.
183
184
:todo: Adding a directory should optionally recurse down and
185
add all non-ignored children. Perhaps do that in a
186
higher-level method.
187
188
>>> b = ScratchBranch(files=['foo'])
189
>>> 'foo' in b.unknowns()
190
True
191
>>> b.show_status()
192
? foo
193
>>> b.add('foo')
194
>>> 'foo' in b.unknowns()
195
False
196
>>> bool(b.inventory.path2id('foo'))
197
True
198
>>> b.show_status()
199
A foo
200
201
>>> b.add('foo')
202
Traceback (most recent call last):
203
...
204
BzrError: ('foo is already versioned', [])
205
206
>>> b.add(['nothere'])
207
Traceback (most recent call last):
208
BzrError: ('cannot add: not a regular file or directory: nothere', [])
442
209
"""
210
443
211
# TODO: Re-adding a file that is removed in the working copy
444
212
# should probably put it back with the previous ID.
445
if isinstance(files, basestring):
446
assert(ids is None or isinstance(ids, basestring))
213
if isinstance(files, types.StringTypes):
447
214
files = [files]
448
if ids is not None:
449
ids = [ids]
450
451
if ids is None:
452
ids = [None] * len(files)
453
else:
454
assert(len(ids) == len(files))
455
456
self.lock_write()
457
try:
458
inv = self.read_working_inventory()
459
for f,file_id in zip(files, ids):
460
if is_control_file(f):
461
raise BzrError("cannot add control file %s" % quotefn(f))
462
463
fp = splitpath(f)
464
465
if len(fp) == 0:
466
raise BzrError("cannot add top-level %r" % f)
467
468
fullpath = os.path.normpath(self.abspath(f))
469
470
try:
471
kind = file_kind(fullpath)
472
except OSError:
473
# maybe something better?
474
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
475
476
if kind != 'file' and kind != 'directory':
477
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
478
479
if file_id is None:
480
file_id = gen_file_id(f)
481
inv.add_path(f, kind=kind, file_id=file_id)
482
483
if verbose:
484
print 'added', quotefn(f)
485
486
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
487
488
self._write_inventory(inv)
489
finally:
490
self.unlock()
491
492
493
def print_file(self, file, revno):
494
"""Print `file` to stdout."""
495
self.lock_read()
496
try:
497
tree = self.revision_tree(self.lookup_revision(revno))
498
# use inventory as it was in that revision
499
file_id = tree.inventory.path2id(file)
500
if not file_id:
501
raise BzrError("%r is not present in revision %s" % (file, revno))
502
tree.print_file(file_id)
503
finally:
504
self.unlock()
215
216
inv = self.read_working_inventory()
217
for f in files:
218
if is_control_file(f):
219
bailout("cannot add control file %s" % quotefn(f))
220
221
fp = splitpath(f)
222
223
if len(fp) == 0:
224
bailout("cannot add top-level %r" % f)
225
226
fullpath = os.path.normpath(self._rel(f))
227
228
if isfile(fullpath):
229
kind = 'file'
230
elif isdir(fullpath):
231
kind = 'directory'
232
else:
233
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
234
235
if len(fp) > 1:
236
parent_name = joinpath(fp[:-1])
237
mutter("lookup parent %r" % parent_name)
238
parent_id = inv.path2id(parent_name)
239
if parent_id == None:
240
bailout("cannot add: parent %r is not versioned"
241
% joinpath(fp[:-1]))
242
else:
243
parent_id = None
244
245
file_id = _gen_file_id(fp[-1])
246
inv.add(InventoryEntry(file_id, fp[-1], kind=kind, parent_id=parent_id))
247
if verbose:
248
show_status('A', kind, quotefn(f))
249
250
mutter("add file %s file_id:{%s} kind=%r parent_id={%s}"
251
% (f, file_id, kind, parent_id))
252
self._write_inventory(inv)
253
505
254
506
255
507
256
def remove(self, files, verbose=False):
509
258
510
259
This does not remove their text. This does not run on
511
260
512
TODO: Refuse to remove modified files unless --force is given?
513
514
TODO: Do something useful with directories.
515
516
TODO: Should this remove the text or not? Tough call; not
261
:todo: Refuse to remove modified files unless --force is given?
262
263
>>> b = ScratchBranch(files=['foo'])
264
>>> b.add('foo')
265
>>> b.inventory.has_filename('foo')
266
True
267
>>> b.remove('foo')
268
>>> b.working_tree().has_filename('foo')
269
True
270
>>> b.inventory.has_filename('foo')
271
False
272
273
>>> b = ScratchBranch(files=['foo'])
274
>>> b.add('foo')
275
>>> b.commit('one')
276
>>> b.remove('foo')
277
>>> b.commit('two')
278
>>> b.inventory.has_filename('foo')
279
False
280
>>> b.basis_tree().has_filename('foo')
281
False
282
>>> b.working_tree().has_filename('foo')
283
True
284
285
:todo: Do something useful with directories.
286
287
:todo: Should this remove the text or not? Tough call; not
517
288
removing may be useful and the user can just use use rm, and
518
289
is the opposite of add. Removing it is consistent with most
519
290
other tools. Maybe an option.
520
291
"""
521
292
## TODO: Normalize names
522
293
## TODO: Remove nested loops; better scalability
523
if isinstance(files, basestring):
294
295
if isinstance(files, types.StringTypes):
524
296
files = [files]
525
526
self.lock_write()
527
528
try:
529
tree = self.working_tree()
530
inv = tree.inventory
531
532
# do this before any modifications
533
for f in files:
534
fid = inv.path2id(f)
535
if not fid:
536
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
537
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
538
if verbose:
539
# having remove it, it must be either ignored or unknown
540
if tree.is_ignored(f):
541
new_status = 'I'
542
else:
543
new_status = '?'
544
show_status(new_status, inv[fid].kind, quotefn(f))
545
del inv[fid]
546
547
self._write_inventory(inv)
548
finally:
549
self.unlock()
550
551
552
# FIXME: this doesn't need to be a branch method
553
def set_inventory(self, new_inventory_list):
554
from bzrlib.inventory import Inventory, InventoryEntry
555
inv = Inventory(self.get_root_id())
556
for path, file_id, parent, kind in new_inventory_list:
557
name = os.path.basename(path)
558
if name == "":
559
continue
560
inv.add(InventoryEntry(file_id, name, kind, parent))
297
298
inv = self.read_working_inventory()
299
300
# do this before any modifications
301
for f in files:
302
fid = inv.path2id(f)
303
if not fid:
304
bailout("cannot remove unversioned file %s" % quotefn(f))
305
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
306
if verbose:
307
show_status('D', inv[fid].kind, quotefn(f))
308
del inv[fid]
309
561
310
self._write_inventory(inv)
562
311
563
312
580
329
return self.working_tree().unknowns()
581
330
582
331
583
def append_revision(self, *revision_ids):
584
from bzrlib.atomicfile import AtomicFile
585
586
for revision_id in revision_ids:
587
mutter("add {%s} to revision-history" % revision_id)
588
589
rev_history = self.revision_history()
590
rev_history.extend(revision_ids)
591
592
f = AtomicFile(self.controlfilename('revision-history'))
593
try:
594
for rev_id in rev_history:
595
print >>f, rev_id
596
f.commit()
597
finally:
598
f.close()
599
600
601
def get_revision_xml(self, revision_id):
602
"""Return XML file object for revision object."""
603
if not revision_id or not isinstance(revision_id, basestring):
604
raise InvalidRevisionId(revision_id)
605
606
self.lock_read()
607
try:
608
try:
609
return self.revision_store[revision_id]
610
except IndexError:
611
raise bzrlib.errors.NoSuchRevision(self, revision_id)
612
finally:
613
self.unlock()
332
def commit(self, message, timestamp=None, committer=None,
333
verbose=False):
334
"""Commit working copy as a new revision.
335
336
The basic approach is to add all the file texts into the
337
store, then the inventory, then make a new revision pointing
338
to that inventory and store that.
339
340
This is not quite safe if the working copy changes during the
341
commit; for the moment that is simply not allowed. A better
342
approach is to make a temporary copy of the files before
343
computing their hashes, and then add those hashes in turn to
344
the inventory. This should mean at least that there are no
345
broken hash pointers. There is no way we can get a snapshot
346
of the whole directory at an instant. This would also have to
347
be robust against files disappearing, moving, etc. So the
348
whole thing is a bit hard.
349
350
:param timestamp: if not None, seconds-since-epoch for a
351
postdated/predated commit.
352
"""
353
354
## TODO: Show branch names
355
356
# TODO: Don't commit if there are no changes, unless forced?
357
358
# First walk over the working inventory; and both update that
359
# and also build a new revision inventory. The revision
360
# inventory needs to hold the text-id, sha1 and size of the
361
# actual file versions committed in the revision. (These are
362
# not present in the working inventory.) We also need to
363
# detect missing/deleted files, and remove them from the
364
# working inventory.
365
366
work_inv = self.read_working_inventory()
367
inv = Inventory()
368
basis = self.basis_tree()
369
basis_inv = basis.inventory
370
missing_ids = []
371
for path, entry in work_inv.iter_entries():
372
## TODO: Cope with files that have gone missing.
373
374
## TODO: Check that the file kind has not changed from the previous
375
## revision of this file (if any).
376
377
entry = entry.copy()
378
379
p = self._rel(path)
380
file_id = entry.file_id
381
mutter('commit prep file %s, id %r ' % (p, file_id))
382
383
if not os.path.exists(p):
384
mutter(" file is missing, removing from inventory")
385
if verbose:
386
show_status('D', entry.kind, quotefn(path))
387
missing_ids.append(file_id)
388
continue
389
390
# TODO: Handle files that have been deleted
391
392
# TODO: Maybe a special case for empty files? Seems a
393
# waste to store them many times.
394
395
inv.add(entry)
396
397
if basis_inv.has_id(file_id):
398
old_kind = basis_inv[file_id].kind
399
if old_kind != entry.kind:
400
bailout("entry %r changed kind from %r to %r"
401
% (file_id, old_kind, entry.kind))
402
403
if entry.kind == 'directory':
404
if not isdir(p):
405
bailout("%s is entered as directory but not a directory" % quotefn(p))
406
elif entry.kind == 'file':
407
if not isfile(p):
408
bailout("%s is entered as file but is not a file" % quotefn(p))
409
410
content = file(p, 'rb').read()
411
412
entry.text_sha1 = sha_string(content)
413
entry.text_size = len(content)
414
415
old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
416
if (old_ie
417
and (old_ie.text_size == entry.text_size)
418
and (old_ie.text_sha1 == entry.text_sha1)):
419
## assert content == basis.get_file(file_id).read()
420
entry.text_id = basis_inv[file_id].text_id
421
mutter(' unchanged from previous text_id {%s}' %
422
entry.text_id)
423
424
else:
425
entry.text_id = _gen_file_id(entry.name)
426
self.text_store.add(content, entry.text_id)
427
mutter(' stored with text_id {%s}' % entry.text_id)
428
if verbose:
429
if not old_ie:
430
state = 'A'
431
elif (old_ie.name == entry.name
432
and old_ie.parent_id == entry.parent_id):
433
state = 'R'
434
else:
435
state = 'M'
436
437
show_status(state, entry.kind, quotefn(path))
438
439
for file_id in missing_ids:
440
# have to do this later so we don't mess up the iterator.
441
# since parents may be removed before their children we
442
# have to test.
443
444
# FIXME: There's probably a better way to do this; perhaps
445
# the workingtree should know how to filter itself.
446
if work_inv.has_id(file_id):
447
del work_inv[file_id]
448
449
450
inv_id = rev_id = _gen_revision_id(time.time())
451
452
inv_tmp = tempfile.TemporaryFile()
453
inv.write_xml(inv_tmp)
454
inv_tmp.seek(0)
455
self.inventory_store.add(inv_tmp, inv_id)
456
mutter('new inventory_id is {%s}' % inv_id)
457
458
self._write_inventory(work_inv)
459
460
if timestamp == None:
461
timestamp = time.time()
462
463
if committer == None:
464
committer = username()
465
466
mutter("building commit log message")
467
rev = Revision(timestamp=timestamp,
468
committer=committer,
469
precursor = self.last_patch(),
470
message = message,
471
inventory_id=inv_id,
472
revision_id=rev_id)
473
474
rev_tmp = tempfile.TemporaryFile()
475
rev.write_xml(rev_tmp)
476
rev_tmp.seek(0)
477
self.revision_store.add(rev_tmp, rev_id)
478
mutter("new revision_id is {%s}" % rev_id)
479
480
## XXX: Everything up to here can simply be orphaned if we abort
481
## the commit; it will leave junk files behind but that doesn't
482
## matter.
483
484
## TODO: Read back the just-generated changeset, and make sure it
485
## applies and recreates the right state.
486
487
## TODO: Also calculate and store the inventory SHA1
488
mutter("committing patch r%d" % (self.revno() + 1))
489
490
mutter("append to revision-history")
491
self.controlfile('revision-history', 'at').write(rev_id + '\n')
492
493
mutter("done!")
614
494
615
495
616
496
def get_revision(self, revision_id):
617
497
"""Return the Revision object for a named revision"""
618
xml_file = self.get_revision_xml(revision_id)
619
620
try:
621
r = unpack_xml(Revision, xml_file)
622
except SyntaxError, e:
623
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
624
[revision_id,
625
str(e)])
626
498
r = Revision.read_xml(self.revision_store[revision_id])
627
499
assert r.revision_id == revision_id
628
500
return r
629
501
630
502
631
def get_revision_delta(self, revno):
632
"""Return the delta for one revision.
633
634
The delta is relative to its mainline predecessor, or the
635
empty tree for revision 1.
636
"""
637
assert isinstance(revno, int)
638
rh = self.revision_history()
639
if not (1 <= revno <= len(rh)):
640
raise InvalidRevisionNumber(revno)
641
642
# revno is 1-based; list is 0-based
643
644
new_tree = self.revision_tree(rh[revno-1])
645
if revno == 1:
646
old_tree = EmptyTree()
647
else:
648
old_tree = self.revision_tree(rh[revno-2])
649
650
return compare_trees(old_tree, new_tree)
651
652
653
654
def get_revision_sha1(self, revision_id):
655
"""Hash the stored value of a revision, and return it."""
656
# In the future, revision entries will be signed. At that
657
# point, it is probably best *not* to include the signature
658
# in the revision hash. Because that lets you re-sign
659
# the revision, (add signatures/remove signatures) and still
660
# have all hash pointers stay consistent.
661
# But for now, just hash the contents.
662
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
663
664
665
503
def get_inventory(self, inventory_id):
666
504
"""Get Inventory object by hash.
667
505
668
TODO: Perhaps for this and similar methods, take a revision
506
:todo: Perhaps for this and similar methods, take a revision
669
507
parameter which can be either an integer revno or a
670
508
string hash."""
671
from bzrlib.inventory import Inventory
672
from bzrlib.xml import unpack_xml
673
674
return unpack_xml(Inventory, self.get_inventory_xml(inventory_id))
675
676
677
def get_inventory_xml(self, inventory_id):
678
"""Get inventory XML as a file object."""
679
return self.inventory_store[inventory_id]
680
681
682
def get_inventory_sha1(self, inventory_id):
683
"""Return the sha1 hash of the inventory entry
684
"""
685
return sha_file(self.get_inventory_xml(inventory_id))
509
i = Inventory.read_xml(self.inventory_store[inventory_id])
510
return i
686
511
687
512
688
513
def get_revision_inventory(self, revision_id):
689
514
"""Return inventory of a past revision."""
690
# bzr 0.0.6 imposes the constraint that the inventory_id
691
# must be the same as its revision, so this is trivial.
692
515
if revision_id == None:
693
from bzrlib.inventory import Inventory
694
return Inventory(self.get_root_id())
516
return Inventory()
695
517
else:
696
return self.get_inventory(revision_id)
518
return self.get_inventory(self.get_revision(revision_id).inventory_id)
697
519
698
520
699
521
def revision_history(self):
702
524
>>> ScratchBranch().revision_history()
703
525
[]
704
526
"""
705
self.lock_read()
706
try:
707
return [l.rstrip('\r\n') for l in
708
self.controlfile('revision-history', 'r').readlines()]
709
finally:
710
self.unlock()
711
712
713
def common_ancestor(self, other, self_revno=None, other_revno=None):
714
"""
715
>>> import commit
716
>>> sb = ScratchBranch(files=['foo', 'foo~'])
717
>>> sb.common_ancestor(sb) == (None, None)
718
True
719
>>> commit.commit(sb, "Committing first revision", verbose=False)
720
>>> sb.common_ancestor(sb)[0]
721
1
722
>>> clone = sb.clone()
723
>>> commit.commit(sb, "Committing second revision", verbose=False)
724
>>> sb.common_ancestor(sb)[0]
725
2
726
>>> sb.common_ancestor(clone)[0]
727
1
728
>>> commit.commit(clone, "Committing divergent second revision",
729
... verbose=False)
730
>>> sb.common_ancestor(clone)[0]
731
1
732
>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
733
True
734
>>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
735
True
736
>>> clone2 = sb.clone()
737
>>> sb.common_ancestor(clone2)[0]
738
2
739
>>> sb.common_ancestor(clone2, self_revno=1)[0]
740
1
741
>>> sb.common_ancestor(clone2, other_revno=1)[0]
742
1
743
"""
744
my_history = self.revision_history()
745
other_history = other.revision_history()
746
if self_revno is None:
747
self_revno = len(my_history)
748
if other_revno is None:
749
other_revno = len(other_history)
750
indices = range(min((self_revno, other_revno)))
751
indices.reverse()
752
for r in indices:
753
if my_history[r] == other_history[r]:
754
return r+1, my_history[r]
755
return None, None
527
return [chomp(l) for l in self.controlfile('revision-history').readlines()]
756
528
757
529
758
530
def revno(self):
760
532
761
533
That is equivalent to the number of revisions committed to
762
534
this branch.
535
536
>>> b = ScratchBranch()
537
>>> b.revno()
538
0
539
>>> b.commit('no foo')
540
>>> b.revno()
541
1
763
542
"""
764
543
return len(self.revision_history())
765
544
766
545
767
546
def last_patch(self):
768
547
"""Return last patch hash, or None if no history.
548
549
>>> ScratchBranch().last_patch() == None
550
True
769
551
"""
770
552
ph = self.revision_history()
771
553
if ph:
772
554
return ph[-1]
773
else:
774
return None
775
776
777
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
778
"""
779
If self and other have not diverged, return a list of the revisions
780
present in other, but missing from self.
781
782
>>> from bzrlib.commit import commit
783
>>> bzrlib.trace.silent = True
784
>>> br1 = ScratchBranch()
785
>>> br2 = ScratchBranch()
786
>>> br1.missing_revisions(br2)
787
[]
788
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
789
>>> br1.missing_revisions(br2)
790
[u'REVISION-ID-1']
791
>>> br2.missing_revisions(br1)
792
[]
793
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
794
>>> br1.missing_revisions(br2)
795
[]
796
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
797
>>> br1.missing_revisions(br2)
798
[u'REVISION-ID-2A']
799
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
800
>>> br1.missing_revisions(br2)
801
Traceback (most recent call last):
802
DivergedBranches: These branches have diverged.
803
"""
804
self_history = self.revision_history()
805
self_len = len(self_history)
806
other_history = other.revision_history()
807
other_len = len(other_history)
808
common_index = min(self_len, other_len) -1
809
if common_index >= 0 and \
810
self_history[common_index] != other_history[common_index]:
811
raise DivergedBranches(self, other)
812
813
if stop_revision is None:
814
stop_revision = other_len
815
elif stop_revision > other_len:
816
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
817
818
return other_history[self_len:stop_revision]
819
820
821
def update_revisions(self, other, stop_revision=None):
822
"""Pull in all new revisions from other branch.
823
"""
824
from bzrlib.fetch import greedy_fetch
825
826
pb = bzrlib.ui.ui_factory.progress_bar()
827
pb.update('comparing histories')
828
829
revision_ids = self.missing_revisions(other, stop_revision)
830
831
if len(revision_ids) > 0:
832
count = greedy_fetch(self, other, revision_ids[-1], pb)[0]
833
else:
834
count = 0
835
self.append_revision(*revision_ids)
836
## note("Added %d revisions." % count)
837
838
839
def install_revisions(self, other, revision_ids, pb):
840
if hasattr(other.revision_store, "prefetch"):
841
other.revision_store.prefetch(revision_ids)
842
if hasattr(other.inventory_store, "prefetch"):
843
inventory_ids = [other.get_revision(r).inventory_id
844
for r in revision_ids]
845
other.inventory_store.prefetch(inventory_ids)
846
847
if pb is None:
848
pb = bzrlib.ui.ui_factory.progress_bar()
849
850
revisions = []
851
needed_texts = set()
852
i = 0
853
854
failures = set()
855
for i, rev_id in enumerate(revision_ids):
856
pb.update('fetching revision', i+1, len(revision_ids))
857
try:
858
rev = other.get_revision(rev_id)
859
except bzrlib.errors.NoSuchRevision:
860
failures.add(rev_id)
861
continue
862
863
revisions.append(rev)
864
inv = other.get_inventory(str(rev.inventory_id))
865
for key, entry in inv.iter_entries():
866
if entry.text_id is None:
867
continue
868
if entry.text_id not in self.text_store:
869
needed_texts.add(entry.text_id)
870
871
pb.clear()
872
873
count, cp_fail = self.text_store.copy_multi(other.text_store,
874
needed_texts)
875
print "Added %d texts." % count
876
inventory_ids = [ f.inventory_id for f in revisions ]
877
count, cp_fail = self.inventory_store.copy_multi(other.inventory_store,
878
inventory_ids)
879
print "Added %d inventories." % count
880
revision_ids = [ f.revision_id for f in revisions]
881
882
count, cp_fail = self.revision_store.copy_multi(other.revision_store,
883
revision_ids,
884
permit_failure=True)
885
assert len(cp_fail) == 0
886
return count, failures
887
888
889
def commit(self, *args, **kw):
890
from bzrlib.commit import commit
891
commit(self, *args, **kw)
892
893
894
def lookup_revision(self, revision):
895
"""Return the revision identifier for a given revision information."""
896
revno, info = self.get_revision_info(revision)
897
return info
898
899
900
def revision_id_to_revno(self, revision_id):
901
"""Given a revision id, return its revno"""
902
history = self.revision_history()
903
try:
904
return history.index(revision_id) + 1
905
except ValueError:
906
raise bzrlib.errors.NoSuchRevision(self, revision_id)
907
908
909
def get_revision_info(self, revision):
910
"""Return (revno, revision id) for revision identifier.
911
912
revision can be an integer, in which case it is assumed to be revno (though
913
this will translate negative values into positive ones)
914
revision can also be a string, in which case it is parsed for something like
915
'date:' or 'revid:' etc.
916
"""
917
if revision is None:
918
return 0, None
919
revno = None
920
try:# Convert to int if possible
921
revision = int(revision)
922
except ValueError:
923
pass
924
revs = self.revision_history()
925
if isinstance(revision, int):
926
if revision == 0:
927
return 0, None
928
# Mabye we should do this first, but we don't need it if revision == 0
929
if revision < 0:
930
revno = len(revs) + revision + 1
931
else:
932
revno = revision
933
elif isinstance(revision, basestring):
934
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
935
if revision.startswith(prefix):
936
revno = func(self, revs, revision)
937
break
938
else:
939
raise BzrError('No namespace registered for string: %r' % revision)
940
941
if revno is None or revno <= 0 or revno > len(revs):
942
raise BzrError("no such revision %s" % revision)
943
return revno, revs[revno-1]
944
945
def _namespace_revno(self, revs, revision):
946
"""Lookup a revision by revision number"""
947
assert revision.startswith('revno:')
948
try:
949
return int(revision[6:])
950
except ValueError:
951
return None
952
REVISION_NAMESPACES['revno:'] = _namespace_revno
953
954
def _namespace_revid(self, revs, revision):
955
assert revision.startswith('revid:')
956
try:
957
return revs.index(revision[6:]) + 1
958
except ValueError:
959
return None
960
REVISION_NAMESPACES['revid:'] = _namespace_revid
961
962
def _namespace_last(self, revs, revision):
963
assert revision.startswith('last:')
964
try:
965
offset = int(revision[5:])
966
except ValueError:
967
return None
968
else:
969
if offset <= 0:
970
raise BzrError('You must supply a positive value for --revision last:XXX')
971
return len(revs) - offset + 1
972
REVISION_NAMESPACES['last:'] = _namespace_last
973
974
def _namespace_tag(self, revs, revision):
975
assert revision.startswith('tag:')
976
raise BzrError('tag: namespace registered, but not implemented.')
977
REVISION_NAMESPACES['tag:'] = _namespace_tag
978
979
def _namespace_date(self, revs, revision):
980
assert revision.startswith('date:')
981
import datetime
982
# Spec for date revisions:
983
# date:value
984
# value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
985
# it can also start with a '+/-/='. '+' says match the first
986
# entry after the given date. '-' is match the first entry before the date
987
# '=' is match the first entry after, but still on the given date.
988
#
989
# +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
990
# -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
991
# =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
992
# May 13th, 2005 at 0:00
993
#
994
# So the proper way of saying 'give me all entries for today' is:
995
# -r {date:+today}:{date:-tomorrow}
996
# The default is '=' when not supplied
997
val = revision[5:]
998
match_style = '='
999
if val[:1] in ('+', '-', '='):
1000
match_style = val[:1]
1001
val = val[1:]
1002
1003
today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
1004
if val.lower() == 'yesterday':
1005
dt = today - datetime.timedelta(days=1)
1006
elif val.lower() == 'today':
1007
dt = today
1008
elif val.lower() == 'tomorrow':
1009
dt = today + datetime.timedelta(days=1)
1010
else:
1011
import re
1012
# This should be done outside the function to avoid recompiling it.
1013
_date_re = re.compile(
1014
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
1015
r'(,|T)?\s*'
1016
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
1017
)
1018
m = _date_re.match(val)
1019
if not m or (not m.group('date') and not m.group('time')):
1020
raise BzrError('Invalid revision date %r' % revision)
1021
1022
if m.group('date'):
1023
year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
1024
else:
1025
year, month, day = today.year, today.month, today.day
1026
if m.group('time'):
1027
hour = int(m.group('hour'))
1028
minute = int(m.group('minute'))
1029
if m.group('second'):
1030
second = int(m.group('second'))
1031
else:
1032
second = 0
1033
else:
1034
hour, minute, second = 0,0,0
1035
1036
dt = datetime.datetime(year=year, month=month, day=day,
1037
hour=hour, minute=minute, second=second)
1038
first = dt
1039
last = None
1040
reversed = False
1041
if match_style == '-':
1042
reversed = True
1043
elif match_style == '=':
1044
last = dt + datetime.timedelta(days=1)
1045
1046
if reversed:
1047
for i in range(len(revs)-1, -1, -1):
1048
r = self.get_revision(revs[i])
1049
# TODO: Handle timezone.
1050
dt = datetime.datetime.fromtimestamp(r.timestamp)
1051
if first >= dt and (last is None or dt >= last):
1052
return i+1
1053
else:
1054
for i in range(len(revs)):
1055
r = self.get_revision(revs[i])
1056
# TODO: Handle timezone.
1057
dt = datetime.datetime.fromtimestamp(r.timestamp)
1058
if first <= dt and (last is None or dt <= last):
1059
return i+1
1060
REVISION_NAMESPACES['date:'] = _namespace_date
555
556
557
def lookup_revision(self, revno):
558
"""Return revision hash for revision number."""
559
if revno == 0:
560
return None
561
562
try:
563
# list is 0-based; revisions are 1-based
564
return self.revision_history()[revno-1]
565
except IndexError:
566
bailout("no such revision %s" % revno)
567
1061
568
1062
569
def revision_tree(self, revision_id):
1063
570
"""Return Tree for a revision on this branch.
1064
571
1065
572
`revision_id` may be None for the null revision, in which case
1066
573
an `EmptyTree` is returned."""
1067
# TODO: refactor this to use an existing revision object
1068
# so we don't need to read it in twice.
574
1069
575
if revision_id == None:
1070
576
return EmptyTree()
1071
577
else:
1075
581
1076
582
def working_tree(self):
1077
583
"""Return a `Tree` for the working copy."""
1078
from workingtree import WorkingTree
1079
584
return WorkingTree(self.base, self.read_working_inventory())
1080
585
1081
586
1083
588
"""Return `Tree` object for last revision.
1084
589
1085
590
If there are no revisions yet, return an `EmptyTree`.
591
592
>>> b = ScratchBranch(files=['foo'])
593
>>> b.basis_tree().has_filename('foo')
594
False
595
>>> b.working_tree().has_filename('foo')
596
True
597
>>> b.add('foo')
598
>>> b.commit('add foo')
599
>>> b.basis_tree().has_filename('foo')
600
True
1086
601
"""
1087
602
r = self.last_patch()
1088
603
if r == None:
1092
607
1093
608
1094
609
1095
def rename_one(self, from_rel, to_rel):
1096
"""Rename one file.
1097
1098
This can change the directory or the filename or both.
1099
"""
1100
self.lock_write()
1101
try:
1102
tree = self.working_tree()
1103
inv = tree.inventory
1104
if not tree.has_filename(from_rel):
1105
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
1106
if tree.has_filename(to_rel):
1107
raise BzrError("can't rename: new working file %r already exists" % to_rel)
1108
1109
file_id = inv.path2id(from_rel)
1110
if file_id == None:
1111
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
1112
1113
if inv.path2id(to_rel):
1114
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
1115
1116
to_dir, to_tail = os.path.split(to_rel)
1117
to_dir_id = inv.path2id(to_dir)
1118
if to_dir_id == None and to_dir != '':
1119
raise BzrError("can't determine destination directory id for %r" % to_dir)
1120
1121
mutter("rename_one:")
1122
mutter(" file_id {%s}" % file_id)
1123
mutter(" from_rel %r" % from_rel)
1124
mutter(" to_rel %r" % to_rel)
1125
mutter(" to_dir %r" % to_dir)
1126
mutter(" to_dir_id {%s}" % to_dir_id)
1127
1128
inv.rename(file_id, to_dir_id, to_tail)
1129
1130
print "%s => %s" % (from_rel, to_rel)
1131
1132
from_abs = self.abspath(from_rel)
1133
to_abs = self.abspath(to_rel)
1134
try:
1135
os.rename(from_abs, to_abs)
1136
except OSError, e:
1137
raise BzrError("failed to rename %r to %r: %s"
1138
% (from_abs, to_abs, e[1]),
1139
["rename rolled back"])
1140
1141
self._write_inventory(inv)
1142
finally:
1143
self.unlock()
1144
1145
1146
def move(self, from_paths, to_name):
1147
"""Rename files.
1148
1149
to_name must exist as a versioned directory.
1150
1151
If to_name exists and is a directory, the files are moved into
1152
it, keeping their old names. If it is a directory,
1153
1154
Note that to_name is only the last component of the new name;
1155
this doesn't change the directory.
1156
"""
1157
self.lock_write()
1158
try:
1159
## TODO: Option to move IDs only
1160
assert not isinstance(from_paths, basestring)
1161
tree = self.working_tree()
1162
inv = tree.inventory
1163
to_abs = self.abspath(to_name)
1164
if not isdir(to_abs):
1165
raise BzrError("destination %r is not a directory" % to_abs)
1166
if not tree.has_filename(to_name):
1167
raise BzrError("destination %r not in working directory" % to_abs)
1168
to_dir_id = inv.path2id(to_name)
1169
if to_dir_id == None and to_name != '':
1170
raise BzrError("destination %r is not a versioned directory" % to_name)
1171
to_dir_ie = inv[to_dir_id]
1172
if to_dir_ie.kind not in ('directory', 'root_directory'):
1173
raise BzrError("destination %r is not a directory" % to_abs)
1174
1175
to_idpath = inv.get_idpath(to_dir_id)
1176
1177
for f in from_paths:
1178
if not tree.has_filename(f):
1179
raise BzrError("%r does not exist in working tree" % f)
1180
f_id = inv.path2id(f)
1181
if f_id == None:
1182
raise BzrError("%r is not versioned" % f)
1183
name_tail = splitpath(f)[-1]
1184
dest_path = appendpath(to_name, name_tail)
1185
if tree.has_filename(dest_path):
1186
raise BzrError("destination %r already exists" % dest_path)
1187
if f_id in to_idpath:
1188
raise BzrError("can't move %r to a subdirectory of itself" % f)
1189
1190
# OK, so there's a race here, it's possible that someone will
1191
# create a file in this interval and then the rename might be
1192
# left half-done. But we should have caught most problems.
1193
1194
for f in from_paths:
1195
name_tail = splitpath(f)[-1]
1196
dest_path = appendpath(to_name, name_tail)
1197
print "%s => %s" % (f, dest_path)
1198
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1199
try:
1200
os.rename(self.abspath(f), self.abspath(dest_path))
1201
except OSError, e:
1202
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1203
["rename rolled back"])
1204
1205
self._write_inventory(inv)
1206
finally:
1207
self.unlock()
1208
1209
1210
def revert(self, filenames, old_tree=None, backups=True):
1211
"""Restore selected files to the versions from a previous tree.
1212
1213
backups
1214
If true (default) backups are made of files before
1215
they're renamed.
1216
"""
1217
from bzrlib.errors import NotVersionedError, BzrError
1218
from bzrlib.atomicfile import AtomicFile
1219
from bzrlib.osutils import backup_file
1220
1221
inv = self.read_working_inventory()
1222
if old_tree is None:
1223
old_tree = self.basis_tree()
1224
old_inv = old_tree.inventory
1225
1226
nids = []
1227
for fn in filenames:
1228
file_id = inv.path2id(fn)
1229
if not file_id:
1230
raise NotVersionedError("not a versioned file", fn)
1231
if not old_inv.has_id(file_id):
1232
raise BzrError("file not present in old tree", fn, file_id)
1233
nids.append((fn, file_id))
1234
1235
# TODO: Rename back if it was previously at a different location
1236
1237
# TODO: If given a directory, restore the entire contents from
1238
# the previous version.
1239
1240
# TODO: Make a backup to a temporary file.
1241
1242
# TODO: If the file previously didn't exist, delete it?
1243
for fn, file_id in nids:
1244
backup_file(fn)
1245
1246
f = AtomicFile(fn, 'wb')
1247
try:
1248
f.write(old_tree.get_file(file_id).read())
1249
f.commit()
1250
finally:
1251
f.close()
1252
1253
1254
def pending_merges(self):
1255
"""Return a list of pending merges.
1256
1257
These are revisions that have been merged into the working
1258
directory but not yet committed.
1259
"""
1260
cfn = self.controlfilename('pending-merges')
1261
if not os.path.exists(cfn):
1262
return []
1263
p = []
1264
for l in self.controlfile('pending-merges', 'r').readlines():
1265
p.append(l.rstrip('\n'))
1266
return p
1267
1268
1269
def add_pending_merge(self, revision_id):
1270
from bzrlib.revision import validate_revision_id
1271
1272
validate_revision_id(revision_id)
1273
1274
p = self.pending_merges()
1275
if revision_id in p:
1276
return
1277
p.append(revision_id)
1278
self.set_pending_merges(p)
1279
1280
1281
def set_pending_merges(self, rev_list):
1282
from bzrlib.atomicfile import AtomicFile
1283
self.lock_write()
1284
try:
1285
f = AtomicFile(self.controlfilename('pending-merges'))
1286
try:
1287
for l in rev_list:
1288
print >>f, l
1289
f.commit()
1290
finally:
1291
f.close()
1292
finally:
1293
self.unlock()
1294
610
def write_log(self, utc=False):
611
"""Write out human-readable log of commits to this branch
612
613
:param utc: If true, show dates in universal time, not local time."""
614
revno = 1
615
precursor = None
616
for p in self.revision_history():
617
print '-' * 40
618
print 'revno:', revno
619
## TODO: Show hash if --id is given.
620
##print 'revision-hash:', p
621
rev = self.get_revision(p)
622
print 'committer:', rev.committer
623
print 'timestamp: %s' % (format_date(rev.timestamp, utc))
624
625
## opportunistic consistency check, same as check_patch_chaining
626
if rev.precursor != precursor:
627
bailout("mismatched precursor!")
628
629
print 'message:'
630
if not rev.message:
631
print ' (no message)'
632
else:
633
for l in rev.message.split('\n'):
634
print ' ' + l
635
636
revno += 1
637
precursor = p
638
639
640
641
def show_status(branch, show_all=False):
642
"""Display single-line status for non-ignored working files.
643
644
The list is show sorted in order by file name.
645
646
>>> b = ScratchBranch(files=['foo', 'foo~'])
647
>>> b.show_status()
648
? foo
649
>>> b.add('foo')
650
>>> b.show_status()
651
A foo
652
>>> b.commit("add foo")
653
>>> b.show_status()
654
655
:todo: Get state for single files.
656
657
:todo: Perhaps show a slash at the end of directory names.
658
659
"""
660
661
# We have to build everything into a list first so that it can
662
# sorted by name, incorporating all the different sources.
663
664
# FIXME: Rather than getting things in random order and then sorting,
665
# just step through in order.
666
667
# Interesting case: the old ID for a file has been removed,
668
# but a new file has been created under that name.
669
670
old = branch.basis_tree()
671
old_inv = old.inventory
672
new = branch.working_tree()
673
new_inv = new.inventory
674
675
for fs, fid, oldname, newname, kind in diff_trees(old, new):
676
if fs == 'R':
677
show_status(fs, kind,
678
oldname + ' => ' + newname)
679
elif fs == 'A' or fs == 'M':
680
show_status(fs, kind, newname)
681
elif fs == 'D':
682
show_status(fs, kind, oldname)
683
elif fs == '.':
684
if show_all:
685
show_status(fs, kind, newname)
686
elif fs == 'I':
687
if show_all:
688
show_status(fs, kind, newname)
689
elif fs == '?':
690
show_status(fs, kind, newname)
691
else:
692
bailout("wierd file state %r" % ((fs, fid),))
693
1295
694
1296
695
1297
696
class ScratchBranch(Branch):
1301
700
>>> isdir(b.base)
1302
701
True
1303
702
>>> bd = b.base
1304
>>> b.destroy()
703
>>> del b
1305
704
>>> isdir(bd)
1306
705
False
1307
706
"""
1308
def __init__(self, files=[], dirs=[], base=None):
707
def __init__(self, files = []):
1309
708
"""Make a test branch.
1310
709
1311
710
This creates a temporary directory and runs init-tree in it.
1312
711
1313
712
If any files are listed, they are created in the working copy.
1314
713
"""
1315
from tempfile import mkdtemp
1316
init = False
1317
if base is None:
1318
base = mkdtemp()
1319
init = True
1320
Branch.__init__(self, base, init=init)
1321
for d in dirs:
1322
os.mkdir(self.abspath(d))
1323
714
Branch.__init__(self, tempfile.mkdtemp(), init=True)
1324
715
for f in files:
1325
716
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
1326
717
1327
718
1328
def clone(self):
1329
"""
1330
>>> orig = ScratchBranch(files=["file1", "file2"])
1331
>>> clone = orig.clone()
1332
>>> os.path.samefile(orig.base, clone.base)
1333
False
1334
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1335
True
1336
"""
1337
from shutil import copytree
1338
from tempfile import mkdtemp
1339
base = mkdtemp()
1340
os.rmdir(base)
1341
copytree(self.base, base, symlinks=True)
1342
return ScratchBranch(base=base)
1343
1344
719
def __del__(self):
1345
self.destroy()
1346
1347
def destroy(self):
1348
720
"""Destroy the test branch, removing the scratch directory."""
1349
from shutil import rmtree
1350
try:
1351
if self.base:
1352
mutter("delete ScratchBranch %s" % self.base)
1353
rmtree(self.base)
1354
except OSError, e:
1355
# Work around for shutil.rmtree failing on Windows when
1356
# readonly files are encountered
1357
mutter("hit exception in destroying ScratchBranch: %s" % e)
1358
for root, dirs, files in os.walk(self.base, topdown=False):
1359
for name in files:
1360
os.chmod(os.path.join(root, name), 0700)
1361
rmtree(self.base)
1362
self.base = None
721
shutil.rmtree(self.base)
1363
722
1364
723
1365
724
1375
734
## mutter('check %r for control file' % ((head, tail), ))
1376
735
if tail == bzrlib.BZRDIR:
1377
736
return True
1378
if filename == head:
1379
break
1380
737
filename = head
1381
738
return False
1382
739
1383
740
1384
741
1385
def gen_file_id(name):
742
def _gen_revision_id(when):
743
"""Return new revision-id."""
744
s = '%s-%s-' % (user_email(), compact_date(when))
745
s += hexlify(rand_bytes(8))
746
return s
747
748
749
def _gen_file_id(name):
1386
750
"""Return new file id.
1387
751
1388
752
This should probably generate proper UUIDs, but for the moment we
1389
753
cope with just randomness because running uuidgen every time is
1390
754
slow."""
1391
import re
1392
from binascii import hexlify
1393
from time import time
1394
1395
# get last component
1396
idx = name.rfind('/')
1397
if idx != -1:
1398
name = name[idx+1 : ]
1399
idx = name.rfind('\\')
1400
if idx != -1:
1401
name = name[idx+1 : ]
1402
1403
# make it not a hidden file
1404
name = name.lstrip('.')
1405
1406
# remove any wierd characters; we don't escape them but rather
1407
# just pull them out
1408
name = re.sub(r'[^\w.]', '', name)
1409
755
assert '/' not in name
756
while name[0] == '.':
757
name = name[1:]
1410
758
s = hexlify(rand_bytes(8))
1411
return '-'.join((name, compact_date(time()), s))
1412
1413
1414
def gen_root_id():
1415
"""Return a new tree-root file id."""
1416
return gen_file_id('TREE_ROOT')
759
return '-'.join((name, compact_date(time.time()), s))
760
1417
761
Loggerhead is a web-based interface for Breezy
Version: 2.0.1