« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1185.81.8
- compare with another revision
- download diff
- download tarball
- view history from revision 1185.81.8
- Committer: John Arbash Meinel
- Date: 2005-11-08 18:36:26 UTC
- mto: This revision was merged to the branch mainline in revision 1727.
- Revision ID: john@arbash-meinel.com-20051108183626-71f8414338043265
Updating unified_diff to take a factory, using the new diff algorithm in the code.
- files added:
- INSTALL
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- files removed:
- bzrlib/meta_store.py
- files renamed:
- bzr-man.py => bzr_man.py
- tools/testweave.py => bzrlib/selftest/test_weave.py
- bzrlib/selftest/plugins.py => bzrlib/selftest/testplugins.py
- tools/history2weaves.py => bzrlib/upgrade.py
- bzrlib/newinventory.py => contrib/newinventory.py
- files modified:
- .bzrignore
- bzr *
- setup.py *
added
removed
bzrlib/branch.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
18
import shutil
18
19
import sys
19
20
import os
21
import errno
22
from warnings import warn
23
from cStringIO import StringIO
24
20
25
21
26
import bzrlib
27
from bzrlib.inventory import InventoryEntry
28
import bzrlib.inventory as inventory
22
29
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
DivergedBranches, NotBranchError
30
from bzrlib.osutils import (isdir, quotefn, compact_date, rand_bytes,
31
rename, splitpath, sha_file, appendpath,
32
file_kind, abspath)
33
import bzrlib.errors as errors
34
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
35
NoSuchRevision, HistoryMissing, NotBranchError,
36
DivergedBranches, LockError, UnlistableStore,
37
UnlistableBranch, NoSuchFile, NotVersionedError,
38
NoWorkingTree)
29
39
from bzrlib.textui import show_status
30
from bzrlib.revision import Revision
40
from bzrlib.revision import (Revision, is_ancestor, get_intervening_revisions,
41
NULL_REVISION)
42
31
43
from bzrlib.delta import compare_trees
32
44
from bzrlib.tree import EmptyTree, RevisionTree
33
import bzrlib.xml
45
from bzrlib.inventory import Inventory
46
from bzrlib.store import copy_all
47
from bzrlib.store.compressed_text import CompressedTextStore
48
from bzrlib.store.text import TextStore
49
from bzrlib.store.weave import WeaveStore
50
from bzrlib.testament import Testament
51
import bzrlib.transactions as transactions
52
from bzrlib.transport import Transport, get_transport
53
import bzrlib.xml5
34
54
import bzrlib.ui
35
55
36
56
37
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
57
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
58
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
59
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
39
60
## TODO: Maybe include checks for common corruption of newlines, etc?
40
61
41
62
42
63
# TODO: Some operations like log might retrieve the same revisions
43
64
# 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
from bzrlib.transport import transport
52
from bzrlib.local_transport import LocalTransport
53
t = transport(f)
54
# FIXME: This is a hack around transport so that
55
# We can search the local directories for
56
# a branch root.
57
if args.has_key('init') and args['init']:
58
# Don't search if we are init-ing
59
return Branch(t, **args)
60
if isinstance(t, LocalTransport):
61
root = find_branch_root(f)
62
if root != f:
63
t = transport(root)
64
return Branch(t, **args)
65
66
def _relpath(base, path):
67
"""Return path relative to base, or raise exception.
68
69
The path may be either an absolute path or a path relative to the
70
current working directory.
71
72
Lifted out of Branch.relpath for ease of testing.
73
74
os.path.commonprefix (python2.4) has a bad bug that it works just
75
on string prefixes, assuming that '/u' is a prefix of '/u2'. This
76
avoids that problem."""
77
rp = os.path.abspath(path)
78
79
s = []
80
head = rp
81
while len(head) >= len(base):
82
if head == base:
83
break
84
head, tail = os.path.split(head)
85
if tail:
86
s.insert(0, tail)
87
else:
88
raise NotBranchError("path %r is not within branch %r" % (rp, base))
89
90
return os.sep.join(s)
91
92
93
def find_branch_root(f=None):
94
"""Find the branch root enclosing f, or pwd.
95
96
f may be a filename or a URL.
97
98
It is not necessary that f exists.
99
100
Basically we keep looking up until we find the control directory or
101
run into the root. If there isn't one, raises NotBranchError.
102
"""
103
if f == None:
104
f = os.getcwd()
105
else:
106
f = os.path.realpath(f)
107
if not os.path.exists(f):
108
raise BzrError('%r does not exist' % f)
109
110
111
orig_f = f
112
113
while True:
114
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
115
return f
116
head, tail = os.path.split(f)
117
if head == f:
118
# reached the root, whatever that may be
119
raise NotBranchError('%s is not in a branch' % orig_f)
120
f = head
121
122
123
65
# cache in memory to make this faster. In general anything can be
66
# cached in memory between lock and unlock operations.
67
68
def find_branch(*ignored, **ignored_too):
69
# XXX: leave this here for about one release, then remove it
70
raise NotImplementedError('find_branch() is not supported anymore, '
71
'please use one of the new branch constructors')
72
73
74
def needs_read_lock(unbound):
75
"""Decorate unbound to take out and release a read lock."""
76
def decorated(self, *args, **kwargs):
77
self.lock_read()
78
try:
79
return unbound(self, *args, **kwargs)
80
finally:
81
self.unlock()
82
return decorated
83
84
85
def needs_write_lock(unbound):
86
"""Decorate unbound to take out and release a write lock."""
87
def decorated(self, *args, **kwargs):
88
self.lock_write()
89
try:
90
return unbound(self, *args, **kwargs)
91
finally:
92
self.unlock()
93
return decorated
124
94
125
95
######################################################################
126
96
# branch objects
129
99
"""Branch holding a history of revisions.
130
100
131
101
base
132
Base directory of the branch.
102
Base directory/url of the branch.
103
"""
104
base = None
105
106
def __init__(self, *ignored, **ignored_too):
107
raise NotImplementedError('The Branch class is abstract')
108
109
@staticmethod
110
def open_downlevel(base):
111
"""Open a branch which may be of an old format.
112
113
Only local branches are supported."""
114
return _Branch(get_transport(base), relax_version_check=True)
115
116
@staticmethod
117
def open(base):
118
"""Open an existing branch, rooted at 'base' (url)"""
119
t = get_transport(base)
120
mutter("trying to open %r with transport %r", base, t)
121
return _Branch(t)
122
123
@staticmethod
124
def open_containing(url):
125
"""Open an existing branch which contains url.
126
127
This probes for a branch at url, and searches upwards from there.
128
129
Basically we keep looking up until we find the control directory or
130
run into the root. If there isn't one, raises NotBranchError.
131
If there is one, it is returned, along with the unused portion of url.
132
"""
133
t = get_transport(url)
134
while True:
135
try:
136
return _Branch(t), t.relpath(url)
137
except NotBranchError:
138
pass
139
new_t = t.clone('..')
140
if new_t.base == t.base:
141
# reached the root, whatever that may be
142
raise NotBranchError(path=url)
143
t = new_t
144
145
@staticmethod
146
def initialize(base):
147
"""Create a new branch, rooted at 'base' (url)"""
148
t = get_transport(base)
149
return _Branch(t, init=True)
150
151
def setup_caching(self, cache_root):
152
"""Subclasses that care about caching should override this, and set
153
up cached stores located under cache_root.
154
"""
155
self.cache_root = cache_root
156
157
158
class _Branch(Branch):
159
"""A branch stored in the actual filesystem.
160
161
Note that it's "local" in the context of the filesystem; it doesn't
162
really matter if it's on an nfs/smb/afs/coda/... share, as long as
163
it's writable, and can be accessed via the normal filesystem API.
133
164
134
165
_lock_mode
135
166
None, or 'r' or 'w'
141
172
_lock
142
173
Lock object from bzrlib.lock.
143
174
"""
144
base = None
175
# We actually expect this class to be somewhat short-lived; part of its
176
# purpose is to try to isolate what bits of the branch logic are tied to
177
# filesystem access, so that in a later step, we can extricate them to
178
# a separarte ("storage") class.
145
179
_lock_mode = None
146
180
_lock_count = None
147
181
_lock = None
148
cache_root = None
182
_inventory_weave = None
149
183
150
184
# Map some sort of prefix into a namespace
151
185
# stuff like "revno:10", "revid:", etc.
152
186
# This should match a prefix with a function which accepts
153
187
REVISION_NAMESPACES = {}
154
188
155
def __init__(self, transport, init=False):
189
def push_stores(self, branch_to):
190
"""Copy the content of this branches store to branch_to."""
191
if (self._branch_format != branch_to._branch_format
192
or self._branch_format != 4):
193
from bzrlib.fetch import greedy_fetch
194
mutter("falling back to fetch logic to push between %s(%s) and %s(%s)",
195
self, self._branch_format, branch_to, branch_to._branch_format)
196
greedy_fetch(to_branch=branch_to, from_branch=self,
197
revision=self.last_revision())
198
return
199
200
store_pairs = ((self.text_store, branch_to.text_store),
201
(self.inventory_store, branch_to.inventory_store),
202
(self.revision_store, branch_to.revision_store))
203
try:
204
for from_store, to_store in store_pairs:
205
copy_all(from_store, to_store)
206
except UnlistableStore:
207
raise UnlistableBranch(from_store)
208
209
def __init__(self, transport, init=False,
210
relax_version_check=False):
156
211
"""Create new branch object at a particular location.
157
212
158
213
transport -- A Transport object, defining how to access files.
159
(If a string, transport.transport() will be used to
160
create a Transport object)
161
214
162
215
init -- If True, create new control files in a previously
163
216
unversioned directory. If False, the branch must already
164
217
be versioned.
165
218
219
relax_version_check -- If true, the usual check for the branch
220
version is not applied. This is intended only for
221
upgrade/recovery type use; it's not guaranteed that
222
all operations will work on old format branches.
223
166
224
In the test suite, creation of new trees is tested using the
167
225
`ScratchBranch` class.
168
226
"""
169
if isinstance(transport, basestring):
170
from transport import transport as get_transport
171
transport = get_transport(transport)
172
227
assert isinstance(transport, Transport), \
228
"%r is not a Transport" % transport
173
229
self._transport = transport
174
230
if init:
175
231
self._make_control()
176
self._check_format()
177
232
self._check_format(relax_version_check)
233
234
def get_store(name, compressed=True, prefixed=False):
235
# FIXME: This approach of assuming stores are all entirely compressed
236
# or entirely uncompressed is tidy, but breaks upgrade from
237
# some existing branches where there's a mixture; we probably
238
# still want the option to look for both.
239
relpath = self._rel_controlfilename(name)
240
if compressed:
241
store = CompressedTextStore(self._transport.clone(relpath),
242
prefixed=prefixed)
243
else:
244
store = TextStore(self._transport.clone(relpath),
245
prefixed=prefixed)
246
#if self._transport.should_cache():
247
# cache_path = os.path.join(self.cache_root, name)
248
# os.mkdir(cache_path)
249
# store = bzrlib.store.CachedStore(store, cache_path)
250
return store
251
def get_weave(name, prefixed=False):
252
relpath = self._rel_controlfilename(name)
253
ws = WeaveStore(self._transport.clone(relpath), prefixed=prefixed)
254
if self._transport.should_cache():
255
ws.enable_cache = True
256
return ws
257
258
if self._branch_format == 4:
259
self.inventory_store = get_store('inventory-store')
260
self.text_store = get_store('text-store')
261
self.revision_store = get_store('revision-store')
262
elif self._branch_format == 5:
263
self.control_weaves = get_weave('')
264
self.weave_store = get_weave('weaves')
265
self.revision_store = get_store('revision-store', compressed=False)
266
elif self._branch_format == 6:
267
self.control_weaves = get_weave('')
268
self.weave_store = get_weave('weaves', prefixed=True)
269
self.revision_store = get_store('revision-store', compressed=False,
270
prefixed=True)
271
self.revision_store.register_suffix('sig')
272
self._transaction = None
178
273
179
274
def __str__(self):
180
275
return '%s(%r)' % (self.__class__.__name__, self._transport.base)
181
276
182
183
277
__repr__ = __str__
184
278
185
186
279
def __del__(self):
187
280
if self._lock_mode or self._lock:
188
from bzrlib.warnings import warn
281
# XXX: This should show something every time, and be suitable for
282
# headless operation and embedding
189
283
warn("branch %r was not explicitly unlocked" % self)
190
284
self._lock.unlock()
191
285
195
289
# Alternatively, we could have the Transport objects cache requests
196
290
# See the earlier discussion about how major objects (like Branch)
197
291
# should never expect their __del__ function to run.
198
if self.cache_root is not None:
199
#from warnings import warn
200
#warn("branch %r auto-cleanup of cache files" % self)
292
if hasattr(self, 'cache_root') and self.cache_root is not None:
201
293
try:
202
import shutil
203
294
shutil.rmtree(self.cache_root)
204
295
except:
205
296
pass
210
301
return self._transport.base
211
302
return None
212
303
213
base = property(_get_base)
214
304
base = property(_get_base, doc="The URL for the root of this branch.")
305
306
def _finish_transaction(self):
307
"""Exit the current transaction."""
308
if self._transaction is None:
309
raise errors.LockError('Branch %s is not in a transaction' %
310
self)
311
transaction = self._transaction
312
self._transaction = None
313
transaction.finish()
314
315
def get_transaction(self):
316
"""Return the current active transaction.
317
318
If no transaction is active, this returns a passthrough object
319
for which all data is immediately flushed and no caching happens.
320
"""
321
if self._transaction is None:
322
return transactions.PassThroughTransaction()
323
else:
324
return self._transaction
325
326
def _set_transaction(self, new_transaction):
327
"""Set a new active transaction."""
328
if self._transaction is not None:
329
raise errors.LockError('Branch %s is in a transaction already.' %
330
self)
331
self._transaction = new_transaction
215
332
216
333
def lock_write(self):
334
mutter("lock write: %s (%s)", self, self._lock_count)
217
335
# TODO: Upgrade locking to support using a Transport,
218
336
# and potentially a remote locking protocol
219
337
if self._lock_mode:
220
338
if self._lock_mode != 'w':
221
from bzrlib.errors import LockError
222
339
raise LockError("can't upgrade to a write lock from %r" %
223
340
self._lock_mode)
224
341
self._lock_count += 1
227
344
self._rel_controlfilename('branch-lock'))
228
345
self._lock_mode = 'w'
229
346
self._lock_count = 1
230
347
self._set_transaction(transactions.PassThroughTransaction())
231
348
232
349
def lock_read(self):
350
mutter("lock read: %s (%s)", self, self._lock_count)
233
351
if self._lock_mode:
234
352
assert self._lock_mode in ('r', 'w'), \
235
353
"invalid lock mode %r" % self._lock_mode
239
357
self._rel_controlfilename('branch-lock'))
240
358
self._lock_mode = 'r'
241
359
self._lock_count = 1
360
self._set_transaction(transactions.ReadOnlyTransaction())
361
# 5K may be excessive, but hey, its a knob.
362
self.get_transaction().set_cache_size(5000)
242
363
243
364
def unlock(self):
365
mutter("unlock: %s (%s)", self, self._lock_count)
244
366
if not self._lock_mode:
245
from bzrlib.errors import LockError
246
367
raise LockError('branch %r is not locked' % (self))
247
368
248
369
if self._lock_count > 1:
249
370
self._lock_count -= 1
250
371
else:
372
self._finish_transaction()
251
373
self._lock.unlock()
252
374
self._lock = None
253
375
self._lock_mode = self._lock_count = None
254
376
255
377
def abspath(self, name):
256
"""Return absolute filename for something in the branch"""
378
"""Return absolute filename for something in the branch
379
380
XXX: Robert Collins 20051017 what is this used for? why is it a branch
381
method and not a tree method.
382
"""
257
383
return self._transport.abspath(name)
258
384
259
def relpath(self, path):
260
"""Return path relative to this branch of something inside it.
261
262
Raises an error if path is not in this branch."""
263
return self._transport.relpath(path)
264
265
266
385
def _rel_controlfilename(self, file_or_path):
267
if isinstance(file_or_path, basestring):
268
file_or_path = [file_or_path]
269
return [bzrlib.BZRDIR] + file_or_path
386
if not isinstance(file_or_path, basestring):
387
file_or_path = '/'.join(file_or_path)
388
if file_or_path == '':
389
return bzrlib.BZRDIR
390
return bzrlib.transport.urlescape(bzrlib.BZRDIR + '/' + file_or_path)
270
391
271
392
def controlfilename(self, file_or_path):
272
393
"""Return location relative to branch."""
273
394
return self._transport.abspath(self._rel_controlfilename(file_or_path))
274
395
275
276
396
def controlfile(self, file_or_path, mode='r'):
277
397
"""Open a control file for this branch.
278
398
331
451
332
452
def _make_control(self):
333
453
from bzrlib.inventory import Inventory
334
from cStringIO import StringIO
454
from bzrlib.weavefile import write_weave_v5
455
from bzrlib.weave import Weave
335
456
336
457
# Create an empty inventory
337
458
sio = StringIO()
338
459
# if we want per-tree root ids then this is the place to set
339
460
# them; they're not needed for now and so ommitted for
340
461
# simplicity.
341
bzrlib.xml.serializer_v4.write_inventory(Inventory(), sio)
462
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), sio)
463
empty_inv = sio.getvalue()
464
sio = StringIO()
465
bzrlib.weavefile.write_weave_v5(Weave(), sio)
466
empty_weave = sio.getvalue()
342
467
343
dirs = [[], 'text-store', 'inventory-store', 'revision-store']
468
dirs = [[], 'revision-store', 'weaves']
344
469
files = [('README',
345
470
"This is a Bazaar-NG control directory.\n"
346
471
"Do not change any files in this directory.\n"),
347
('branch-format', BZR_BRANCH_FORMAT),
472
('branch-format', BZR_BRANCH_FORMAT_6),
348
473
('revision-history', ''),
349
('merged-patches', ''),
350
('pending-merged-patches', ''),
351
474
('branch-name', ''),
352
475
('branch-lock', ''),
353
476
('pending-merges', ''),
354
('inventory', sio.getvalue())
477
('inventory', empty_inv),
478
('inventory.weave', empty_weave),
479
('ancestry.weave', empty_weave)
355
480
]
356
self._transport.mkdir_multi([self._rel_controlfilename(d) for d in dirs])
481
cfn = self._rel_controlfilename
482
self._transport.mkdir_multi([cfn(d) for d in dirs])
357
483
self.put_controlfiles(files)
358
484
mutter('created control directory in ' + self._transport.base)
359
485
360
def _check_format(self):
486
def _check_format(self, relax_version_check):
361
487
"""Check this branch format is supported.
362
488
363
The current tool only supports the current unstable format.
489
The format level is stored, as an integer, in
490
self._branch_format for code that needs to check it later.
364
491
365
492
In the future, we might need different in-memory Branch
366
493
classes to support downlevel branches. But not yet.
367
494
"""
368
# This ignores newlines so that we can open branches created
369
# on Windows from Linux and so on. I think it might be better
370
# to always make all internal files in unix format.
371
fmt = self.controlfile('branch-format', 'r').read()
372
fmt = fmt.replace('\r\n', '\n')
373
if fmt != BZR_BRANCH_FORMAT:
374
raise BzrError('sorry, branch format %r not supported' % fmt,
495
try:
496
fmt = self.controlfile('branch-format', 'r').read()
497
except NoSuchFile:
498
raise NotBranchError(path=self.base)
499
mutter("got branch format %r", fmt)
500
if fmt == BZR_BRANCH_FORMAT_6:
501
self._branch_format = 6
502
elif fmt == BZR_BRANCH_FORMAT_5:
503
self._branch_format = 5
504
elif fmt == BZR_BRANCH_FORMAT_4:
505
self._branch_format = 4
506
507
if (not relax_version_check
508
and self._branch_format not in (5, 6)):
509
raise errors.UnsupportedFormatError(
510
'sorry, branch format %r not supported' % fmt,
375
511
['use a different bzr version',
376
'or remove the .bzr directory and "bzr init" again'])
377
378
# We know that the format is the currently supported one.
379
# So create the rest of the entries.
380
from bzrlib.store.compressed_text import CompressedTextStore
381
382
if self._transport.should_cache():
383
import tempfile
384
self.cache_root = tempfile.mkdtemp(prefix='bzr-cache')
385
mutter('Branch %r using caching in %r' % (self, self.cache_root))
386
else:
387
self.cache_root = None
388
389
def get_store(name):
390
relpath = self._rel_controlfilename(name)
391
store = CompressedTextStore(self._transport.clone(relpath))
392
if self._transport.should_cache():
393
from meta_store import CachedStore
394
cache_path = os.path.join(self.cache_root, name)
395
os.mkdir(cache_path)
396
store = CachedStore(store, cache_path)
397
return store
398
399
self.text_store = get_store('text-store')
400
self.revision_store = get_store('revision-store')
401
self.inventory_store = get_store('inventory-store')
512
'or remove the .bzr directory'
513
' and "bzr init" again'])
402
514
403
515
def get_root_id(self):
404
516
"""Return the id of this branches root"""
405
inv = self.read_working_inventory()
517
inv = self.get_inventory(self.last_revision())
406
518
return inv.root.file_id
407
519
520
@needs_write_lock
408
521
def set_root_id(self, file_id):
409
inv = self.read_working_inventory()
522
inv = self.working_tree().read_working_inventory()
410
523
orig_root_id = inv.root.file_id
411
524
del inv._byid[inv.root.file_id]
412
525
inv.root.file_id = file_id
417
530
entry.parent_id = inv.root.file_id
418
531
self._write_inventory(inv)
419
532
420
def read_working_inventory(self):
421
"""Read the working inventory."""
422
from bzrlib.inventory import Inventory
423
self.lock_read()
424
try:
425
# ElementTree does its own conversion from UTF-8, so open in
426
# binary.
427
f = self.controlfile('inventory', 'rb')
428
return bzrlib.xml.serializer_v4.read_inventory(f)
429
finally:
430
self.unlock()
431
432
533
@needs_write_lock
433
534
def _write_inventory(self, inv):
434
535
"""Update the working inventory.
435
536
437
538
will be committed to the next revision.
438
539
"""
439
540
from cStringIO import StringIO
440
self.lock_write()
441
try:
442
sio = StringIO()
443
bzrlib.xml.serializer_v4.write_inventory(inv, sio)
444
sio.seek(0)
445
# Transport handles atomicity
446
self.put_controlfile('inventory', sio)
447
finally:
448
self.unlock()
541
sio = StringIO()
542
bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
543
sio.seek(0)
544
# Transport handles atomicity
545
self.put_controlfile('inventory', sio)
449
546
450
547
mutter('wrote working inventory')
451
548
452
453
inventory = property(read_working_inventory, _write_inventory, None,
454
"""Inventory for the working copy.""")
455
456
549
@needs_write_lock
457
550
def add(self, files, ids=None):
458
551
"""Make files versioned.
459
552
489
582
else:
490
583
assert(len(ids) == len(files))
491
584
492
self.lock_write()
493
try:
494
inv = self.read_working_inventory()
495
for f,file_id in zip(files, ids):
496
if is_control_file(f):
497
raise BzrError("cannot add control file %s" % quotefn(f))
498
499
fp = splitpath(f)
500
501
if len(fp) == 0:
502
raise BzrError("cannot add top-level %r" % f)
503
504
fullpath = os.path.normpath(self.abspath(f))
505
506
try:
507
kind = file_kind(fullpath)
508
except OSError:
509
# maybe something better?
510
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
511
512
if kind != 'file' and kind != 'directory':
513
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
514
515
if file_id is None:
516
file_id = gen_file_id(f)
517
inv.add_path(f, kind=kind, file_id=file_id)
518
519
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
520
521
self._write_inventory(inv)
522
finally:
523
self.unlock()
524
525
585
inv = self.working_tree().read_working_inventory()
586
for f,file_id in zip(files, ids):
587
if is_control_file(f):
588
raise BzrError("cannot add control file %s" % quotefn(f))
589
590
fp = splitpath(f)
591
592
if len(fp) == 0:
593
raise BzrError("cannot add top-level %r" % f)
594
595
fullpath = os.path.normpath(self.abspath(f))
596
597
try:
598
kind = file_kind(fullpath)
599
except OSError:
600
# maybe something better?
601
raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
602
603
if not InventoryEntry.versionable_kind(kind):
604
raise BzrError('cannot add: not a versionable file ('
605
'i.e. regular file, symlink or directory): %s' % quotefn(f))
606
607
if file_id is None:
608
file_id = gen_file_id(f)
609
inv.add_path(f, kind=kind, file_id=file_id)
610
611
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
612
613
self._write_inventory(inv)
614
615
@needs_read_lock
526
616
def print_file(self, file, revno):
527
617
"""Print `file` to stdout."""
528
self.lock_read()
529
try:
530
tree = self.revision_tree(self.lookup_revision(revno))
531
# use inventory as it was in that revision
532
file_id = tree.inventory.path2id(file)
533
if not file_id:
534
raise BzrError("%r is not present in revision %s" % (file, revno))
535
tree.print_file(file_id)
536
finally:
537
self.unlock()
538
539
540
def remove(self, files, verbose=False):
541
"""Mark nominated files for removal from the inventory.
542
543
This does not remove their text. This does not run on
544
545
TODO: Refuse to remove modified files unless --force is given?
546
547
TODO: Do something useful with directories.
548
549
TODO: Should this remove the text or not? Tough call; not
550
removing may be useful and the user can just use use rm, and
551
is the opposite of add. Removing it is consistent with most
552
other tools. Maybe an option.
553
"""
554
## TODO: Normalize names
555
## TODO: Remove nested loops; better scalability
556
if isinstance(files, basestring):
557
files = [files]
558
559
self.lock_write()
560
561
try:
562
tree = self.working_tree()
563
inv = tree.inventory
564
565
# do this before any modifications
566
for f in files:
567
fid = inv.path2id(f)
568
if not fid:
569
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
570
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
571
if verbose:
572
# having remove it, it must be either ignored or unknown
573
if tree.is_ignored(f):
574
new_status = 'I'
575
else:
576
new_status = '?'
577
show_status(new_status, inv[fid].kind, quotefn(f))
578
del inv[fid]
579
580
self._write_inventory(inv)
581
finally:
582
self.unlock()
583
584
585
# FIXME: this doesn't need to be a branch method
586
def set_inventory(self, new_inventory_list):
587
from bzrlib.inventory import Inventory, InventoryEntry
588
inv = Inventory(self.get_root_id())
589
for path, file_id, parent, kind in new_inventory_list:
590
name = os.path.basename(path)
591
if name == "":
592
continue
593
inv.add(InventoryEntry(file_id, name, kind, parent))
594
self._write_inventory(inv)
595
618
tree = self.revision_tree(self.get_rev_id(revno))
619
# use inventory as it was in that revision
620
file_id = tree.inventory.path2id(file)
621
if not file_id:
622
raise BzrError("%r is not present in revision %s" % (file, revno))
623
tree.print_file(file_id)
596
624
597
625
def unknowns(self):
598
626
"""Return all unknown files.
600
628
These are files in the working directory that are not versioned or
601
629
control files or ignored.
602
630
631
>>> from bzrlib.workingtree import WorkingTree
603
632
>>> b = ScratchBranch(files=['foo', 'foo~'])
604
>>> list(b.unknowns())
633
>>> map(str, b.unknowns())
605
634
['foo']
606
635
>>> b.add('foo')
607
636
>>> list(b.unknowns())
608
637
[]
609
>>> b.remove('foo')
638
>>> WorkingTree(b.base, b).remove('foo')
610
639
>>> list(b.unknowns())
611
['foo']
640
[u'foo']
612
641
"""
613
642
return self.working_tree().unknowns()
614
643
615
644
@needs_write_lock
616
645
def append_revision(self, *revision_ids):
617
646
for revision_id in revision_ids:
618
647
mutter("add {%s} to revision-history" % revision_id)
619
620
648
rev_history = self.revision_history()
621
649
rev_history.extend(revision_ids)
622
623
self.lock_write()
624
try:
625
self.put_controlfile('revision-history', '\n'.join(rev_history))
626
finally:
627
self.unlock()
628
629
650
self.set_revision_history(rev_history)
651
652
@needs_write_lock
653
def set_revision_history(self, rev_history):
654
self.put_controlfile('revision-history', '\n'.join(rev_history))
655
656
def has_revision(self, revision_id):
657
"""True if this branch has a copy of the revision.
658
659
This does not necessarily imply the revision is merge
660
or on the mainline."""
661
return (revision_id is None
662
or self.revision_store.has_id(revision_id))
663
664
@needs_read_lock
630
665
def get_revision_xml_file(self, revision_id):
631
666
"""Return XML file object for revision object."""
632
667
if not revision_id or not isinstance(revision_id, basestring):
633
raise InvalidRevisionId(revision_id)
634
635
self.lock_read()
668
raise InvalidRevisionId(revision_id=revision_id, branch=self)
636
669
try:
637
try:
638
return self.revision_store[revision_id]
639
except (IndexError, KeyError):
640
raise bzrlib.errors.NoSuchRevision(self, revision_id)
641
finally:
642
self.unlock()
643
670
return self.revision_store.get(revision_id)
671
except (IndexError, KeyError):
672
raise bzrlib.errors.NoSuchRevision(self, revision_id)
644
673
645
674
#deprecated
646
675
get_revision_xml = get_revision_xml_file
647
676
677
def get_revision_xml(self, revision_id):
678
return self.get_revision_xml_file(revision_id).read()
679
648
680
649
681
def get_revision(self, revision_id):
650
682
"""Return the Revision object for a named revision"""
651
683
xml_file = self.get_revision_xml_file(revision_id)
652
684
653
685
try:
654
r = bzrlib.xml.serializer_v4.read_revision(xml_file)
686
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
655
687
except SyntaxError, e:
656
688
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
657
689
[revision_id,
660
692
assert r.revision_id == revision_id
661
693
return r
662
694
663
664
695
def get_revision_delta(self, revno):
665
696
"""Return the delta for one revision.
666
697
682
713
683
714
return compare_trees(old_tree, new_tree)
684
715
685
686
def get_revisions(self, revision_ids, pb=None):
687
"""Return the Revision object for a set of named revisions"""
688
from bzrlib.revision import Revision
689
from bzrlib.xml import unpack_xml
690
691
# TODO: We need to decide what to do here
692
# we cannot use a generator with a try/finally, because
693
# you cannot guarantee that the caller will iterate through
694
# all entries.
695
# in the past, get_inventory wasn't even wrapped in a
696
# try/finally locking block.
697
# We could either lock without the try/finally, or just
698
# not lock at all. We are reading entries that should
699
# never be updated.
700
# I prefer locking with no finally, so that if someone
701
# asks for a list of revisions, but doesn't consume them,
702
# that is their problem, and they will suffer the consequences
703
self.lock_read()
704
for xml_file in self.revision_store.get(revision_ids, pb=pb):
705
try:
706
r = bzrlib.xml.serializer_v4.read_revision(xml_file)
707
except SyntaxError, e:
708
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
709
[revision_id,
710
str(e)])
711
yield r
712
self.unlock()
713
714
716
def get_revision_sha1(self, revision_id):
715
717
"""Hash the stored value of a revision, and return it."""
716
718
# In the future, revision entries will be signed. At that
719
721
# the revision, (add signatures/remove signatures) and still
720
722
# have all hash pointers stay consistent.
721
723
# But for now, just hash the contents.
722
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
723
724
725
def get_inventory(self, inventory_id):
726
"""Get Inventory object by hash.
727
728
TODO: Perhaps for this and similar methods, take a revision
729
parameter which can be either an integer revno or a
730
string hash.
724
return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
725
726
def get_ancestry(self, revision_id):
727
"""Return a list of revision-ids integrated by a revision.
728
729
This currently returns a list, but the ordering is not guaranteed:
730
treat it as a set.
731
731
"""
732
f = self.get_inventory_xml_file(inventory_id)
733
return bzrlib.xml.serializer_v4.read_inventory(f)
734
735
736
def get_inventory_xml(self, inventory_id):
732
if revision_id is None:
733
return [None]
734
w = self.get_inventory_weave()
735
return [None] + map(w.idx_to_name,
736
w.inclusions([w.lookup(revision_id)]))
737
738
def get_inventory_weave(self):
739
return self.control_weaves.get_weave('inventory',
740
self.get_transaction())
741
742
def get_inventory(self, revision_id):
743
"""Get Inventory object by hash."""
744
xml = self.get_inventory_xml(revision_id)
745
return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
746
747
def get_inventory_xml(self, revision_id):
737
748
"""Get inventory XML as a file object."""
738
# Shouldn't this have a read-lock around it?
739
# As well as some sort of trap for missing ids?
740
return self.inventory_store[inventory_id]
741
742
get_inventory_xml_file = get_inventory_xml
743
744
def get_inventories(self, inventory_ids, pb=None, ignore_missing=False):
745
"""Get Inventory objects by id
746
"""
747
from bzrlib.inventory import Inventory
748
749
# See the discussion in get_revisions for why
750
# we don't use a try/finally block here
751
self.lock_read()
752
for f in self.inventory_store.get(inventory_ids, pb=pb, ignore_missing=ignore_missing):
753
if f is not None:
754
# TODO: Possibly put a try/except around this to handle
755
# read serialization errors
756
r = bzrlib.xml.serializer_v4.read_inventory(f)
757
yield r
758
elif ignore_missing:
759
yield None
760
else:
761
raise bzrlib.errors.NoSuchRevision(self, revision_id)
762
self.unlock()
763
764
def get_inventory_sha1(self, inventory_id):
749
try:
750
assert isinstance(revision_id, basestring), type(revision_id)
751
iw = self.get_inventory_weave()
752
return iw.get_text(iw.lookup(revision_id))
753
except IndexError:
754
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
755
756
def get_inventory_sha1(self, revision_id):
765
757
"""Return the sha1 hash of the inventory entry
766
758
"""
767
return sha_file(self.get_inventory_xml(inventory_id))
768
759
return self.get_revision(revision_id).inventory_sha1
769
760
770
761
def get_revision_inventory(self, revision_id):
771
762
"""Return inventory of a past revision."""
772
# bzr 0.0.6 imposes the constraint that the inventory_id
763
# TODO: Unify this with get_inventory()
764
# bzr 0.0.6 and later imposes the constraint that the inventory_id
773
765
# must be the same as its revision, so this is trivial.
774
766
if revision_id == None:
775
from bzrlib.inventory import Inventory
776
return Inventory(self.get_root_id())
767
# This does not make sense: if there is no revision,
768
# then it is the current tree inventory surely ?!
769
# and thus get_root_id() is something that looks at the last
770
# commit on the branch, and the get_root_id is an inventory check.
771
raise NotImplementedError
772
# return Inventory(self.get_root_id())
777
773
else:
778
774
return self.get_inventory(revision_id)
779
775
780
776
@needs_read_lock
781
777
def revision_history(self):
782
"""Return sequence of revision hashes on to this branch.
783
784
>>> ScratchBranch().revision_history()
785
[]
786
"""
787
self.lock_read()
788
try:
789
return [l.rstrip('\r\n') for l in
790
self.controlfile('revision-history', 'r').readlines()]
791
finally:
792
self.unlock()
793
794
795
def common_ancestor(self, other, self_revno=None, other_revno=None):
796
"""
797
>>> from bzrlib.commit import commit
798
>>> sb = ScratchBranch(files=['foo', 'foo~'])
799
>>> sb.common_ancestor(sb) == (None, None)
800
True
801
>>> commit(sb, "Committing first revision", verbose=False)
802
>>> sb.common_ancestor(sb)[0]
803
1
804
>>> clone = sb.clone()
805
>>> commit(sb, "Committing second revision", verbose=False)
806
>>> sb.common_ancestor(sb)[0]
807
2
808
>>> sb.common_ancestor(clone)[0]
809
1
810
>>> commit(clone, "Committing divergent second revision",
811
... verbose=False)
812
>>> sb.common_ancestor(clone)[0]
813
1
814
>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
815
True
816
>>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
817
True
818
>>> clone2 = sb.clone()
819
>>> sb.common_ancestor(clone2)[0]
820
2
821
>>> sb.common_ancestor(clone2, self_revno=1)[0]
822
1
823
>>> sb.common_ancestor(clone2, other_revno=1)[0]
824
1
825
"""
826
my_history = self.revision_history()
827
other_history = other.revision_history()
828
if self_revno is None:
829
self_revno = len(my_history)
830
if other_revno is None:
831
other_revno = len(other_history)
832
indices = range(min((self_revno, other_revno)))
833
indices.reverse()
834
for r in indices:
835
if my_history[r] == other_history[r]:
836
return r+1, my_history[r]
837
return None, None
838
778
"""Return sequence of revision hashes on to this branch."""
779
transaction = self.get_transaction()
780
history = transaction.map.find_revision_history()
781
if history is not None:
782
mutter("cache hit for revision-history in %s", self)
783
return list(history)
784
history = [l.rstrip('\r\n') for l in
785
self.controlfile('revision-history', 'r').readlines()]
786
transaction.map.add_revision_history(history)
787
# this call is disabled because revision_history is
788
# not really an object yet, and the transaction is for objects.
789
# transaction.register_clean(history, precious=True)
790
return list(history)
839
791
840
792
def revno(self):
841
793
"""Return current revision number for this branch.
845
797
"""
846
798
return len(self.revision_history())
847
799
848
849
def last_patch(self):
800
def last_revision(self):
850
801
"""Return last patch hash, or None if no history.
851
802
"""
852
803
ph = self.revision_history()
855
806
else:
856
807
return None
857
808
858
859
809
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
860
"""
810
"""Return a list of new revisions that would perfectly fit.
811
861
812
If self and other have not diverged, return a list of the revisions
862
813
present in other, but missing from self.
863
814
894
845
895
846
if stop_revision is None:
896
847
stop_revision = other_len
897
elif stop_revision > other_len:
898
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
899
848
else:
849
assert isinstance(stop_revision, int)
850
if stop_revision > other_len:
851
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
900
852
return other_history[self_len:stop_revision]
901
853
902
903
854
def update_revisions(self, other, stop_revision=None):
904
"""Pull in all new revisions from other branch.
905
"""
855
"""Pull in new perfect-fit revisions."""
906
856
from bzrlib.fetch import greedy_fetch
907
from bzrlib.revision import get_intervening_revisions
857
if stop_revision is None:
858
stop_revision = other.last_revision()
859
### Should this be checking is_ancestor instead of revision_history?
860
if (stop_revision is not None and
861
stop_revision in self.revision_history()):
862
return
863
greedy_fetch(to_branch=self, from_branch=other,
864
revision=stop_revision)
865
pullable_revs = self.pullable_revisions(other, stop_revision)
866
if len(pullable_revs) > 0:
867
self.append_revision(*pullable_revs)
908
868
909
pb = bzrlib.ui.ui_factory.progress_bar()
910
pb.update('comparing histories')
911
if stop_revision is None:
912
other_revision = other.last_patch()
913
else:
914
other_revision = other.lookup_revision(stop_revision)
915
count = greedy_fetch(self, other, other_revision, pb)[0]
869
def pullable_revisions(self, other, stop_revision):
870
other_revno = other.revision_id_to_revno(stop_revision)
916
871
try:
917
revision_ids = self.missing_revisions(other, stop_revision)
872
return self.missing_revisions(other, other_revno)
918
873
except DivergedBranches, e:
919
874
try:
920
revision_ids = get_intervening_revisions(self.last_patch(),
921
other_revision, self)
922
assert self.last_patch() not in revision_ids
875
pullable_revs = get_intervening_revisions(self.last_revision(),
876
stop_revision, self)
877
assert self.last_revision() not in pullable_revs
878
return pullable_revs
923
879
except bzrlib.errors.NotAncestor:
924
raise e
925
926
self.append_revision(*revision_ids)
927
pb.clear()
928
929
def install_revisions(self, other, revision_ids, pb):
930
# We are going to iterate this many times, so make sure
931
# that it is a list, and not a generator
932
revision_ids = list(revision_ids)
933
if hasattr(other.revision_store, "prefetch"):
934
other.revision_store.prefetch(revision_ids)
935
if hasattr(other.inventory_store, "prefetch"):
936
other.inventory_store.prefetch(inventory_ids)
937
938
if pb is None:
939
pb = bzrlib.ui.ui_factory.progress_bar()
940
941
# This entire next section is generally done
942
# with either generators, or bulk updates
943
inventories = other.get_inventories(revision_ids, ignore_missing=True)
944
needed_texts = set()
945
946
failures = set()
947
good_revisions = set()
948
for i, (inv, rev_id) in enumerate(zip(inventories, revision_ids)):
949
pb.update('fetching revision', i+1, len(revision_ids))
950
951
# We don't really need to get the revision here, because
952
# the only thing we needed was the inventory_id, which now
953
# is (by design) identical to the revision_id
954
# try:
955
# rev = other.get_revision(rev_id)
956
# except bzrlib.errors.NoSuchRevision:
957
# failures.add(rev_id)
958
# continue
959
960
if inv is None:
961
failures.add(rev_id)
962
continue
963
else:
964
good_revisions.add(rev_id)
965
966
text_ids = []
967
for key, entry in inv.iter_entries():
968
if entry.text_id is None:
969
continue
970
text_ids.append(entry.text_id)
971
972
has_ids = self.text_store.has(text_ids)
973
for has, text_id in zip(has_ids, text_ids):
974
if not has:
975
needed_texts.add(text_id)
976
977
pb.clear()
978
979
count, cp_fail = self.text_store.copy_multi(other.text_store,
980
needed_texts)
981
#print "Added %d texts." % count
982
count, cp_fail = self.inventory_store.copy_multi(other.inventory_store,
983
good_revisions)
984
#print "Added %d inventories." % count
985
count, cp_fail = self.revision_store.copy_multi(other.revision_store,
986
good_revisions,
987
permit_failure=True)
988
assert len(cp_fail) == 0
989
return count, failures
990
991
880
if is_ancestor(self.last_revision(), stop_revision, self):
881
return []
882
else:
883
raise e
884
992
885
def commit(self, *args, **kw):
993
from bzrlib.commit import commit
994
commit(self, *args, **kw)
995
996
997
def lookup_revision(self, revision):
998
"""Return the revision identifier for a given revision information."""
999
revno, info = self._get_revision_info(revision)
1000
return info
1001
1002
886
from bzrlib.commit import Commit
887
Commit().commit(self, *args, **kw)
888
1003
889
def revision_id_to_revno(self, revision_id):
1004
890
"""Given a revision id, return its revno"""
891
if revision_id is None:
892
return 0
1005
893
history = self.revision_history()
1006
894
try:
1007
895
return history.index(revision_id) + 1
1008
896
except ValueError:
1009
897
raise bzrlib.errors.NoSuchRevision(self, revision_id)
1010
898
1011
1012
def get_revision_info(self, revision):
1013
"""Return (revno, revision id) for revision identifier.
1014
1015
revision can be an integer, in which case it is assumed to be revno (though
1016
this will translate negative values into positive ones)
1017
revision can also be a string, in which case it is parsed for something like
1018
'date:' or 'revid:' etc.
1019
"""
1020
revno, rev_id = self._get_revision_info(revision)
1021
if revno is None:
1022
raise bzrlib.errors.NoSuchRevision(self, revision)
1023
return revno, rev_id
1024
1025
899
def get_rev_id(self, revno, history=None):
1026
900
"""Find the revision id of the specified revno."""
1027
901
if revno == 0:
1032
906
raise bzrlib.errors.NoSuchRevision(self, revno)
1033
907
return history[revno - 1]
1034
908
1035
def _get_revision_info(self, revision):
1036
"""Return (revno, revision id) for revision specifier.
1037
1038
revision can be an integer, in which case it is assumed to be revno
1039
(though this will translate negative values into positive ones)
1040
revision can also be a string, in which case it is parsed for something
1041
like 'date:' or 'revid:' etc.
1042
1043
A revid is always returned. If it is None, the specifier referred to
1044
the null revision. If the revid does not occur in the revision
1045
history, revno will be None.
1046
"""
1047
1048
if revision is None:
1049
return 0, None
1050
revno = None
1051
try:# Convert to int if possible
1052
revision = int(revision)
1053
except ValueError:
1054
pass
1055
revs = self.revision_history()
1056
if isinstance(revision, int):
1057
if revision < 0:
1058
revno = len(revs) + revision + 1
1059
else:
1060
revno = revision
1061
rev_id = self.get_rev_id(revno, revs)
1062
elif isinstance(revision, basestring):
1063
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
1064
if revision.startswith(prefix):
1065
result = func(self, revs, revision)
1066
if len(result) > 1:
1067
revno, rev_id = result
1068
else:
1069
revno = result[0]
1070
rev_id = self.get_rev_id(revno, revs)
1071
break
1072
else:
1073
raise BzrError('No namespace registered for string: %r' %
1074
revision)
1075
else:
1076
raise TypeError('Unhandled revision type %s' % revision)
1077
1078
if revno is None:
1079
if rev_id is None:
1080
raise bzrlib.errors.NoSuchRevision(self, revision)
1081
return revno, rev_id
1082
1083
def _namespace_revno(self, revs, revision):
1084
"""Lookup a revision by revision number"""
1085
assert revision.startswith('revno:')
1086
try:
1087
return (int(revision[6:]),)
1088
except ValueError:
1089
return None
1090
REVISION_NAMESPACES['revno:'] = _namespace_revno
1091
1092
def _namespace_revid(self, revs, revision):
1093
assert revision.startswith('revid:')
1094
rev_id = revision[len('revid:'):]
1095
try:
1096
return revs.index(rev_id) + 1, rev_id
1097
except ValueError:
1098
return None, rev_id
1099
REVISION_NAMESPACES['revid:'] = _namespace_revid
1100
1101
def _namespace_last(self, revs, revision):
1102
assert revision.startswith('last:')
1103
try:
1104
offset = int(revision[5:])
1105
except ValueError:
1106
return (None,)
1107
else:
1108
if offset <= 0:
1109
raise BzrError('You must supply a positive value for --revision last:XXX')
1110
return (len(revs) - offset + 1,)
1111
REVISION_NAMESPACES['last:'] = _namespace_last
1112
1113
def _namespace_tag(self, revs, revision):
1114
assert revision.startswith('tag:')
1115
raise BzrError('tag: namespace registered, but not implemented.')
1116
REVISION_NAMESPACES['tag:'] = _namespace_tag
1117
1118
def _namespace_date(self, revs, revision):
1119
assert revision.startswith('date:')
1120
import datetime
1121
# Spec for date revisions:
1122
# date:value
1123
# value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
1124
# it can also start with a '+/-/='. '+' says match the first
1125
# entry after the given date. '-' is match the first entry before the date
1126
# '=' is match the first entry after, but still on the given date.
1127
#
1128
# +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
1129
# -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
1130
# =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
1131
# May 13th, 2005 at 0:00
1132
#
1133
# So the proper way of saying 'give me all entries for today' is:
1134
# -r {date:+today}:{date:-tomorrow}
1135
# The default is '=' when not supplied
1136
val = revision[5:]
1137
match_style = '='
1138
if val[:1] in ('+', '-', '='):
1139
match_style = val[:1]
1140
val = val[1:]
1141
1142
today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
1143
if val.lower() == 'yesterday':
1144
dt = today - datetime.timedelta(days=1)
1145
elif val.lower() == 'today':
1146
dt = today
1147
elif val.lower() == 'tomorrow':
1148
dt = today + datetime.timedelta(days=1)
1149
else:
1150
import re
1151
# This should be done outside the function to avoid recompiling it.
1152
_date_re = re.compile(
1153
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
1154
r'(,|T)?\s*'
1155
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
1156
)
1157
m = _date_re.match(val)
1158
if not m or (not m.group('date') and not m.group('time')):
1159
raise BzrError('Invalid revision date %r' % revision)
1160
1161
if m.group('date'):
1162
year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
1163
else:
1164
year, month, day = today.year, today.month, today.day
1165
if m.group('time'):
1166
hour = int(m.group('hour'))
1167
minute = int(m.group('minute'))
1168
if m.group('second'):
1169
second = int(m.group('second'))
1170
else:
1171
second = 0
1172
else:
1173
hour, minute, second = 0,0,0
1174
1175
dt = datetime.datetime(year=year, month=month, day=day,
1176
hour=hour, minute=minute, second=second)
1177
first = dt
1178
last = None
1179
reversed = False
1180
if match_style == '-':
1181
reversed = True
1182
elif match_style == '=':
1183
last = dt + datetime.timedelta(days=1)
1184
1185
if reversed:
1186
for i in range(len(revs)-1, -1, -1):
1187
r = self.get_revision(revs[i])
1188
# TODO: Handle timezone.
1189
dt = datetime.datetime.fromtimestamp(r.timestamp)
1190
if first >= dt and (last is None or dt >= last):
1191
return (i+1,)
1192
else:
1193
for i in range(len(revs)):
1194
r = self.get_revision(revs[i])
1195
# TODO: Handle timezone.
1196
dt = datetime.datetime.fromtimestamp(r.timestamp)
1197
if first <= dt and (last is None or dt <= last):
1198
return (i+1,)
1199
REVISION_NAMESPACES['date:'] = _namespace_date
1200
1201
1202
def _namespace_ancestor(self, revs, revision):
1203
from revision import common_ancestor, MultipleRevisionSources
1204
other_branch = find_branch(_trim_namespace('ancestor', revision))
1205
revision_a = self.last_patch()
1206
revision_b = other_branch.last_patch()
1207
for r, b in ((revision_a, self), (revision_b, other_branch)):
1208
if r is None:
1209
raise bzrlib.errors.NoCommits(b)
1210
revision_source = MultipleRevisionSources(self, other_branch)
1211
result = common_ancestor(revision_a, revision_b, revision_source)
1212
try:
1213
revno = self.revision_id_to_revno(result)
1214
except bzrlib.errors.NoSuchRevision:
1215
revno = None
1216
return revno,result
1217
1218
1219
REVISION_NAMESPACES['ancestor:'] = _namespace_ancestor
1220
1221
909
def revision_tree(self, revision_id):
1222
910
"""Return Tree for a revision on this branch.
1223
911
1225
913
an `EmptyTree` is returned."""
1226
914
# TODO: refactor this to use an existing revision object
1227
915
# so we don't need to read it in twice.
1228
if revision_id == None:
916
if revision_id == None or revision_id == NULL_REVISION:
1229
917
return EmptyTree()
1230
918
else:
1231
919
inv = self.get_revision_inventory(revision_id)
1232
return RevisionTree(self.text_store, inv)
1233
920
return RevisionTree(self.weave_store, inv, revision_id)
1234
921
1235
922
def working_tree(self):
1236
923
"""Return a `Tree` for the working copy."""
1237
924
from bzrlib.workingtree import WorkingTree
1238
# TODO: In the future, WorkingTree should utilize Transport
1239
return WorkingTree(self._transport.base, self.read_working_inventory())
925
# TODO: In the future, perhaps WorkingTree should utilize Transport
926
# RobertCollins 20051003 - I don't think it should - working trees are
927
# much more complex to keep consistent than our careful .bzr subset.
928
# instead, we should say that working trees are local only, and optimise
929
# for that.
930
if self._transport.base.find('://') != -1:
931
raise NoWorkingTree(self.base)
932
return WorkingTree(self.base, branch=self)
1240
933
934
@needs_write_lock
935
def pull(self, source, overwrite=False):
936
source.lock_read()
937
try:
938
try:
939
self.update_revisions(source)
940
except DivergedBranches:
941
if not overwrite:
942
raise
943
self.set_revision_history(source.revision_history())
944
finally:
945
source.unlock()
1241
946
1242
947
def basis_tree(self):
1243
948
"""Return `Tree` object for last revision.
1244
949
1245
950
If there are no revisions yet, return an `EmptyTree`.
1246
951
"""
1247
r = self.last_patch()
1248
if r == None:
1249
return EmptyTree()
1250
else:
1251
return RevisionTree(self.text_store, self.get_revision_inventory(r))
1252
1253
1254
952
return self.revision_tree(self.last_revision())
953
954
@needs_write_lock
1255
955
def rename_one(self, from_rel, to_rel):
1256
956
"""Rename one file.
1257
957
1258
958
This can change the directory or the filename or both.
1259
959
"""
1260
self.lock_write()
960
tree = self.working_tree()
961
inv = tree.inventory
962
if not tree.has_filename(from_rel):
963
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
964
if tree.has_filename(to_rel):
965
raise BzrError("can't rename: new working file %r already exists" % to_rel)
966
967
file_id = inv.path2id(from_rel)
968
if file_id == None:
969
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
970
971
if inv.path2id(to_rel):
972
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
973
974
to_dir, to_tail = os.path.split(to_rel)
975
to_dir_id = inv.path2id(to_dir)
976
if to_dir_id == None and to_dir != '':
977
raise BzrError("can't determine destination directory id for %r" % to_dir)
978
979
mutter("rename_one:")
980
mutter(" file_id {%s}" % file_id)
981
mutter(" from_rel %r" % from_rel)
982
mutter(" to_rel %r" % to_rel)
983
mutter(" to_dir %r" % to_dir)
984
mutter(" to_dir_id {%s}" % to_dir_id)
985
986
inv.rename(file_id, to_dir_id, to_tail)
987
988
from_abs = self.abspath(from_rel)
989
to_abs = self.abspath(to_rel)
1261
990
try:
1262
tree = self.working_tree()
1263
inv = tree.inventory
1264
if not tree.has_filename(from_rel):
1265
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
1266
if tree.has_filename(to_rel):
1267
raise BzrError("can't rename: new working file %r already exists" % to_rel)
1268
1269
file_id = inv.path2id(from_rel)
1270
if file_id == None:
1271
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
1272
1273
if inv.path2id(to_rel):
1274
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
1275
1276
to_dir, to_tail = os.path.split(to_rel)
1277
to_dir_id = inv.path2id(to_dir)
1278
if to_dir_id == None and to_dir != '':
1279
raise BzrError("can't determine destination directory id for %r" % to_dir)
1280
1281
mutter("rename_one:")
1282
mutter(" file_id {%s}" % file_id)
1283
mutter(" from_rel %r" % from_rel)
1284
mutter(" to_rel %r" % to_rel)
1285
mutter(" to_dir %r" % to_dir)
1286
mutter(" to_dir_id {%s}" % to_dir_id)
1287
1288
inv.rename(file_id, to_dir_id, to_tail)
1289
1290
from_abs = self.abspath(from_rel)
1291
to_abs = self.abspath(to_rel)
1292
try:
1293
os.rename(from_abs, to_abs)
1294
except OSError, e:
1295
raise BzrError("failed to rename %r to %r: %s"
1296
% (from_abs, to_abs, e[1]),
1297
["rename rolled back"])
1298
1299
self._write_inventory(inv)
1300
finally:
1301
self.unlock()
1302
1303
991
rename(from_abs, to_abs)
992
except OSError, e:
993
raise BzrError("failed to rename %r to %r: %s"
994
% (from_abs, to_abs, e[1]),
995
["rename rolled back"])
996
997
self._write_inventory(inv)
998
999
@needs_write_lock
1304
1000
def move(self, from_paths, to_name):
1305
1001
"""Rename files.
1306
1002
1316
1012
entry that is moved.
1317
1013
"""
1318
1014
result = []
1319
self.lock_write()
1320
try:
1321
## TODO: Option to move IDs only
1322
assert not isinstance(from_paths, basestring)
1323
tree = self.working_tree()
1324
inv = tree.inventory
1325
to_abs = self.abspath(to_name)
1326
if not isdir(to_abs):
1327
raise BzrError("destination %r is not a directory" % to_abs)
1328
if not tree.has_filename(to_name):
1329
raise BzrError("destination %r not in working directory" % to_abs)
1330
to_dir_id = inv.path2id(to_name)
1331
if to_dir_id == None and to_name != '':
1332
raise BzrError("destination %r is not a versioned directory" % to_name)
1333
to_dir_ie = inv[to_dir_id]
1334
if to_dir_ie.kind not in ('directory', 'root_directory'):
1335
raise BzrError("destination %r is not a directory" % to_abs)
1336
1337
to_idpath = inv.get_idpath(to_dir_id)
1338
1339
for f in from_paths:
1340
if not tree.has_filename(f):
1341
raise BzrError("%r does not exist in working tree" % f)
1342
f_id = inv.path2id(f)
1343
if f_id == None:
1344
raise BzrError("%r is not versioned" % f)
1345
name_tail = splitpath(f)[-1]
1346
dest_path = appendpath(to_name, name_tail)
1347
if tree.has_filename(dest_path):
1348
raise BzrError("destination %r already exists" % dest_path)
1349
if f_id in to_idpath:
1350
raise BzrError("can't move %r to a subdirectory of itself" % f)
1351
1352
# OK, so there's a race here, it's possible that someone will
1353
# create a file in this interval and then the rename might be
1354
# left half-done. But we should have caught most problems.
1355
1356
for f in from_paths:
1357
name_tail = splitpath(f)[-1]
1358
dest_path = appendpath(to_name, name_tail)
1359
result.append((f, dest_path))
1360
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1361
try:
1362
os.rename(self.abspath(f), self.abspath(dest_path))
1363
except OSError, e:
1364
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1365
["rename rolled back"])
1366
1367
self._write_inventory(inv)
1368
finally:
1369
self.unlock()
1370
1015
## TODO: Option to move IDs only
1016
assert not isinstance(from_paths, basestring)
1017
tree = self.working_tree()
1018
inv = tree.inventory
1019
to_abs = self.abspath(to_name)
1020
if not isdir(to_abs):
1021
raise BzrError("destination %r is not a directory" % to_abs)
1022
if not tree.has_filename(to_name):
1023
raise BzrError("destination %r not in working directory" % to_abs)
1024
to_dir_id = inv.path2id(to_name)
1025
if to_dir_id == None and to_name != '':
1026
raise BzrError("destination %r is not a versioned directory" % to_name)
1027
to_dir_ie = inv[to_dir_id]
1028
if to_dir_ie.kind not in ('directory', 'root_directory'):
1029
raise BzrError("destination %r is not a directory" % to_abs)
1030
1031
to_idpath = inv.get_idpath(to_dir_id)
1032
1033
for f in from_paths:
1034
if not tree.has_filename(f):
1035
raise BzrError("%r does not exist in working tree" % f)
1036
f_id = inv.path2id(f)
1037
if f_id == None:
1038
raise BzrError("%r is not versioned" % f)
1039
name_tail = splitpath(f)[-1]
1040
dest_path = appendpath(to_name, name_tail)
1041
if tree.has_filename(dest_path):
1042
raise BzrError("destination %r already exists" % dest_path)
1043
if f_id in to_idpath:
1044
raise BzrError("can't move %r to a subdirectory of itself" % f)
1045
1046
# OK, so there's a race here, it's possible that someone will
1047
# create a file in this interval and then the rename might be
1048
# left half-done. But we should have caught most problems.
1049
1050
for f in from_paths:
1051
name_tail = splitpath(f)[-1]
1052
dest_path = appendpath(to_name, name_tail)
1053
result.append((f, dest_path))
1054
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1055
try:
1056
rename(self.abspath(f), self.abspath(dest_path))
1057
except OSError, e:
1058
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1059
["rename rolled back"])
1060
1061
self._write_inventory(inv)
1371
1062
return result
1372
1063
1373
1064
1378
1069
If true (default) backups are made of files before
1379
1070
they're renamed.
1380
1071
"""
1381
from bzrlib.errors import NotVersionedError, BzrError
1382
1072
from bzrlib.atomicfile import AtomicFile
1383
1073
from bzrlib.osutils import backup_file
1384
1074
1385
inv = self.read_working_inventory()
1075
inv = self.working_tree().read_working_inventory()
1386
1076
if old_tree is None:
1387
1077
old_tree = self.basis_tree()
1388
1078
old_inv = old_tree.inventory
1391
1081
for fn in filenames:
1392
1082
file_id = inv.path2id(fn)
1393
1083
if not file_id:
1394
raise NotVersionedError("not a versioned file", fn)
1084
raise NotVersionedError(path=fn)
1395
1085
if not old_inv.has_id(file_id):
1396
1086
raise BzrError("file not present in old tree", fn, file_id)
1397
1087
nids.append((fn, file_id))
1431
1121
1432
1122
1433
1123
def add_pending_merge(self, *revision_ids):
1434
from bzrlib.revision import validate_revision_id
1435
1436
for rev_id in revision_ids:
1437
validate_revision_id(rev_id)
1438
1124
# TODO: Perhaps should check at this point that the
1125
# history of the revision is actually present?
1439
1126
p = self.pending_merges()
1440
1127
updated = False
1441
1128
for rev_id in revision_ids:
1446
1133
if updated:
1447
1134
self.set_pending_merges(p)
1448
1135
1136
@needs_write_lock
1449
1137
def set_pending_merges(self, rev_list):
1450
self.lock_write()
1451
try:
1452
self.put_controlfile('pending-merges', '\n'.join(rev_list))
1453
finally:
1454
self.unlock()
1455
1138
self.put_controlfile('pending-merges', '\n'.join(rev_list))
1456
1139
1457
1140
def get_parent(self):
1458
1141
"""Return the parent location of the branch.
1471
1154
raise
1472
1155
return None
1473
1156
1474
1157
def get_push_location(self):
1158
"""Return the None or the location to push this branch to."""
1159
config = bzrlib.config.BranchConfig(self)
1160
push_loc = config.get_user_option('push_location')
1161
return push_loc
1162
1163
def set_push_location(self, location):
1164
"""Set a new push location for this branch."""
1165
config = bzrlib.config.LocationConfig(self.base)
1166
config.set_user_option('push_location', location)
1167
1168
@needs_write_lock
1475
1169
def set_parent(self, url):
1476
1170
# TODO: Maybe delete old location files?
1477
1171
from bzrlib.atomicfile import AtomicFile
1478
self.lock_write()
1172
f = AtomicFile(self.controlfilename('parent'))
1479
1173
try:
1480
f = AtomicFile(self.controlfilename('parent'))
1481
try:
1482
f.write(url + '\n')
1483
f.commit()
1484
finally:
1485
f.close()
1174
f.write(url + '\n')
1175
f.commit()
1486
1176
finally:
1487
self.unlock()
1177
f.close()
1488
1178
1489
1179
def check_revno(self, revno):
1490
1180
"""\
1502
1192
if revno < 1 or revno > self.revno():
1503
1193
raise InvalidRevisionNumber(revno)
1504
1194
1505
1506
1507
1508
class ScratchBranch(Branch):
1195
def sign_revision(self, revision_id, gpg_strategy):
1196
plaintext = Testament.from_revision(self, revision_id).as_short_text()
1197
self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1198
1199
@needs_write_lock
1200
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1201
self.revision_store.add(StringIO(gpg_strategy.sign(plaintext)),
1202
revision_id, "sig")
1203
1204
1205
class ScratchBranch(_Branch):
1509
1206
"""Special test class: a branch that cleans up after itself.
1510
1207
1511
1208
>>> b = ScratchBranch()
1512
1209
>>> isdir(b.base)
1513
1210
True
1514
1211
>>> bd = b.base
1515
>>> b.destroy()
1212
>>> b._transport.__del__()
1516
1213
>>> isdir(bd)
1517
1214
False
1518
1215
"""
1519
def __init__(self, files=[], dirs=[], base=None):
1216
1217
def __init__(self, files=[], dirs=[], transport=None):
1520
1218
"""Make a test branch.
1521
1219
1522
1220
This creates a temporary directory and runs init-tree in it.
1523
1221
1524
1222
If any files are listed, they are created in the working copy.
1525
1223
"""
1526
from tempfile import mkdtemp
1527
init = False
1528
if base is None:
1529
base = mkdtemp()
1530
init = True
1531
Branch.__init__(self, base, init=init)
1224
if transport is None:
1225
transport = bzrlib.transport.local.ScratchTransport()
1226
super(ScratchBranch, self).__init__(transport, init=True)
1227
else:
1228
super(ScratchBranch, self).__init__(transport)
1229
1532
1230
for d in dirs:
1533
1231
self._transport.mkdir(d)
1534
1232
1540
1238
"""
1541
1239
>>> orig = ScratchBranch(files=["file1", "file2"])
1542
1240
>>> clone = orig.clone()
1543
>>> os.path.samefile(orig.base, clone.base)
1241
>>> if os.name != 'nt':
1242
... os.path.samefile(orig.base, clone.base)
1243
... else:
1244
... orig.base == clone.base
1245
...
1544
1246
False
1545
1247
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1546
1248
True
1550
1252
base = mkdtemp()
1551
1253
os.rmdir(base)
1552
1254
copytree(self.base, base, symlinks=True)
1553
return ScratchBranch(base=base)
1554
1555
1556
1557
def __del__(self):
1558
self.destroy()
1559
1560
def destroy(self):
1561
"""Destroy the test branch, removing the scratch directory."""
1562
from shutil import rmtree
1563
try:
1564
if self.base:
1565
mutter("delete ScratchBranch %s" % self.base)
1566
rmtree(self.base)
1567
except OSError, e:
1568
# Work around for shutil.rmtree failing on Windows when
1569
# readonly files are encountered
1570
mutter("hit exception in destroying ScratchBranch: %s" % e)
1571
for root, dirs, files in os.walk(self.base, topdown=False):
1572
for name in files:
1573
os.chmod(os.path.join(root, name), 0700)
1574
rmtree(self.base)
1575
self._transport = None
1576
1255
return ScratchBranch(
1256
transport=bzrlib.transport.local.ScratchTransport(base))
1577
1257
1578
1258
1579
1259
######################################################################
1629
1309
return gen_file_id('TREE_ROOT')
1630
1310
1631
1311
1632
def copy_branch(branch_from, to_location, revision=None):
1633
"""Copy branch_from into the existing directory to_location.
1634
1635
revision
1636
If not None, only revisions up to this point will be copied.
1637
The head of the new branch will be that revision.
1638
1639
to_location
1640
The name of a local directory that exists but is empty.
1641
"""
1642
from bzrlib.merge import merge
1643
1644
assert isinstance(branch_from, Branch)
1645
assert isinstance(to_location, basestring)
1646
1647
br_to = Branch(to_location, init=True)
1648
br_to.set_root_id(branch_from.get_root_id())
1649
if revision is None:
1650
revno = branch_from.revno()
1651
else:
1652
revno, rev_id = branch_from.get_revision_info(revision)
1653
br_to.update_revisions(branch_from, stop_revision=revno)
1654
merge((to_location, -1), (to_location, 0), this_dir=to_location,
1655
check_clean=False, ignore_zero=True)
1656
br_to.set_parent(branch_from.base)
1657
return br_to
1658
1659
def _trim_namespace(namespace, spec):
1660
full_namespace = namespace + ':'
1661
assert spec.startswith(full_namespace)
1662
return spec[len(full_namespace):]
Loggerhead is a web-based interface for Breezy
Version: 2.0.1