« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1111
- compare with another revision
- download diff
- download tarball
- view history from revision 1111
- Committer: Martin Pool
- Date: 2005-08-25 07:46:11 UTC
- Revision ID: mbp@sourcefrog.net-20050825074611-98130ea6d05d9d2a
- add functions to enable and disable default logging, so that we can
turn it off while running the tests
- default logging gets turned on from the bzr main function so that
other applications using the library can make their own decisions
turn it off while running the tests
- default logging gets turned on from the bzr main function so that
other applications using the library can make their own decisions
- files added:
- HACKING
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- patches
- tools
- files removed:
- bzrlib/statcache.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
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
import bzrlib.ui
35
36
37
37
38
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
39
39
## TODO: Maybe include checks for common corruption of newlines, etc?
40
40
41
41
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
42
49
43
50
def find_branch(f, **args):
44
51
if f and (f.startswith('http://') or f.startswith('https://')):
46
53
return remotebranch.RemoteBranch(f, **args)
47
54
else:
48
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)
49
101
50
102
51
103
def find_branch_root(f=None):
56
108
It is not necessary that f exists.
57
109
58
110
Basically we keep looking up until we find the control directory or
59
run into the root."""
111
run into the root. If there isn't one, raises NotBranchError.
112
"""
60
113
if f == None:
61
114
f = os.getcwd()
62
115
elif hasattr(os.path, 'realpath'):
75
128
head, tail = os.path.split(f)
76
129
if head == f:
77
130
# reached the root, whatever that may be
78
raise BzrError('%r is not in a branch' % orig_f)
131
raise bzrlib.errors.NotBranchError('%s is not in a branch' % orig_f)
79
132
f = head
80
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.")
81
142
82
143
83
144
######################################################################
84
145
# branch objects
85
146
86
class Branch:
147
class Branch(object):
87
148
"""Branch holding a history of revisions.
88
149
89
150
base
90
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.
91
162
"""
92
_lockmode = None
163
base = None
164
_lock_mode = None
165
_lock_count = None
166
_lock = None
93
167
94
def __init__(self, base, init=False, find_root=True, lock_mode='w'):
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):
95
174
"""Create new branch object at a particular location.
96
175
97
176
base -- Base directory for the branch.
106
185
In the test suite, creation of new trees is tested using the
107
186
`ScratchBranch` class.
108
187
"""
188
from bzrlib.store import ImmutableStore
109
189
if init:
110
190
self.base = os.path.realpath(base)
111
191
self._make_control()
114
194
else:
115
195
self.base = os.path.realpath(base)
116
196
if not isdir(self.controlfilename('.')):
117
bailout("not a bzr branch: %s" % quotefn(base),
118
['use "bzr init" to initialize a new working tree',
119
'current bzr can only operate from top-of-tree'])
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'])
120
201
self._check_format()
121
self.lock(lock_mode)
122
202
123
203
self.text_store = ImmutableStore(self.controlfilename('text-store'))
124
204
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
132
212
__repr__ = __str__
133
213
134
214
135
136
def lock(self, mode='w'):
137
"""Lock the on-disk branch, excluding other processes."""
138
try:
139
import fcntl, errno
140
141
if mode == 'w':
142
lm = fcntl.LOCK_EX
143
om = os.O_WRONLY | os.O_CREAT
144
elif mode == 'r':
145
lm = fcntl.LOCK_SH
146
om = os.O_RDONLY
147
else:
148
raise BzrError("invalid locking mode %r" % mode)
149
150
try:
151
lockfile = os.open(self.controlfilename('branch-lock'), om)
152
except OSError, e:
153
if e.errno == errno.ENOENT:
154
# might not exist on branches from <0.0.4
155
self.controlfile('branch-lock', 'w').close()
156
lockfile = os.open(self.controlfilename('branch-lock'), om)
157
else:
158
raise e
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
159
252
160
fcntl.lockf(lockfile, lm)
161
def unlock():
162
fcntl.lockf(lockfile, fcntl.LOCK_UN)
163
os.close(lockfile)
164
self._lockmode = None
165
self.unlock = unlock
166
self._lockmode = mode
167
except ImportError:
168
warning("please write a locking method for platform %r" % sys.platform)
169
def unlock():
170
self._lockmode = None
171
self.unlock = unlock
172
self._lockmode = mode
173
174
175
def _need_readlock(self):
176
if self._lockmode not in ['r', 'w']:
177
raise BzrError('need read lock on branch, only have %r' % self._lockmode)
178
179
def _need_writelock(self):
180
if self._lockmode not in ['w']:
181
raise BzrError('need write lock on branch, only have %r' % self._lockmode)
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
182
264
183
265
184
266
def abspath(self, name):
190
272
"""Return path relative to this branch of something inside it.
191
273
192
274
Raises an error if path is not in this branch."""
193
rp = os.path.realpath(path)
194
# FIXME: windows
195
if not rp.startswith(self.base):
196
bailout("path %r is not within branch %r" % (rp, self.base))
197
rp = rp[len(self.base):]
198
rp = rp.lstrip(os.sep)
199
return rp
275
return _relpath(self.base, path)
200
276
201
277
202
278
def controlfilename(self, file_or_path):
203
279
"""Return location relative to branch."""
204
if isinstance(file_or_path, types.StringTypes):
280
if isinstance(file_or_path, basestring):
205
281
file_or_path = [file_or_path]
206
282
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
207
283
234
310
235
311
236
312
def _make_control(self):
313
from bzrlib.inventory import Inventory
314
from bzrlib.xml import pack_xml
315
237
316
os.mkdir(self.controlfilename([]))
238
317
self.controlfile('README', 'w').write(
239
318
"This is a Bazaar-NG control directory.\n"
240
"Do not change any files in this directory.")
319
"Do not change any files in this directory.\n")
241
320
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
242
321
for d in ('text-store', 'inventory-store', 'revision-store'):
243
322
os.mkdir(self.controlfilename(d))
244
323
for f in ('revision-history', 'merged-patches',
245
324
'pending-merged-patches', 'branch-name',
246
'branch-lock'):
325
'branch-lock',
326
'pending-merges'):
247
327
self.controlfile(f, 'w').write('')
248
328
mutter('created control directory in ' + self.base)
249
Inventory().write_xml(self.controlfile('inventory','w'))
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'))
250
334
251
335
252
336
def _check_format(self):
263
347
fmt = self.controlfile('branch-format', 'r').read()
264
348
fmt.replace('\r\n', '')
265
349
if fmt != BZR_BRANCH_FORMAT:
266
bailout('sorry, branch format %r not supported' % fmt,
267
['use a different bzr version',
268
'or remove the .bzr directory and "bzr init" again'])
269
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)
270
370
271
371
def read_working_inventory(self):
272
372
"""Read the working inventory."""
273
self._need_readlock()
274
before = time.time()
275
# ElementTree does its own conversion from UTF-8, so open in
276
# binary.
277
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
278
mutter("loaded inventory of %d items in %f"
279
% (len(inv), time.time() - before))
280
return inv
281
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
282
389
283
390
def _write_inventory(self, inv):
284
391
"""Update the working inventory.
286
393
That is to say, the inventory describing changes underway, that
287
394
will be committed to the next revision.
288
395
"""
289
self._need_writelock()
290
## TODO: factor out to atomicfile? is rename safe on windows?
291
## TODO: Maybe some kind of clean/dirty marker on inventory?
292
tmpfname = self.controlfilename('inventory.tmp')
293
tmpf = file(tmpfname, 'wb')
294
inv.write_xml(tmpf)
295
tmpf.close()
296
inv_fname = self.controlfilename('inventory')
297
if sys.platform == 'win32':
298
os.remove(inv_fname)
299
os.rename(tmpfname, inv_fname)
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
300
410
mutter('wrote working inventory')
301
411
302
412
303
413
inventory = property(read_working_inventory, _write_inventory, None,
304
414
"""Inventory for the working copy.""")
305
415
306
416
307
def add(self, files, verbose=False):
417
def add(self, files, verbose=False, ids=None):
308
418
"""Make files versioned.
309
419
310
420
Note that the command line normally calls smart_add instead.
312
422
This puts the files in the Added state, so that they will be
313
423
recorded by the next commit.
314
424
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
315
433
TODO: Perhaps have an option to add the ids even if the files do
316
not (yet) exist.
434
not (yet) exist.
317
435
318
436
TODO: Perhaps return the ids of the files? But then again it
319
is easy to retrieve them if they're needed.
320
321
TODO: Option to specify file id.
437
is easy to retrieve them if they're needed.
322
438
323
439
TODO: Adding a directory should optionally recurse down and
324
add all non-ignored children. Perhaps do that in a
325
higher-level method.
326
327
>>> b = ScratchBranch(files=['foo'])
328
>>> 'foo' in b.unknowns()
329
True
330
>>> b.show_status()
331
? foo
332
>>> b.add('foo')
333
>>> 'foo' in b.unknowns()
334
False
335
>>> bool(b.inventory.path2id('foo'))
336
True
337
>>> b.show_status()
338
A foo
339
340
>>> b.add('foo')
341
Traceback (most recent call last):
342
...
343
BzrError: ('foo is already versioned', [])
344
345
>>> b.add(['nothere'])
346
Traceback (most recent call last):
347
BzrError: ('cannot add: not a regular file or directory: nothere', [])
440
add all non-ignored children. Perhaps do that in a
441
higher-level method.
348
442
"""
349
self._need_writelock()
350
351
443
# TODO: Re-adding a file that is removed in the working copy
352
444
# should probably put it back with the previous ID.
353
if isinstance(files, types.StringTypes):
445
if isinstance(files, basestring):
446
assert(ids is None or isinstance(ids, basestring))
354
447
files = [files]
355
356
inv = self.read_working_inventory()
357
for f in files:
358
if is_control_file(f):
359
bailout("cannot add control file %s" % quotefn(f))
360
361
fp = splitpath(f)
362
363
if len(fp) == 0:
364
bailout("cannot add top-level %r" % f)
365
366
fullpath = os.path.normpath(self.abspath(f))
367
368
try:
369
kind = file_kind(fullpath)
370
except OSError:
371
# maybe something better?
372
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
373
374
if kind != 'file' and kind != 'directory':
375
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
376
377
file_id = gen_file_id(f)
378
inv.add_path(f, kind=kind, file_id=file_id)
379
380
if verbose:
381
show_status('A', kind, quotefn(f))
382
383
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
384
385
self._write_inventory(inv)
386
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
387
492
388
493
def print_file(self, file, revno):
389
494
"""Print `file` to stdout."""
390
self._need_readlock()
391
tree = self.revision_tree(self.lookup_revision(revno))
392
# use inventory as it was in that revision
393
file_id = tree.inventory.path2id(file)
394
if not file_id:
395
bailout("%r is not present in revision %d" % (file, revno))
396
tree.print_file(file_id)
397
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()
505
398
506
399
507
def remove(self, files, verbose=False):
400
508
"""Mark nominated files for removal from the inventory.
403
511
404
512
TODO: Refuse to remove modified files unless --force is given?
405
513
406
>>> b = ScratchBranch(files=['foo'])
407
>>> b.add('foo')
408
>>> b.inventory.has_filename('foo')
409
True
410
>>> b.remove('foo')
411
>>> b.working_tree().has_filename('foo')
412
True
413
>>> b.inventory.has_filename('foo')
414
False
415
416
>>> b = ScratchBranch(files=['foo'])
417
>>> b.add('foo')
418
>>> b.commit('one')
419
>>> b.remove('foo')
420
>>> b.commit('two')
421
>>> b.inventory.has_filename('foo')
422
False
423
>>> b.basis_tree().has_filename('foo')
424
False
425
>>> b.working_tree().has_filename('foo')
426
True
427
428
514
TODO: Do something useful with directories.
429
515
430
516
TODO: Should this remove the text or not? Tough call; not
434
520
"""
435
521
## TODO: Normalize names
436
522
## TODO: Remove nested loops; better scalability
437
self._need_writelock()
438
439
if isinstance(files, types.StringTypes):
523
if isinstance(files, basestring):
440
524
files = [files]
441
442
tree = self.working_tree()
443
inv = tree.inventory
444
445
# do this before any modifications
446
for f in files:
447
fid = inv.path2id(f)
448
if not fid:
449
bailout("cannot remove unversioned file %s" % quotefn(f))
450
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
451
if verbose:
452
# having remove it, it must be either ignored or unknown
453
if tree.is_ignored(f):
454
new_status = 'I'
455
else:
456
new_status = '?'
457
show_status(new_status, inv[fid].kind, quotefn(f))
458
del inv[fid]
459
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))
460
561
self._write_inventory(inv)
461
562
462
563
479
580
return self.working_tree().unknowns()
480
581
481
582
482
def commit(self, message, timestamp=None, timezone=None,
483
committer=None,
484
verbose=False):
485
"""Commit working copy as a new revision.
486
487
The basic approach is to add all the file texts into the
488
store, then the inventory, then make a new revision pointing
489
to that inventory and store that.
490
491
This is not quite safe if the working copy changes during the
492
commit; for the moment that is simply not allowed. A better
493
approach is to make a temporary copy of the files before
494
computing their hashes, and then add those hashes in turn to
495
the inventory. This should mean at least that there are no
496
broken hash pointers. There is no way we can get a snapshot
497
of the whole directory at an instant. This would also have to
498
be robust against files disappearing, moving, etc. So the
499
whole thing is a bit hard.
500
501
timestamp -- if not None, seconds-since-epoch for a
502
postdated/predated commit.
503
"""
504
self._need_writelock()
505
506
## TODO: Show branch names
507
508
# TODO: Don't commit if there are no changes, unless forced?
509
510
# First walk over the working inventory; and both update that
511
# and also build a new revision inventory. The revision
512
# inventory needs to hold the text-id, sha1 and size of the
513
# actual file versions committed in the revision. (These are
514
# not present in the working inventory.) We also need to
515
# detect missing/deleted files, and remove them from the
516
# working inventory.
517
518
work_inv = self.read_working_inventory()
519
inv = Inventory()
520
basis = self.basis_tree()
521
basis_inv = basis.inventory
522
missing_ids = []
523
for path, entry in work_inv.iter_entries():
524
## TODO: Cope with files that have gone missing.
525
526
## TODO: Check that the file kind has not changed from the previous
527
## revision of this file (if any).
528
529
entry = entry.copy()
530
531
p = self.abspath(path)
532
file_id = entry.file_id
533
mutter('commit prep file %s, id %r ' % (p, file_id))
534
535
if not os.path.exists(p):
536
mutter(" file is missing, removing from inventory")
537
if verbose:
538
show_status('D', entry.kind, quotefn(path))
539
missing_ids.append(file_id)
540
continue
541
542
# TODO: Handle files that have been deleted
543
544
# TODO: Maybe a special case for empty files? Seems a
545
# waste to store them many times.
546
547
inv.add(entry)
548
549
if basis_inv.has_id(file_id):
550
old_kind = basis_inv[file_id].kind
551
if old_kind != entry.kind:
552
bailout("entry %r changed kind from %r to %r"
553
% (file_id, old_kind, entry.kind))
554
555
if entry.kind == 'directory':
556
if not isdir(p):
557
bailout("%s is entered as directory but not a directory" % quotefn(p))
558
elif entry.kind == 'file':
559
if not isfile(p):
560
bailout("%s is entered as file but is not a file" % quotefn(p))
561
562
content = file(p, 'rb').read()
563
564
entry.text_sha1 = sha_string(content)
565
entry.text_size = len(content)
566
567
old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
568
if (old_ie
569
and (old_ie.text_size == entry.text_size)
570
and (old_ie.text_sha1 == entry.text_sha1)):
571
## assert content == basis.get_file(file_id).read()
572
entry.text_id = basis_inv[file_id].text_id
573
mutter(' unchanged from previous text_id {%s}' %
574
entry.text_id)
575
576
else:
577
entry.text_id = gen_file_id(entry.name)
578
self.text_store.add(content, entry.text_id)
579
mutter(' stored with text_id {%s}' % entry.text_id)
580
if verbose:
581
if not old_ie:
582
state = 'A'
583
elif (old_ie.name == entry.name
584
and old_ie.parent_id == entry.parent_id):
585
state = 'M'
586
else:
587
state = 'R'
588
589
show_status(state, entry.kind, quotefn(path))
590
591
for file_id in missing_ids:
592
# have to do this later so we don't mess up the iterator.
593
# since parents may be removed before their children we
594
# have to test.
595
596
# FIXME: There's probably a better way to do this; perhaps
597
# the workingtree should know how to filter itself.
598
if work_inv.has_id(file_id):
599
del work_inv[file_id]
600
601
602
inv_id = rev_id = _gen_revision_id(time.time())
603
604
inv_tmp = tempfile.TemporaryFile()
605
inv.write_xml(inv_tmp)
606
inv_tmp.seek(0)
607
self.inventory_store.add(inv_tmp, inv_id)
608
mutter('new inventory_id is {%s}' % inv_id)
609
610
self._write_inventory(work_inv)
611
612
if timestamp == None:
613
timestamp = time.time()
614
615
if committer == None:
616
committer = username()
617
618
if timezone == None:
619
timezone = local_time_offset()
620
621
mutter("building commit log message")
622
rev = Revision(timestamp=timestamp,
623
timezone=timezone,
624
committer=committer,
625
precursor = self.last_patch(),
626
message = message,
627
inventory_id=inv_id,
628
revision_id=rev_id)
629
630
rev_tmp = tempfile.TemporaryFile()
631
rev.write_xml(rev_tmp)
632
rev_tmp.seek(0)
633
self.revision_store.add(rev_tmp, rev_id)
634
mutter("new revision_id is {%s}" % rev_id)
635
636
## XXX: Everything up to here can simply be orphaned if we abort
637
## the commit; it will leave junk files behind but that doesn't
638
## matter.
639
640
## TODO: Read back the just-generated changeset, and make sure it
641
## applies and recreates the right state.
642
643
## TODO: Also calculate and store the inventory SHA1
644
mutter("committing patch r%d" % (self.revno() + 1))
645
646
647
self.append_revision(rev_id)
648
649
if verbose:
650
note("commited r%d" % self.revno())
651
652
653
def append_revision(self, revision_id):
654
mutter("add {%s} to revision-history" % revision_id)
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
655
589
rev_history = self.revision_history()
656
657
tmprhname = self.controlfilename('revision-history.tmp')
658
rhname = self.controlfilename('revision-history')
659
660
f = file(tmprhname, 'wt')
661
rev_history.append(revision_id)
662
f.write('\n'.join(rev_history))
663
f.write('\n')
664
f.close()
665
666
if sys.platform == 'win32':
667
os.remove(rhname)
668
os.rename(tmprhname, rhname)
669
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()
670
614
671
615
672
616
def get_revision(self, revision_id):
673
617
"""Return the Revision object for a named revision"""
674
self._need_readlock()
675
r = Revision.read_xml(self.revision_store[revision_id])
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
676
627
assert r.revision_id == revision_id
677
628
return r
678
629
679
630
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
680
665
def get_inventory(self, inventory_id):
681
666
"""Get Inventory object by hash.
682
667
683
668
TODO: Perhaps for this and similar methods, take a revision
684
669
parameter which can be either an integer revno or a
685
670
string hash."""
686
self._need_readlock()
687
i = Inventory.read_xml(self.inventory_store[inventory_id])
688
return i
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))
689
686
690
687
691
688
def get_revision_inventory(self, revision_id):
692
689
"""Return inventory of a past revision."""
693
self._need_readlock()
690
# bzr 0.0.6 imposes the constraint that the inventory_id
691
# must be the same as its revision, so this is trivial.
694
692
if revision_id == None:
695
return Inventory()
693
from bzrlib.inventory import Inventory
694
return Inventory(self.get_root_id())
696
695
else:
697
return self.get_inventory(self.get_revision(revision_id).inventory_id)
696
return self.get_inventory(revision_id)
698
697
699
698
700
699
def revision_history(self):
703
702
>>> ScratchBranch().revision_history()
704
703
[]
705
704
"""
706
self._need_readlock()
707
return [l.rstrip('\r\n') for l in self.controlfile('revision-history', 'r').readlines()]
708
709
710
def enum_history(self, direction):
711
"""Return (revno, revision_id) for history of branch.
712
713
direction
714
'forward' is from earliest to latest
715
'reverse' is from latest to earliest
716
"""
717
rh = self.revision_history()
718
if direction == 'forward':
719
i = 1
720
for rid in rh:
721
yield i, rid
722
i += 1
723
elif direction == 'reverse':
724
i = len(rh)
725
while i > 0:
726
yield i, rh[i-1]
727
i -= 1
728
else:
729
raise BzrError('invalid history direction %r' % direction)
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
730
756
731
757
732
758
def revno(self):
734
760
735
761
That is equivalent to the number of revisions committed to
736
762
this branch.
737
738
>>> b = ScratchBranch()
739
>>> b.revno()
740
0
741
>>> b.commit('no foo')
742
>>> b.revno()
743
1
744
763
"""
745
764
return len(self.revision_history())
746
765
747
766
748
767
def last_patch(self):
749
768
"""Return last patch hash, or None if no history.
750
751
>>> ScratchBranch().last_patch() == None
752
True
753
769
"""
754
770
ph = self.revision_history()
755
771
if ph:
756
772
return ph[-1]
757
773
else:
758
774
return None
759
760
761
def lookup_revision(self, revno):
762
"""Return revision hash for revision number."""
763
if revno == 0:
764
return None
765
766
try:
767
# list is 0-based; revisions are 1-based
768
return self.revision_history()[revno-1]
769
except IndexError:
770
raise BzrError("no such revision %s" % revno)
771
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
772
1061
773
1062
def revision_tree(self, revision_id):
774
1063
"""Return Tree for a revision on this branch.
775
1064
776
1065
`revision_id` may be None for the null revision, in which case
777
1066
an `EmptyTree` is returned."""
778
self._need_readlock()
1067
# TODO: refactor this to use an existing revision object
1068
# so we don't need to read it in twice.
779
1069
if revision_id == None:
780
1070
return EmptyTree()
781
1071
else:
793
1083
"""Return `Tree` object for last revision.
794
1084
795
1085
If there are no revisions yet, return an `EmptyTree`.
796
797
>>> b = ScratchBranch(files=['foo'])
798
>>> b.basis_tree().has_filename('foo')
799
False
800
>>> b.working_tree().has_filename('foo')
801
True
802
>>> b.add('foo')
803
>>> b.commit('add foo')
804
>>> b.basis_tree().has_filename('foo')
805
True
806
1086
"""
807
1087
r = self.last_patch()
808
1088
if r == None:
817
1097
818
1098
This can change the directory or the filename or both.
819
1099
"""
820
self._need_writelock()
821
tree = self.working_tree()
822
inv = tree.inventory
823
if not tree.has_filename(from_rel):
824
bailout("can't rename: old working file %r does not exist" % from_rel)
825
if tree.has_filename(to_rel):
826
bailout("can't rename: new working file %r already exists" % to_rel)
827
828
file_id = inv.path2id(from_rel)
829
if file_id == None:
830
bailout("can't rename: old name %r is not versioned" % from_rel)
831
832
if inv.path2id(to_rel):
833
bailout("can't rename: new name %r is already versioned" % to_rel)
834
835
to_dir, to_tail = os.path.split(to_rel)
836
to_dir_id = inv.path2id(to_dir)
837
if to_dir_id == None and to_dir != '':
838
bailout("can't determine destination directory id for %r" % to_dir)
839
840
mutter("rename_one:")
841
mutter(" file_id {%s}" % file_id)
842
mutter(" from_rel %r" % from_rel)
843
mutter(" to_rel %r" % to_rel)
844
mutter(" to_dir %r" % to_dir)
845
mutter(" to_dir_id {%s}" % to_dir_id)
846
847
inv.rename(file_id, to_dir_id, to_tail)
848
849
print "%s => %s" % (from_rel, to_rel)
850
851
from_abs = self.abspath(from_rel)
852
to_abs = self.abspath(to_rel)
1100
self.lock_write()
853
1101
try:
854
os.rename(from_abs, to_abs)
855
except OSError, e:
856
bailout("failed to rename %r to %r: %s"
857
% (from_abs, to_abs, e[1]),
858
["rename rolled back"])
859
860
self._write_inventory(inv)
861
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()
862
1144
863
1145
864
1146
def move(self, from_paths, to_name):
872
1154
Note that to_name is only the last component of the new name;
873
1155
this doesn't change the directory.
874
1156
"""
875
self._need_writelock()
876
## TODO: Option to move IDs only
877
assert not isinstance(from_paths, basestring)
878
tree = self.working_tree()
879
inv = tree.inventory
880
to_abs = self.abspath(to_name)
881
if not isdir(to_abs):
882
bailout("destination %r is not a directory" % to_abs)
883
if not tree.has_filename(to_name):
884
bailout("destination %r not in working directory" % to_abs)
885
to_dir_id = inv.path2id(to_name)
886
if to_dir_id == None and to_name != '':
887
bailout("destination %r is not a versioned directory" % to_name)
888
to_dir_ie = inv[to_dir_id]
889
if to_dir_ie.kind not in ('directory', 'root_directory'):
890
bailout("destination %r is not a directory" % to_abs)
891
892
to_idpath = Set(inv.get_idpath(to_dir_id))
893
894
for f in from_paths:
895
if not tree.has_filename(f):
896
bailout("%r does not exist in working tree" % f)
897
f_id = inv.path2id(f)
898
if f_id == None:
899
bailout("%r is not versioned" % f)
900
name_tail = splitpath(f)[-1]
901
dest_path = appendpath(to_name, name_tail)
902
if tree.has_filename(dest_path):
903
bailout("destination %r already exists" % dest_path)
904
if f_id in to_idpath:
905
bailout("can't move %r to a subdirectory of itself" % f)
906
907
# OK, so there's a race here, it's possible that someone will
908
# create a file in this interval and then the rename might be
909
# left half-done. But we should have caught most problems.
910
911
for f in from_paths:
912
name_tail = splitpath(f)[-1]
913
dest_path = appendpath(to_name, name_tail)
914
print "%s => %s" % (f, dest_path)
915
inv.rename(inv.path2id(f), to_dir_id, name_tail)
916
try:
917
os.rename(self.abspath(f), self.abspath(dest_path))
918
except OSError, e:
919
bailout("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
920
["rename rolled back"])
921
922
self._write_inventory(inv)
923
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()
924
1294
925
1295
926
1296
935
1305
>>> isdir(bd)
936
1306
False
937
1307
"""
938
def __init__(self, files=[], dirs=[]):
1308
def __init__(self, files=[], dirs=[], base=None):
939
1309
"""Make a test branch.
940
1310
941
1311
This creates a temporary directory and runs init-tree in it.
942
1312
943
1313
If any files are listed, they are created in the working copy.
944
1314
"""
945
Branch.__init__(self, tempfile.mkdtemp(), init=True)
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)
946
1321
for d in dirs:
947
1322
os.mkdir(self.abspath(d))
948
1323
950
1325
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
951
1326
952
1327
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
953
1344
def __del__(self):
954
1345
self.destroy()
955
1346
956
1347
def destroy(self):
957
1348
"""Destroy the test branch, removing the scratch directory."""
1349
from shutil import rmtree
958
1350
try:
959
mutter("delete ScratchBranch %s" % self.base)
960
shutil.rmtree(self.base)
1351
if self.base:
1352
mutter("delete ScratchBranch %s" % self.base)
1353
rmtree(self.base)
961
1354
except OSError, e:
962
1355
# Work around for shutil.rmtree failing on Windows when
963
1356
# readonly files are encountered
965
1358
for root, dirs, files in os.walk(self.base, topdown=False):
966
1359
for name in files:
967
1360
os.chmod(os.path.join(root, name), 0700)
968
shutil.rmtree(self.base)
1361
rmtree(self.base)
969
1362
self.base = None
970
1363
971
1364
989
1382
990
1383
991
1384
992
def _gen_revision_id(when):
993
"""Return new revision-id."""
994
s = '%s-%s-' % (user_email(), compact_date(when))
995
s += hexlify(rand_bytes(8))
996
return s
997
998
999
1385
def gen_file_id(name):
1000
1386
"""Return new file id.
1001
1387
1002
1388
This should probably generate proper UUIDs, but for the moment we
1003
1389
cope with just randomness because running uuidgen every time is
1004
1390
slow."""
1391
import re
1392
from binascii import hexlify
1393
from time import time
1394
1395
# get last component
1005
1396
idx = name.rfind('/')
1006
1397
if idx != -1:
1007
1398
name = name[idx+1 : ]
1009
1400
if idx != -1:
1010
1401
name = name[idx+1 : ]
1011
1402
1403
# make it not a hidden file
1012
1404
name = name.lstrip('.')
1013
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
1014
1410
s = hexlify(rand_bytes(8))
1015
return '-'.join((name, compact_date(time.time()), s))
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')
1417
Loggerhead is a web-based interface for Breezy
Version: 2.0.1