« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 254
- compare with another revision
- download diff
- download tarball
- view history from revision 254
- Committer: Martin Pool
- Date: 2005-04-15 01:31:21 UTC
- Revision ID: mbp@sourcefrog.net-20050415013121-b18f1be12a735066
- Doc cleanups from Magnus Therning
- files added:
- bzrlib/tests.py
- files removed:
- TODO
- contrib
- contrib/bash
- contrib/zsh
- patches
- 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
18
20
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
19
21
import traceback, socket, fnmatch, difflib, time
20
22
from binascii import hexlify
22
24
import bzrlib
23
25
from inventory import Inventory
24
26
from trace import mutter, note
25
from tree import Tree, EmptyTree, RevisionTree
27
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
26
28
from inventory import InventoryEntry, Inventory
27
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
29
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, chomp, \
28
30
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
29
31
joinpath, sha_string, file_kind, local_time_offset, appendpath
30
32
from store import ImmutableStore
31
33
from revision import Revision
32
from errors import BzrError
34
from errors import bailout, BzrError
33
35
from textui import show_status
36
from diff import diff_trees
34
37
35
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
36
39
## TODO: Maybe include checks for common corruption of newlines, etc?
37
40
38
41
39
42
40
def find_branch(f, **args):
41
if f and (f.startswith('http://') or f.startswith('https://')):
42
import remotebranch
43
return remotebranch.RemoteBranch(f, **args)
44
else:
45
return Branch(f, **args)
46
47
48
49
def with_writelock(method):
50
"""Method decorator for functions run with the branch locked."""
51
def d(self, *a, **k):
52
# called with self set to the branch
53
self.lock('w')
54
try:
55
return method(self, *a, **k)
56
finally:
57
self.unlock()
58
return d
59
60
61
def with_readlock(method):
62
def d(self, *a, **k):
63
self.lock('r')
64
try:
65
return method(self, *a, **k)
66
finally:
67
self.unlock()
68
return d
69
70
71
43
def find_branch_root(f=None):
72
44
"""Find the branch root enclosing f, or pwd.
73
45
74
f may be a filename or a URL.
75
76
46
It is not necessary that f exists.
77
47
78
48
Basically we keep looking up until we find the control directory or
83
53
f = os.path.realpath(f)
84
54
else:
85
55
f = os.path.abspath(f)
86
if not os.path.exists(f):
87
raise BzrError('%r does not exist' % f)
88
89
56
90
57
orig_f = f
91
58
103
70
######################################################################
104
71
# branch objects
105
72
106
class Branch(object):
73
class Branch:
107
74
"""Branch holding a history of revisions.
108
75
109
base
110
Base directory of the branch.
111
112
_lock_mode
113
None, or 'r' or 'w'
114
115
_lock_count
116
If _lock_mode is true, a positive count of the number of times the
117
lock has been taken.
118
119
_lockfile
120
Open file used for locking.
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.
121
88
"""
122
base = None
123
_lock_mode = None
124
_lock_count = None
125
126
89
def __init__(self, base, init=False, find_root=True):
127
90
"""Create new branch object at a particular location.
128
91
146
109
else:
147
110
self.base = os.path.realpath(base)
148
111
if not isdir(self.controlfilename('.')):
149
from errors import NotBranchError
150
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
151
['use "bzr init" to initialize a new working tree',
152
'current bzr can only operate from top-of-tree'])
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'])
153
115
self._check_format()
154
self._lockfile = self.controlfile('branch-lock', 'wb')
155
116
156
117
self.text_store = ImmutableStore(self.controlfilename('text-store'))
157
118
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
165
126
__repr__ = __str__
166
127
167
128
168
def __del__(self):
169
if self._lock_mode:
170
from warnings import warn
171
warn("branch %r was not explicitly unlocked" % self)
172
self.unlock()
173
174
175
def lock(self, mode):
176
if self._lock_mode:
177
if mode == 'w' and cur_lm == 'r':
178
raise BzrError("can't upgrade to a write lock")
179
180
assert self._lock_count >= 1
181
self._lock_count += 1
182
else:
183
from bzrlib.lock import lock, LOCK_SH, LOCK_EX
184
if mode == 'r':
185
m = LOCK_SH
186
elif mode == 'w':
187
m = LOCK_EX
188
else:
189
raise ValueError('invalid lock mode %r' % mode)
190
191
lock(self._lockfile, m)
192
self._lock_mode = mode
193
self._lock_count = 1
194
195
196
def unlock(self):
197
if not self._lock_mode:
198
raise BzrError('branch %r is not locked' % (self))
199
200
if self._lock_count > 1:
201
self._lock_count -= 1
202
else:
203
assert self._lock_count == 1
204
from bzrlib.lock import unlock
205
unlock(self._lockfile)
206
self._lock_mode = self._lock_count = None
207
208
209
129
def abspath(self, name):
210
130
"""Return absolute filename for something in the branch"""
211
131
return os.path.join(self.base, name)
218
138
rp = os.path.realpath(path)
219
139
# FIXME: windows
220
140
if not rp.startswith(self.base):
221
from errors import NotBranchError
222
raise NotBranchError("path %r is not within branch %r" % (rp, self.base))
141
bailout("path %r is not within branch %r" % (rp, self.base))
223
142
rp = rp[len(self.base):]
224
143
rp = rp.lstrip(os.sep)
225
144
return rp
239
158
and binary. binary files are untranslated byte streams. Text
240
159
control files are stored with Unix newlines and in UTF-8, even
241
160
if the platform or locale defaults are different.
242
243
Controlfiles should almost never be opened in write mode but
244
rather should be atomically copied and replaced using atomicfile.
245
161
"""
246
162
247
163
fn = self.controlfilename(file_or_path)
249
165
if mode == 'rb' or mode == 'wb':
250
166
return file(fn, mode)
251
167
elif mode == 'r' or mode == 'w':
252
# open in binary mode anyhow so there's no newline translation;
253
# codecs uses line buffering by default; don't want that.
168
# open in binary mode anyhow so there's no newline translation
254
169
import codecs
255
return codecs.open(fn, mode + 'b', 'utf-8',
256
buffering=60000)
170
return codecs.open(fn, mode + 'b', 'utf-8')
257
171
else:
258
172
raise BzrError("invalid controlfile mode %r" % mode)
259
173
268
182
for d in ('text-store', 'inventory-store', 'revision-store'):
269
183
os.mkdir(self.controlfilename(d))
270
184
for f in ('revision-history', 'merged-patches',
271
'pending-merged-patches', 'branch-name',
272
'branch-lock'):
185
'pending-merged-patches', 'branch-name'):
273
186
self.controlfile(f, 'w').write('')
274
187
mutter('created control directory in ' + self.base)
275
188
Inventory().write_xml(self.controlfile('inventory','w'))
289
202
fmt = self.controlfile('branch-format', 'r').read()
290
203
fmt.replace('\r\n', '')
291
204
if fmt != BZR_BRANCH_FORMAT:
292
raise BzrError('sorry, branch format %r not supported' % fmt,
293
['use a different bzr version',
294
'or remove the .bzr directory and "bzr init" again'])
295
296
297
298
@with_readlock
205
bailout('sorry, branch format %r not supported' % fmt,
206
['use a different bzr version',
207
'or remove the .bzr directory and "bzr init" again'])
208
209
299
210
def read_working_inventory(self):
300
211
"""Read the working inventory."""
301
212
before = time.time()
305
216
mutter("loaded inventory of %d items in %f"
306
217
% (len(inv), time.time() - before))
307
218
return inv
308
219
309
220
310
221
def _write_inventory(self, inv):
311
222
"""Update the working inventory.
324
235
os.remove(inv_fname)
325
236
os.rename(tmpfname, inv_fname)
326
237
mutter('wrote working inventory')
327
238
328
239
329
240
inventory = property(read_working_inventory, _write_inventory, None,
330
241
"""Inventory for the working copy.""")
331
242
332
243
333
@with_writelock
334
def add(self, files, verbose=False, ids=None):
244
def add(self, files, verbose=False):
335
245
"""Make files versioned.
336
246
337
247
Note that the command line normally calls smart_add instead.
350
260
TODO: Adding a directory should optionally recurse down and
351
261
add all non-ignored children. Perhaps do that in a
352
262
higher-level method.
263
264
>>> b = ScratchBranch(files=['foo'])
265
>>> 'foo' in b.unknowns()
266
True
267
>>> b.show_status()
268
? foo
269
>>> b.add('foo')
270
>>> 'foo' in b.unknowns()
271
False
272
>>> bool(b.inventory.path2id('foo'))
273
True
274
>>> b.show_status()
275
A foo
276
277
>>> b.add('foo')
278
Traceback (most recent call last):
279
...
280
BzrError: ('foo is already versioned', [])
281
282
>>> b.add(['nothere'])
283
Traceback (most recent call last):
284
BzrError: ('cannot add: not a regular file or directory: nothere', [])
353
285
"""
286
354
287
# TODO: Re-adding a file that is removed in the working copy
355
288
# should probably put it back with the previous ID.
356
289
if isinstance(files, types.StringTypes):
357
assert(ids is None or isinstance(ids, types.StringTypes))
358
290
files = [files]
359
if ids is not None:
360
ids = [ids]
361
362
if ids is None:
363
ids = [None] * len(files)
364
else:
365
assert(len(ids) == len(files))
366
291
367
292
inv = self.read_working_inventory()
368
for f,file_id in zip(files, ids):
293
for f in files:
369
294
if is_control_file(f):
370
raise BzrError("cannot add control file %s" % quotefn(f))
295
bailout("cannot add control file %s" % quotefn(f))
371
296
372
297
fp = splitpath(f)
373
298
374
299
if len(fp) == 0:
375
raise BzrError("cannot add top-level %r" % f)
376
300
bailout("cannot add top-level %r" % f)
301
377
302
fullpath = os.path.normpath(self.abspath(f))
378
303
379
304
try:
380
305
kind = file_kind(fullpath)
381
306
except OSError:
382
307
# maybe something better?
383
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
384
308
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
309
385
310
if kind != 'file' and kind != 'directory':
386
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
311
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
387
312
388
if file_id is None:
389
file_id = gen_file_id(f)
313
file_id = gen_file_id(f)
390
314
inv.add_path(f, kind=kind, file_id=file_id)
391
315
392
316
if verbose:
393
317
show_status('A', kind, quotefn(f))
394
318
395
319
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
396
320
397
321
self._write_inventory(inv)
398
322
399
323
400
324
def print_file(self, file, revno):
401
325
"""Print `file` to stdout."""
403
327
# use inventory as it was in that revision
404
328
file_id = tree.inventory.path2id(file)
405
329
if not file_id:
406
raise BzrError("%r is not present in revision %d" % (file, revno))
330
bailout("%r is not present in revision %d" % (file, revno))
407
331
tree.print_file(file_id)
408
409
410
@with_writelock
332
333
411
334
def remove(self, files, verbose=False):
412
335
"""Mark nominated files for removal from the inventory.
413
336
415
338
416
339
TODO: Refuse to remove modified files unless --force is given?
417
340
341
>>> b = ScratchBranch(files=['foo'])
342
>>> b.add('foo')
343
>>> b.inventory.has_filename('foo')
344
True
345
>>> b.remove('foo')
346
>>> b.working_tree().has_filename('foo')
347
True
348
>>> b.inventory.has_filename('foo')
349
False
350
351
>>> b = ScratchBranch(files=['foo'])
352
>>> b.add('foo')
353
>>> b.commit('one')
354
>>> b.remove('foo')
355
>>> b.commit('two')
356
>>> b.inventory.has_filename('foo')
357
False
358
>>> b.basis_tree().has_filename('foo')
359
False
360
>>> b.working_tree().has_filename('foo')
361
True
362
418
363
TODO: Do something useful with directories.
419
364
420
365
TODO: Should this remove the text or not? Tough call; not
424
369
"""
425
370
## TODO: Normalize names
426
371
## TODO: Remove nested loops; better scalability
372
427
373
if isinstance(files, types.StringTypes):
428
374
files = [files]
429
375
430
376
tree = self.working_tree()
431
377
inv = tree.inventory
432
378
434
380
for f in files:
435
381
fid = inv.path2id(f)
436
382
if not fid:
437
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
383
bailout("cannot remove unversioned file %s" % quotefn(f))
438
384
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
439
385
if verbose:
440
386
# having remove it, it must be either ignored or unknown
448
394
self._write_inventory(inv)
449
395
450
396
451
def set_inventory(self, new_inventory_list):
452
inv = Inventory()
453
for path, file_id, parent, kind in new_inventory_list:
454
name = os.path.basename(path)
455
if name == "":
456
continue
457
inv.add(InventoryEntry(file_id, name, kind, parent))
458
self._write_inventory(inv)
459
460
461
397
def unknowns(self):
462
398
"""Return all unknown files.
463
399
477
413
return self.working_tree().unknowns()
478
414
479
415
416
def commit(self, message, timestamp=None, timezone=None,
417
committer=None,
418
verbose=False):
419
"""Commit working copy as a new revision.
420
421
The basic approach is to add all the file texts into the
422
store, then the inventory, then make a new revision pointing
423
to that inventory and store that.
424
425
This is not quite safe if the working copy changes during the
426
commit; for the moment that is simply not allowed. A better
427
approach is to make a temporary copy of the files before
428
computing their hashes, and then add those hashes in turn to
429
the inventory. This should mean at least that there are no
430
broken hash pointers. There is no way we can get a snapshot
431
of the whole directory at an instant. This would also have to
432
be robust against files disappearing, moving, etc. So the
433
whole thing is a bit hard.
434
435
timestamp -- if not None, seconds-since-epoch for a
436
postdated/predated commit.
437
"""
438
439
## TODO: Show branch names
440
441
# TODO: Don't commit if there are no changes, unless forced?
442
443
# First walk over the working inventory; and both update that
444
# and also build a new revision inventory. The revision
445
# inventory needs to hold the text-id, sha1 and size of the
446
# actual file versions committed in the revision. (These are
447
# not present in the working inventory.) We also need to
448
# detect missing/deleted files, and remove them from the
449
# working inventory.
450
451
work_inv = self.read_working_inventory()
452
inv = Inventory()
453
basis = self.basis_tree()
454
basis_inv = basis.inventory
455
missing_ids = []
456
for path, entry in work_inv.iter_entries():
457
## TODO: Cope with files that have gone missing.
458
459
## TODO: Check that the file kind has not changed from the previous
460
## revision of this file (if any).
461
462
entry = entry.copy()
463
464
p = self.abspath(path)
465
file_id = entry.file_id
466
mutter('commit prep file %s, id %r ' % (p, file_id))
467
468
if not os.path.exists(p):
469
mutter(" file is missing, removing from inventory")
470
if verbose:
471
show_status('D', entry.kind, quotefn(path))
472
missing_ids.append(file_id)
473
continue
474
475
# TODO: Handle files that have been deleted
476
477
# TODO: Maybe a special case for empty files? Seems a
478
# waste to store them many times.
479
480
inv.add(entry)
481
482
if basis_inv.has_id(file_id):
483
old_kind = basis_inv[file_id].kind
484
if old_kind != entry.kind:
485
bailout("entry %r changed kind from %r to %r"
486
% (file_id, old_kind, entry.kind))
487
488
if entry.kind == 'directory':
489
if not isdir(p):
490
bailout("%s is entered as directory but not a directory" % quotefn(p))
491
elif entry.kind == 'file':
492
if not isfile(p):
493
bailout("%s is entered as file but is not a file" % quotefn(p))
494
495
content = file(p, 'rb').read()
496
497
entry.text_sha1 = sha_string(content)
498
entry.text_size = len(content)
499
500
old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
501
if (old_ie
502
and (old_ie.text_size == entry.text_size)
503
and (old_ie.text_sha1 == entry.text_sha1)):
504
## assert content == basis.get_file(file_id).read()
505
entry.text_id = basis_inv[file_id].text_id
506
mutter(' unchanged from previous text_id {%s}' %
507
entry.text_id)
508
509
else:
510
entry.text_id = gen_file_id(entry.name)
511
self.text_store.add(content, entry.text_id)
512
mutter(' stored with text_id {%s}' % entry.text_id)
513
if verbose:
514
if not old_ie:
515
state = 'A'
516
elif (old_ie.name == entry.name
517
and old_ie.parent_id == entry.parent_id):
518
state = 'M'
519
else:
520
state = 'R'
521
522
show_status(state, entry.kind, quotefn(path))
523
524
for file_id in missing_ids:
525
# have to do this later so we don't mess up the iterator.
526
# since parents may be removed before their children we
527
# have to test.
528
529
# FIXME: There's probably a better way to do this; perhaps
530
# the workingtree should know how to filter itself.
531
if work_inv.has_id(file_id):
532
del work_inv[file_id]
533
534
535
inv_id = rev_id = _gen_revision_id(time.time())
536
537
inv_tmp = tempfile.TemporaryFile()
538
inv.write_xml(inv_tmp)
539
inv_tmp.seek(0)
540
self.inventory_store.add(inv_tmp, inv_id)
541
mutter('new inventory_id is {%s}' % inv_id)
542
543
self._write_inventory(work_inv)
544
545
if timestamp == None:
546
timestamp = time.time()
547
548
if committer == None:
549
committer = username()
550
551
if timezone == None:
552
timezone = local_time_offset()
553
554
mutter("building commit log message")
555
rev = Revision(timestamp=timestamp,
556
timezone=timezone,
557
committer=committer,
558
precursor = self.last_patch(),
559
message = message,
560
inventory_id=inv_id,
561
revision_id=rev_id)
562
563
rev_tmp = tempfile.TemporaryFile()
564
rev.write_xml(rev_tmp)
565
rev_tmp.seek(0)
566
self.revision_store.add(rev_tmp, rev_id)
567
mutter("new revision_id is {%s}" % rev_id)
568
569
## XXX: Everything up to here can simply be orphaned if we abort
570
## the commit; it will leave junk files behind but that doesn't
571
## matter.
572
573
## TODO: Read back the just-generated changeset, and make sure it
574
## applies and recreates the right state.
575
576
## TODO: Also calculate and store the inventory SHA1
577
mutter("committing patch r%d" % (self.revno() + 1))
578
579
580
self.append_revision(rev_id)
581
582
if verbose:
583
note("commited r%d" % self.revno())
584
585
480
586
def append_revision(self, revision_id):
481
587
mutter("add {%s} to revision-history" % revision_id)
482
588
rev_history = self.revision_history()
521
627
return self.get_inventory(self.get_revision(revision_id).inventory_id)
522
628
523
629
524
@with_readlock
525
630
def revision_history(self):
526
631
"""Return sequence of revision hashes on to this branch.
527
632
528
633
>>> ScratchBranch().revision_history()
529
634
[]
530
635
"""
531
return [l.rstrip('\r\n') for l in self.controlfile('revision-history', 'r').readlines()]
532
533
534
def enum_history(self, direction):
535
"""Return (revno, revision_id) for history of branch.
536
537
direction
538
'forward' is from earliest to latest
539
'reverse' is from latest to earliest
540
"""
541
rh = self.revision_history()
542
if direction == 'forward':
543
i = 1
544
for rid in rh:
545
yield i, rid
546
i += 1
547
elif direction == 'reverse':
548
i = len(rh)
549
while i > 0:
550
yield i, rh[i-1]
551
i -= 1
552
else:
553
raise ValueError('invalid history direction', direction)
636
return [chomp(l) for l in self.controlfile('revision-history', 'r').readlines()]
554
637
555
638
556
639
def revno(self):
558
641
559
642
That is equivalent to the number of revisions committed to
560
643
this branch.
644
645
>>> b = ScratchBranch()
646
>>> b.revno()
647
0
648
>>> b.commit('no foo')
649
>>> b.revno()
650
1
561
651
"""
562
652
return len(self.revision_history())
563
653
564
654
565
655
def last_patch(self):
566
656
"""Return last patch hash, or None if no history.
657
658
>>> ScratchBranch().last_patch() == None
659
True
567
660
"""
568
661
ph = self.revision_history()
569
662
if ph:
570
663
return ph[-1]
571
664
else:
572
665
return None
573
574
575
def commit(self, *args, **kw):
576
"""Deprecated"""
577
from bzrlib.commit import commit
578
commit(self, *args, **kw)
579
666
580
667
581
668
def lookup_revision(self, revno):
595
682
596
683
`revision_id` may be None for the null revision, in which case
597
684
an `EmptyTree` is returned."""
598
# TODO: refactor this to use an existing revision object
599
# so we don't need to read it in twice.
685
600
686
if revision_id == None:
601
687
return EmptyTree()
602
688
else:
606
692
607
693
def working_tree(self):
608
694
"""Return a `Tree` for the working copy."""
609
from workingtree import WorkingTree
610
695
return WorkingTree(self.base, self.read_working_inventory())
611
696
612
697
614
699
"""Return `Tree` object for last revision.
615
700
616
701
If there are no revisions yet, return an `EmptyTree`.
702
703
>>> b = ScratchBranch(files=['foo'])
704
>>> b.basis_tree().has_filename('foo')
705
False
706
>>> b.working_tree().has_filename('foo')
707
True
708
>>> b.add('foo')
709
>>> b.commit('add foo')
710
>>> b.basis_tree().has_filename('foo')
711
True
617
712
"""
618
713
r = self.last_patch()
619
714
if r == None:
623
718
624
719
625
720
626
@with_writelock
721
def write_log(self, show_timezone='original', verbose=False):
722
"""Write out human-readable log of commits to this branch
723
724
utc -- If true, show dates in universal time, not local time."""
725
## TODO: Option to choose either original, utc or local timezone
726
revno = 1
727
precursor = None
728
for p in self.revision_history():
729
print '-' * 40
730
print 'revno:', revno
731
## TODO: Show hash if --id is given.
732
##print 'revision-hash:', p
733
rev = self.get_revision(p)
734
print 'committer:', rev.committer
735
print 'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
736
show_timezone))
737
738
## opportunistic consistency check, same as check_patch_chaining
739
if rev.precursor != precursor:
740
bailout("mismatched precursor!")
741
742
print 'message:'
743
if not rev.message:
744
print ' (no message)'
745
else:
746
for l in rev.message.split('\n'):
747
print ' ' + l
748
749
if verbose == True and precursor != None:
750
print 'changed files:'
751
tree = self.revision_tree(p)
752
prevtree = self.revision_tree(precursor)
753
754
for file_state, fid, old_name, new_name, kind in \
755
diff_trees(prevtree, tree, ):
756
if file_state == 'A' or file_state == 'M':
757
show_status(file_state, kind, new_name)
758
elif file_state == 'D':
759
show_status(file_state, kind, old_name)
760
elif file_state == 'R':
761
show_status(file_state, kind,
762
old_name + ' => ' + new_name)
763
764
revno += 1
765
precursor = p
766
767
627
768
def rename_one(self, from_rel, to_rel):
628
"""Rename one file.
629
630
This can change the directory or the filename or both.
631
"""
632
769
tree = self.working_tree()
633
770
inv = tree.inventory
634
771
if not tree.has_filename(from_rel):
635
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
772
bailout("can't rename: old working file %r does not exist" % from_rel)
636
773
if tree.has_filename(to_rel):
637
raise BzrError("can't rename: new working file %r already exists" % to_rel)
638
774
bailout("can't rename: new working file %r already exists" % to_rel)
775
639
776
file_id = inv.path2id(from_rel)
640
777
if file_id == None:
641
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
778
bailout("can't rename: old name %r is not versioned" % from_rel)
642
779
643
780
if inv.path2id(to_rel):
644
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
781
bailout("can't rename: new name %r is already versioned" % to_rel)
645
782
646
783
to_dir, to_tail = os.path.split(to_rel)
647
784
to_dir_id = inv.path2id(to_dir)
648
785
if to_dir_id == None and to_dir != '':
649
raise BzrError("can't determine destination directory id for %r" % to_dir)
786
bailout("can't determine destination directory id for %r" % to_dir)
650
787
651
788
mutter("rename_one:")
652
789
mutter(" file_id {%s}" % file_id)
654
791
mutter(" to_rel %r" % to_rel)
655
792
mutter(" to_dir %r" % to_dir)
656
793
mutter(" to_dir_id {%s}" % to_dir_id)
657
794
658
795
inv.rename(file_id, to_dir_id, to_tail)
659
796
660
797
print "%s => %s" % (from_rel, to_rel)
661
798
662
799
from_abs = self.abspath(from_rel)
663
800
to_abs = self.abspath(to_rel)
664
801
try:
665
802
os.rename(from_abs, to_abs)
666
803
except OSError, e:
667
raise BzrError("failed to rename %r to %r: %s"
804
bailout("failed to rename %r to %r: %s"
668
805
% (from_abs, to_abs, e[1]),
669
806
["rename rolled back"])
670
807
671
808
self._write_inventory(inv)
672
673
674
675
@with_writelock
809
810
811
676
812
def move(self, from_paths, to_name):
677
813
"""Rename files.
678
814
690
826
inv = tree.inventory
691
827
to_abs = self.abspath(to_name)
692
828
if not isdir(to_abs):
693
raise BzrError("destination %r is not a directory" % to_abs)
829
bailout("destination %r is not a directory" % to_abs)
694
830
if not tree.has_filename(to_name):
695
raise BzrError("destination %r not in working directory" % to_abs)
831
bailout("destination %r not in working directory" % to_abs)
696
832
to_dir_id = inv.path2id(to_name)
697
833
if to_dir_id == None and to_name != '':
698
raise BzrError("destination %r is not a versioned directory" % to_name)
834
bailout("destination %r is not a versioned directory" % to_name)
699
835
to_dir_ie = inv[to_dir_id]
700
836
if to_dir_ie.kind not in ('directory', 'root_directory'):
701
raise BzrError("destination %r is not a directory" % to_abs)
837
bailout("destination %r is not a directory" % to_abs)
702
838
703
to_idpath = inv.get_idpath(to_dir_id)
839
to_idpath = Set(inv.get_idpath(to_dir_id))
704
840
705
841
for f in from_paths:
706
842
if not tree.has_filename(f):
707
raise BzrError("%r does not exist in working tree" % f)
843
bailout("%r does not exist in working tree" % f)
708
844
f_id = inv.path2id(f)
709
845
if f_id == None:
710
raise BzrError("%r is not versioned" % f)
846
bailout("%r is not versioned" % f)
711
847
name_tail = splitpath(f)[-1]
712
848
dest_path = appendpath(to_name, name_tail)
713
849
if tree.has_filename(dest_path):
714
raise BzrError("destination %r already exists" % dest_path)
850
bailout("destination %r already exists" % dest_path)
715
851
if f_id in to_idpath:
716
raise BzrError("can't move %r to a subdirectory of itself" % f)
852
bailout("can't move %r to a subdirectory of itself" % f)
717
853
718
854
# OK, so there's a race here, it's possible that someone will
719
855
# create a file in this interval and then the rename might be
727
863
try:
728
864
os.rename(self.abspath(f), self.abspath(dest_path))
729
865
except OSError, e:
730
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
866
bailout("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
731
867
["rename rolled back"])
732
868
733
869
self._write_inventory(inv)
734
870
735
871
736
872
873
def show_status(self, show_all=False):
874
"""Display single-line status for non-ignored working files.
875
876
The list is show sorted in order by file name.
877
878
>>> b = ScratchBranch(files=['foo', 'foo~'])
879
>>> b.show_status()
880
? foo
881
>>> b.add('foo')
882
>>> b.show_status()
883
A foo
884
>>> b.commit("add foo")
885
>>> b.show_status()
886
>>> os.unlink(b.abspath('foo'))
887
>>> b.show_status()
888
D foo
889
890
891
TODO: Get state for single files.
892
893
TODO: Perhaps show a slash at the end of directory names.
894
895
"""
896
897
# We have to build everything into a list first so that it can
898
# sorted by name, incorporating all the different sources.
899
900
# FIXME: Rather than getting things in random order and then sorting,
901
# just step through in order.
902
903
# Interesting case: the old ID for a file has been removed,
904
# but a new file has been created under that name.
905
906
old = self.basis_tree()
907
new = self.working_tree()
908
909
for fs, fid, oldname, newname, kind in diff_trees(old, new):
910
if fs == 'R':
911
show_status(fs, kind,
912
oldname + ' => ' + newname)
913
elif fs == 'A' or fs == 'M':
914
show_status(fs, kind, newname)
915
elif fs == 'D':
916
show_status(fs, kind, oldname)
917
elif fs == '.':
918
if show_all:
919
show_status(fs, kind, newname)
920
elif fs == 'I':
921
if show_all:
922
show_status(fs, kind, newname)
923
elif fs == '?':
924
show_status(fs, kind, newname)
925
else:
926
bailout("weird file state %r" % ((fs, fid),))
927
928
737
929
738
930
class ScratchBranch(Branch):
739
931
"""Special test class: a branch that cleans up after itself.
742
934
>>> isdir(b.base)
743
935
True
744
936
>>> bd = b.base
745
>>> b.destroy()
937
>>> del b
746
938
>>> isdir(bd)
747
939
False
748
940
"""
762
954
763
955
764
956
def __del__(self):
765
self.destroy()
766
767
def destroy(self):
768
957
"""Destroy the test branch, removing the scratch directory."""
769
958
try:
770
mutter("delete ScratchBranch %s" % self.base)
771
959
shutil.rmtree(self.base)
772
except OSError, e:
960
except OSError:
773
961
# Work around for shutil.rmtree failing on Windows when
774
962
# readonly files are encountered
775
mutter("hit exception in destroying ScratchBranch: %s" % e)
776
963
for root, dirs, files in os.walk(self.base, topdown=False):
777
964
for name in files:
778
965
os.chmod(os.path.join(root, name), 0700)
779
966
shutil.rmtree(self.base)
780
self.base = None
781
967
782
968
783
969
800
986
801
987
802
988
989
def _gen_revision_id(when):
990
"""Return new revision-id."""
991
s = '%s-%s-' % (user_email(), compact_date(when))
992
s += hexlify(rand_bytes(8))
993
return s
994
995
803
996
def gen_file_id(name):
804
997
"""Return new file id.
805
998
806
999
This should probably generate proper UUIDs, but for the moment we
807
1000
cope with just randomness because running uuidgen every time is
808
1001
slow."""
809
import re
810
811
# get last component
812
1002
idx = name.rfind('/')
813
1003
if idx != -1:
814
1004
name = name[idx+1 : ]
815
idx = name.rfind('\\')
816
if idx != -1:
817
name = name[idx+1 : ]
818
1005
819
# make it not a hidden file
820
1006
name = name.lstrip('.')
821
1007
822
# remove any wierd characters; we don't escape them but rather
823
# just pull them out
824
name = re.sub(r'[^\w.]', '', name)
825
826
1008
s = hexlify(rand_bytes(8))
827
1009
return '-'.join((name, compact_date(time.time()), s))
Loggerhead is a web-based interface for Breezy
Version: 2.0.1