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