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