« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1417.1.4
- compare with another revision
- download diff
- download tarball
- view history from revision 1417.1.4
- Committer: Robert Collins
- Date: 2005-10-06 22:15:52 UTC
- mfrom: (1185.13.2)
- mto: This revision was merged to the branch mainline in revision 1420.
- Revision ID: robertc@robertcollins.net-20051006221552-9b15c96fa504e0ad
merge from upstream
- files added:
- NEWS.developers
- bzrlib/store
- bzrlib/transport
- files removed:
- bzrlib/meta_store.py
- files renamed:
- tools/testweave.py => bzrlib/selftest/test_weave.py
- bzrlib/store.py => bzrlib/store/__init__.py
- tools/history2weaves.py => bzrlib/upgrade.py
- bzrlib/newinventory.py => contrib/newinventory.py
- files modified:
- .bzrignore
added
removed
bzrlib/branch.py
17
17
18
18
import sys
19
19
import os
20
import errno
21
from warnings import warn
22
from cStringIO import StringIO
23
20
24
21
25
import bzrlib
26
from bzrlib.inventory import InventoryEntry
27
import bzrlib.inventory as inventory
22
28
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.osutils import (isdir, quotefn, compact_date, rand_bytes,
30
rename, splitpath, sha_file, appendpath,
31
file_kind)
32
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
33
NoSuchRevision, HistoryMissing, NotBranchError,
34
DivergedBranches, LockError, UnlistableStore,
35
UnlistableBranch, NoSuchFile)
29
36
from bzrlib.textui import show_status
30
37
from bzrlib.revision import Revision
31
from bzrlib.xml import unpack_xml
32
38
from bzrlib.delta import compare_trees
33
39
from bzrlib.tree import EmptyTree, RevisionTree
40
from bzrlib.inventory import Inventory
41
from bzrlib.store import copy_all
42
from bzrlib.store.compressed_text import CompressedTextStore
43
from bzrlib.store.text import TextStore
44
from bzrlib.store.weave import WeaveStore
45
from bzrlib.transport import Transport, get_transport
46
import bzrlib.xml5
34
47
import bzrlib.ui
35
48
36
49
37
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
50
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
51
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
38
52
## TODO: Maybe include checks for common corruption of newlines, etc?
39
53
40
54
41
55
# TODO: Some operations like log might retrieve the same revisions
42
56
# repeatedly to calculate deltas. We could perhaps have a weakref
43
# cache in memory to make this faster.
44
45
# TODO: please move the revision-string syntax stuff out of the branch
46
# object; it's clutter
47
48
49
def find_branch(f, **args):
50
if f and (f.startswith('http://') or f.startswith('https://')):
51
import remotebranch
52
return remotebranch.RemoteBranch(f, **args)
53
else:
54
return Branch(f, **args)
55
56
57
def find_cached_branch(f, cache_root, **args):
58
from remotebranch import RemoteBranch
59
br = find_branch(f, **args)
60
def cacheify(br, store_name):
61
from meta_store import CachedStore
62
cache_path = os.path.join(cache_root, store_name)
63
os.mkdir(cache_path)
64
new_store = CachedStore(getattr(br, store_name), cache_path)
65
setattr(br, store_name, new_store)
66
67
if isinstance(br, RemoteBranch):
68
cacheify(br, 'inventory_store')
69
cacheify(br, 'text_store')
70
cacheify(br, 'revision_store')
71
return br
72
73
57
# cache in memory to make this faster. In general anything can be
58
# cached in memory between lock and unlock operations.
59
60
def find_branch(*ignored, **ignored_too):
61
# XXX: leave this here for about one release, then remove it
62
raise NotImplementedError('find_branch() is not supported anymore, '
63
'please use one of the new branch constructors')
74
64
def _relpath(base, path):
75
65
"""Return path relative to base, or raise exception.
76
66
93
83
if tail:
94
84
s.insert(0, tail)
95
85
else:
96
from errors import NotBranchError
97
86
raise NotBranchError("path %r is not within branch %r" % (rp, base))
98
87
99
88
return os.sep.join(s)
100
89
101
90
102
def find_branch_root(f=None):
103
"""Find the branch root enclosing f, or pwd.
104
105
f may be a filename or a URL.
106
107
It is not necessary that f exists.
91
def find_branch_root(t):
92
"""Find the branch root enclosing the transport's base.
93
94
t is a Transport object.
95
96
It is not necessary that the base of t exists.
108
97
109
98
Basically we keep looking up until we find the control directory or
110
99
run into the root. If there isn't one, raises NotBranchError.
111
100
"""
112
if f == None:
113
f = os.getcwd()
114
elif hasattr(os.path, 'realpath'):
115
f = os.path.realpath(f)
116
else:
117
f = os.path.abspath(f)
118
if not os.path.exists(f):
119
raise BzrError('%r does not exist' % f)
120
121
122
orig_f = f
123
101
orig_base = t.base
124
102
while True:
125
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
126
return f
127
head, tail = os.path.split(f)
128
if head == f:
103
if t.has(bzrlib.BZRDIR):
104
return t
105
new_t = t.clone('..')
106
if new_t.base == t.base:
129
107
# reached the root, whatever that may be
130
raise bzrlib.errors.NotBranchError('%s is not in a branch' % orig_f)
131
f = head
132
133
134
135
# XXX: move into bzrlib.errors; subclass BzrError
136
class DivergedBranches(Exception):
137
def __init__(self, branch1, branch2):
138
self.branch1 = branch1
139
self.branch2 = branch2
140
Exception.__init__(self, "These branches have diverged.")
108
raise NotBranchError('%s is not in a branch' % orig_base)
109
t = new_t
141
110
142
111
143
112
######################################################################
147
116
"""Branch holding a history of revisions.
148
117
149
118
base
150
Base directory of the branch.
119
Base directory/url of the branch.
120
"""
121
base = None
122
123
def __init__(self, *ignored, **ignored_too):
124
raise NotImplementedError('The Branch class is abstract')
125
126
@staticmethod
127
def open_downlevel(base):
128
"""Open a branch which may be of an old format.
129
130
Only local branches are supported."""
131
return _Branch(get_transport(base), relax_version_check=True)
132
133
@staticmethod
134
def open(base):
135
"""Open an existing branch, rooted at 'base' (url)"""
136
t = get_transport(base)
137
mutter("trying to open %r with transport %r", base, t)
138
return _Branch(t)
139
140
@staticmethod
141
def open_containing(url):
142
"""Open an existing branch which contains url.
143
144
This probes for a branch at url, and searches upwards from there.
145
"""
146
t = get_transport(url)
147
t = find_branch_root(t)
148
return _Branch(t)
149
150
@staticmethod
151
def initialize(base):
152
"""Create a new branch, rooted at 'base' (url)"""
153
t = get_transport(base)
154
return _Branch(t, init=True)
155
156
def setup_caching(self, cache_root):
157
"""Subclasses that care about caching should override this, and set
158
up cached stores located under cache_root.
159
"""
160
self.cache_root = cache_root
161
162
163
class _Branch(Branch):
164
"""A branch stored in the actual filesystem.
165
166
Note that it's "local" in the context of the filesystem; it doesn't
167
really matter if it's on an nfs/smb/afs/coda/... share, as long as
168
it's writable, and can be accessed via the normal filesystem API.
151
169
152
170
_lock_mode
153
171
None, or 'r' or 'w'
159
177
_lock
160
178
Lock object from bzrlib.lock.
161
179
"""
162
base = None
180
# We actually expect this class to be somewhat short-lived; part of its
181
# purpose is to try to isolate what bits of the branch logic are tied to
182
# filesystem access, so that in a later step, we can extricate them to
183
# a separarte ("storage") class.
163
184
_lock_mode = None
164
185
_lock_count = None
165
186
_lock = None
187
_inventory_weave = None
166
188
167
189
# Map some sort of prefix into a namespace
168
190
# stuff like "revno:10", "revid:", etc.
169
191
# This should match a prefix with a function which accepts
170
192
REVISION_NAMESPACES = {}
171
193
172
def __init__(self, base, init=False, find_root=True):
194
def push_stores(self, branch_to):
195
"""Copy the content of this branches store to branch_to."""
196
if (self._branch_format != branch_to._branch_format
197
or self._branch_format != 4):
198
from bzrlib.fetch import greedy_fetch
199
mutter("falling back to fetch logic to push between %s(%s) and %s(%s)",
200
self, self._branch_format, branch_to, branch_to._branch_format)
201
greedy_fetch(to_branch=branch_to, from_branch=self,
202
revision=self.last_revision())
203
return
204
205
store_pairs = ((self.text_store, branch_to.text_store),
206
(self.inventory_store, branch_to.inventory_store),
207
(self.revision_store, branch_to.revision_store))
208
try:
209
for from_store, to_store in store_pairs:
210
copy_all(from_store, to_store)
211
except UnlistableStore:
212
raise UnlistableBranch(from_store)
213
214
def __init__(self, transport, init=False,
215
relax_version_check=False):
173
216
"""Create new branch object at a particular location.
174
217
175
base -- Base directory for the branch.
218
transport -- A Transport object, defining how to access files.
219
(If a string, transport.transport() will be used to
220
create a Transport object)
176
221
177
222
init -- If True, create new control files in a previously
178
223
unversioned directory. If False, the branch must already
179
224
be versioned.
180
225
181
find_root -- If true and init is false, find the root of the
182
existing branch containing base.
226
relax_version_check -- If true, the usual check for the branch
227
version is not applied. This is intended only for
228
upgrade/recovery type use; it's not guaranteed that
229
all operations will work on old format branches.
183
230
184
231
In the test suite, creation of new trees is tested using the
185
232
`ScratchBranch` class.
186
233
"""
187
from bzrlib.store import ImmutableStore
234
assert isinstance(transport, Transport), \
235
"%r is not a Transport" % transport
236
self._transport = transport
188
237
if init:
189
self.base = os.path.realpath(base)
190
238
self._make_control()
191
elif find_root:
192
self.base = find_branch_root(base)
193
else:
194
self.base = os.path.realpath(base)
195
if not isdir(self.controlfilename('.')):
196
from errors import NotBranchError
197
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
198
['use "bzr init" to initialize a new working tree',
199
'current bzr can only operate from top-of-tree'])
200
self._check_format()
201
202
self.text_store = ImmutableStore(self.controlfilename('text-store'))
203
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
204
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
205
239
self._check_format(relax_version_check)
240
241
def get_store(name, compressed=True):
242
# FIXME: This approach of assuming stores are all entirely compressed
243
# or entirely uncompressed is tidy, but breaks upgrade from
244
# some existing branches where there's a mixture; we probably
245
# still want the option to look for both.
246
relpath = self._rel_controlfilename(name)
247
if compressed:
248
store = CompressedTextStore(self._transport.clone(relpath))
249
else:
250
store = TextStore(self._transport.clone(relpath))
251
#if self._transport.should_cache():
252
# cache_path = os.path.join(self.cache_root, name)
253
# os.mkdir(cache_path)
254
# store = bzrlib.store.CachedStore(store, cache_path)
255
return store
256
def get_weave(name):
257
relpath = self._rel_controlfilename(name)
258
ws = WeaveStore(self._transport.clone(relpath))
259
if self._transport.should_cache():
260
ws.enable_cache = True
261
return ws
262
263
if self._branch_format == 4:
264
self.inventory_store = get_store('inventory-store')
265
self.text_store = get_store('text-store')
266
self.revision_store = get_store('revision-store')
267
elif self._branch_format == 5:
268
self.control_weaves = get_weave([])
269
self.weave_store = get_weave('weaves')
270
self.revision_store = get_store('revision-store', compressed=False)
206
271
207
272
def __str__(self):
208
return '%s(%r)' % (self.__class__.__name__, self.base)
273
return '%s(%r)' % (self.__class__.__name__, self._transport.base)
209
274
210
275
211
276
__repr__ = __str__
213
278
214
279
def __del__(self):
215
280
if self._lock_mode or self._lock:
216
from warnings import warn
281
# XXX: This should show something every time, and be suitable for
282
# headless operation and embedding
217
283
warn("branch %r was not explicitly unlocked" % self)
218
284
self._lock.unlock()
219
285
286
# TODO: It might be best to do this somewhere else,
287
# but it is nice for a Branch object to automatically
288
# cache it's information.
289
# Alternatively, we could have the Transport objects cache requests
290
# See the earlier discussion about how major objects (like Branch)
291
# should never expect their __del__ function to run.
292
if hasattr(self, 'cache_root') and self.cache_root is not None:
293
try:
294
import shutil
295
shutil.rmtree(self.cache_root)
296
except:
297
pass
298
self.cache_root = None
299
300
def _get_base(self):
301
if self._transport:
302
return self._transport.base
303
return None
304
305
base = property(_get_base)
306
220
307
221
308
def lock_write(self):
309
# TODO: Upgrade locking to support using a Transport,
310
# and potentially a remote locking protocol
222
311
if self._lock_mode:
223
312
if self._lock_mode != 'w':
224
from errors import LockError
225
313
raise LockError("can't upgrade to a write lock from %r" %
226
314
self._lock_mode)
227
315
self._lock_count += 1
228
316
else:
229
from bzrlib.lock import WriteLock
230
231
self._lock = WriteLock(self.controlfilename('branch-lock'))
317
self._lock = self._transport.lock_write(
318
self._rel_controlfilename('branch-lock'))
232
319
self._lock_mode = 'w'
233
320
self._lock_count = 1
234
321
239
326
"invalid lock mode %r" % self._lock_mode
240
327
self._lock_count += 1
241
328
else:
242
from bzrlib.lock import ReadLock
243
244
self._lock = ReadLock(self.controlfilename('branch-lock'))
329
self._lock = self._transport.lock_read(
330
self._rel_controlfilename('branch-lock'))
245
331
self._lock_mode = 'r'
246
332
self._lock_count = 1
247
333
248
334
def unlock(self):
249
335
if not self._lock_mode:
250
from errors import LockError
251
336
raise LockError('branch %r is not locked' % (self))
252
337
253
338
if self._lock_count > 1:
259
344
260
345
def abspath(self, name):
261
346
"""Return absolute filename for something in the branch"""
262
return os.path.join(self.base, name)
347
return self._transport.abspath(name)
263
348
264
349
def relpath(self, path):
265
350
"""Return path relative to this branch of something inside it.
266
351
267
352
Raises an error if path is not in this branch."""
268
return _relpath(self.base, path)
353
return self._transport.relpath(path)
354
355
356
def _rel_controlfilename(self, file_or_path):
357
if isinstance(file_or_path, basestring):
358
file_or_path = [file_or_path]
359
return [bzrlib.BZRDIR] + file_or_path
269
360
270
361
def controlfilename(self, file_or_path):
271
362
"""Return location relative to branch."""
272
if isinstance(file_or_path, basestring):
273
file_or_path = [file_or_path]
274
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
363
return self._transport.abspath(self._rel_controlfilename(file_or_path))
275
364
276
365
277
366
def controlfile(self, file_or_path, mode='r'):
285
374
Controlfiles should almost never be opened in write mode but
286
375
rather should be atomically copied and replaced using atomicfile.
287
376
"""
288
289
fn = self.controlfilename(file_or_path)
290
291
if mode == 'rb' or mode == 'wb':
292
return file(fn, mode)
293
elif mode == 'r' or mode == 'w':
294
# open in binary mode anyhow so there's no newline translation;
295
# codecs uses line buffering by default; don't want that.
296
import codecs
297
return codecs.open(fn, mode + 'b', 'utf-8',
298
buffering=60000)
377
import codecs
378
379
relpath = self._rel_controlfilename(file_or_path)
380
#TODO: codecs.open() buffers linewise, so it was overloaded with
381
# a much larger buffer, do we need to do the same for getreader/getwriter?
382
if mode == 'rb':
383
return self._transport.get(relpath)
384
elif mode == 'wb':
385
raise BzrError("Branch.controlfile(mode='wb') is not supported, use put_controlfiles")
386
elif mode == 'r':
387
return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
388
elif mode == 'w':
389
raise BzrError("Branch.controlfile(mode='w') is not supported, use put_controlfiles")
299
390
else:
300
391
raise BzrError("invalid controlfile mode %r" % mode)
301
392
393
def put_controlfile(self, path, f, encode=True):
394
"""Write an entry as a controlfile.
395
396
:param path: The path to put the file, relative to the .bzr control
397
directory
398
:param f: A file-like or string object whose contents should be copied.
399
:param encode: If true, encode the contents as utf-8
400
"""
401
self.put_controlfiles([(path, f)], encode=encode)
402
403
def put_controlfiles(self, files, encode=True):
404
"""Write several entries as controlfiles.
405
406
:param files: A list of [(path, file)] pairs, where the path is the directory
407
underneath the bzr control directory
408
:param encode: If true, encode the contents as utf-8
409
"""
410
import codecs
411
ctrl_files = []
412
for path, f in files:
413
if encode:
414
if isinstance(f, basestring):
415
f = f.encode('utf-8', 'replace')
416
else:
417
f = codecs.getwriter('utf-8')(f, errors='replace')
418
path = self._rel_controlfilename(path)
419
ctrl_files.append((path, f))
420
self._transport.put_multi(ctrl_files)
421
302
422
def _make_control(self):
303
423
from bzrlib.inventory import Inventory
304
from bzrlib.xml import pack_xml
424
from bzrlib.weavefile import write_weave_v5
425
from bzrlib.weave import Weave
305
426
306
os.mkdir(self.controlfilename([]))
307
self.controlfile('README', 'w').write(
308
"This is a Bazaar-NG control directory.\n"
309
"Do not change any files in this directory.\n")
310
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
311
for d in ('text-store', 'inventory-store', 'revision-store'):
312
os.mkdir(self.controlfilename(d))
313
for f in ('revision-history', 'merged-patches',
314
'pending-merged-patches', 'branch-name',
315
'branch-lock',
316
'pending-merges'):
317
self.controlfile(f, 'w').write('')
318
mutter('created control directory in ' + self.base)
319
427
# Create an empty inventory
428
sio = StringIO()
320
429
# if we want per-tree root ids then this is the place to set
321
430
# them; they're not needed for now and so ommitted for
322
431
# simplicity.
323
pack_xml(Inventory(), self.controlfile('inventory','w'))
324
325
def _check_format(self):
432
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), sio)
433
empty_inv = sio.getvalue()
434
sio = StringIO()
435
bzrlib.weavefile.write_weave_v5(Weave(), sio)
436
empty_weave = sio.getvalue()
437
438
dirs = [[], 'revision-store', 'weaves']
439
files = [('README',
440
"This is a Bazaar-NG control directory.\n"
441
"Do not change any files in this directory.\n"),
442
('branch-format', BZR_BRANCH_FORMAT_5),
443
('revision-history', ''),
444
('branch-name', ''),
445
('branch-lock', ''),
446
('pending-merges', ''),
447
('inventory', empty_inv),
448
('inventory.weave', empty_weave),
449
('ancestry.weave', empty_weave)
450
]
451
cfn = self._rel_controlfilename
452
self._transport.mkdir_multi([cfn(d) for d in dirs])
453
self.put_controlfiles(files)
454
mutter('created control directory in ' + self._transport.base)
455
456
def _check_format(self, relax_version_check):
326
457
"""Check this branch format is supported.
327
458
328
The current tool only supports the current unstable format.
459
The format level is stored, as an integer, in
460
self._branch_format for code that needs to check it later.
329
461
330
462
In the future, we might need different in-memory Branch
331
463
classes to support downlevel branches. But not yet.
332
464
"""
333
# This ignores newlines so that we can open branches created
334
# on Windows from Linux and so on. I think it might be better
335
# to always make all internal files in unix format.
336
fmt = self.controlfile('branch-format', 'r').read()
337
fmt.replace('\r\n', '')
338
if fmt != BZR_BRANCH_FORMAT:
465
try:
466
fmt = self.controlfile('branch-format', 'r').read()
467
except NoSuchFile:
468
raise NotBranchError(self.base)
469
mutter("got branch format %r", fmt)
470
if fmt == BZR_BRANCH_FORMAT_5:
471
self._branch_format = 5
472
elif fmt == BZR_BRANCH_FORMAT_4:
473
self._branch_format = 4
474
475
if (not relax_version_check
476
and self._branch_format != 5):
339
477
raise BzrError('sorry, branch format %r not supported' % fmt,
340
478
['use a different bzr version',
341
'or remove the .bzr directory and "bzr init" again'])
479
'or remove the .bzr directory'
480
' and "bzr init" again'])
342
481
343
482
def get_root_id(self):
344
483
"""Return the id of this branches root"""
359
498
360
499
def read_working_inventory(self):
361
500
"""Read the working inventory."""
362
from bzrlib.inventory import Inventory
363
from bzrlib.xml import unpack_xml
364
from time import time
365
before = time()
366
501
self.lock_read()
367
502
try:
368
503
# ElementTree does its own conversion from UTF-8, so open in
369
504
# binary.
370
inv = unpack_xml(Inventory,
371
self.controlfile('inventory', 'rb'))
372
mutter("loaded inventory of %d items in %f"
373
% (len(inv), time() - before))
374
return inv
505
f = self.controlfile('inventory', 'rb')
506
return bzrlib.xml5.serializer_v5.read_inventory(f)
375
507
finally:
376
508
self.unlock()
377
509
382
514
That is to say, the inventory describing changes underway, that
383
515
will be committed to the next revision.
384
516
"""
385
from bzrlib.atomicfile import AtomicFile
386
from bzrlib.xml import pack_xml
387
517
from cStringIO import StringIO
388
518
self.lock_write()
389
519
try:
390
f = AtomicFile(self.controlfilename('inventory'), 'wb')
391
try:
392
pack_xml(inv, f)
393
f.commit()
394
finally:
395
f.close()
520
sio = StringIO()
521
bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
522
sio.seek(0)
523
# Transport handles atomicity
524
self.put_controlfile('inventory', sio)
396
525
finally:
397
526
self.unlock()
398
527
399
528
mutter('wrote working inventory')
400
529
401
402
530
inventory = property(read_working_inventory, _write_inventory, None,
403
531
"""Inventory for the working copy.""")
404
532
405
406
def add(self, files, verbose=False, ids=None):
533
def add(self, files, ids=None):
407
534
"""Make files versioned.
408
535
409
Note that the command line normally calls smart_add instead.
536
Note that the command line normally calls smart_add instead,
537
which can automatically recurse.
410
538
411
539
This puts the files in the Added state, so that they will be
412
540
recorded by the next commit.
422
550
TODO: Perhaps have an option to add the ids even if the files do
423
551
not (yet) exist.
424
552
425
TODO: Perhaps return the ids of the files? But then again it
426
is easy to retrieve them if they're needed.
427
428
TODO: Adding a directory should optionally recurse down and
429
add all non-ignored children. Perhaps do that in a
430
higher-level method.
553
TODO: Perhaps yield the ids and paths as they're added.
431
554
"""
432
555
# TODO: Re-adding a file that is removed in the working copy
433
556
# should probably put it back with the previous ID.
460
583
kind = file_kind(fullpath)
461
584
except OSError:
462
585
# maybe something better?
463
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
586
raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
464
587
465
if kind != 'file' and kind != 'directory':
466
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
588
if not InventoryEntry.versionable_kind(kind):
589
raise BzrError('cannot add: not a versionable file ('
590
'i.e. regular file, symlink or directory): %s' % quotefn(f))
467
591
468
592
if file_id is None:
469
593
file_id = gen_file_id(f)
470
594
inv.add_path(f, kind=kind, file_id=file_id)
471
595
472
if verbose:
473
print 'added', quotefn(f)
474
475
596
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
476
597
477
598
self._write_inventory(inv)
483
604
"""Print `file` to stdout."""
484
605
self.lock_read()
485
606
try:
486
tree = self.revision_tree(self.lookup_revision(revno))
607
tree = self.revision_tree(self.get_rev_id(revno))
487
608
# use inventory as it was in that revision
488
609
file_id = tree.inventory.path2id(file)
489
610
if not file_id:
537
658
finally:
538
659
self.unlock()
539
660
540
541
661
# FIXME: this doesn't need to be a branch method
542
662
def set_inventory(self, new_inventory_list):
543
663
from bzrlib.inventory import Inventory, InventoryEntry
546
666
name = os.path.basename(path)
547
667
if name == "":
548
668
continue
549
inv.add(InventoryEntry(file_id, name, kind, parent))
669
# fixme, there should be a factory function inv,add_??
670
if kind == 'directory':
671
inv.add(inventory.InventoryDirectory(file_id, name, parent))
672
elif kind == 'file':
673
inv.add(inventory.InventoryFile(file_id, name, parent))
674
elif kind == 'symlink':
675
inv.add(inventory.InventoryLink(file_id, name, parent))
676
else:
677
raise BzrError("unknown kind %r" % kind)
550
678
self._write_inventory(inv)
551
679
552
553
680
def unknowns(self):
554
681
"""Return all unknown files.
555
682
570
697
571
698
572
699
def append_revision(self, *revision_ids):
573
from bzrlib.atomicfile import AtomicFile
574
575
700
for revision_id in revision_ids:
576
701
mutter("add {%s} to revision-history" % revision_id)
577
578
rev_history = self.revision_history()
579
rev_history.extend(revision_ids)
580
581
f = AtomicFile(self.controlfilename('revision-history'))
702
self.lock_write()
582
703
try:
583
for rev_id in rev_history:
584
print >>f, rev_id
585
f.commit()
704
rev_history = self.revision_history()
705
rev_history.extend(revision_ids)
706
self.put_controlfile('revision-history', '\n'.join(rev_history))
586
707
finally:
587
f.close()
588
589
590
def get_revision_xml(self, revision_id):
708
self.unlock()
709
710
def has_revision(self, revision_id):
711
"""True if this branch has a copy of the revision.
712
713
This does not necessarily imply the revision is merge
714
or on the mainline."""
715
return (revision_id is None
716
or revision_id in self.revision_store)
717
718
def get_revision_xml_file(self, revision_id):
591
719
"""Return XML file object for revision object."""
592
720
if not revision_id or not isinstance(revision_id, basestring):
593
721
raise InvalidRevisionId(revision_id)
596
724
try:
597
725
try:
598
726
return self.revision_store[revision_id]
599
except IndexError:
727
except (IndexError, KeyError):
600
728
raise bzrlib.errors.NoSuchRevision(self, revision_id)
601
729
finally:
602
730
self.unlock()
603
731
732
#deprecated
733
get_revision_xml = get_revision_xml_file
734
735
def get_revision_xml(self, revision_id):
736
return self.get_revision_xml_file(revision_id).read()
737
604
738
605
739
def get_revision(self, revision_id):
606
740
"""Return the Revision object for a named revision"""
607
xml_file = self.get_revision_xml(revision_id)
741
xml_file = self.get_revision_xml_file(revision_id)
608
742
609
743
try:
610
r = unpack_xml(Revision, xml_file)
744
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
611
745
except SyntaxError, e:
612
746
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
613
747
[revision_id,
616
750
assert r.revision_id == revision_id
617
751
return r
618
752
619
620
753
def get_revision_delta(self, revno):
621
754
"""Return the delta for one revision.
622
755
638
771
639
772
return compare_trees(old_tree, new_tree)
640
773
641
642
643
774
def get_revision_sha1(self, revision_id):
644
775
"""Hash the stored value of a revision, and return it."""
645
776
# In the future, revision entries will be signed. At that
648
779
# the revision, (add signatures/remove signatures) and still
649
780
# have all hash pointers stay consistent.
650
781
# But for now, just hash the contents.
651
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
652
653
654
def get_inventory(self, inventory_id):
655
"""Get Inventory object by hash.
656
657
TODO: Perhaps for this and similar methods, take a revision
658
parameter which can be either an integer revno or a
659
string hash."""
660
from bzrlib.inventory import Inventory
661
from bzrlib.xml import unpack_xml
662
663
return unpack_xml(Inventory, self.get_inventory_xml(inventory_id))
664
665
666
def get_inventory_xml(self, inventory_id):
782
return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
783
784
def get_ancestry(self, revision_id):
785
"""Return a list of revision-ids integrated by a revision.
786
787
This currently returns a list, but the ordering is not guaranteed:
788
treat it as a set.
789
"""
790
if revision_id is None:
791
return [None]
792
w = self.control_weaves.get_weave('inventory')
793
return [None] + map(w.idx_to_name,
794
w.inclusions([w.lookup(revision_id)]))
795
796
def get_inventory_weave(self):
797
return self.control_weaves.get_weave('inventory')
798
799
def get_inventory(self, revision_id):
800
"""Get Inventory object by hash."""
801
xml = self.get_inventory_xml(revision_id)
802
return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
803
804
def get_inventory_xml(self, revision_id):
667
805
"""Get inventory XML as a file object."""
668
return self.inventory_store[inventory_id]
669
806
try:
807
assert isinstance(revision_id, basestring), type(revision_id)
808
iw = self.get_inventory_weave()
809
return iw.get_text(iw.lookup(revision_id))
810
except IndexError:
811
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
670
812
671
def get_inventory_sha1(self, inventory_id):
813
def get_inventory_sha1(self, revision_id):
672
814
"""Return the sha1 hash of the inventory entry
673
815
"""
674
return sha_file(self.get_inventory_xml(inventory_id))
675
816
return self.get_revision(revision_id).inventory_sha1
676
817
677
818
def get_revision_inventory(self, revision_id):
678
819
"""Return inventory of a past revision."""
679
# bzr 0.0.6 imposes the constraint that the inventory_id
820
# TODO: Unify this with get_inventory()
821
# bzr 0.0.6 and later imposes the constraint that the inventory_id
680
822
# must be the same as its revision, so this is trivial.
681
823
if revision_id == None:
682
from bzrlib.inventory import Inventory
683
824
return Inventory(self.get_root_id())
684
825
else:
685
826
return self.get_inventory(revision_id)
686
827
687
688
828
def revision_history(self):
689
"""Return sequence of revision hashes on to this branch.
690
691
>>> ScratchBranch().revision_history()
692
[]
693
"""
829
"""Return sequence of revision hashes on to this branch."""
694
830
self.lock_read()
695
831
try:
696
832
return [l.rstrip('\r\n') for l in
698
834
finally:
699
835
self.unlock()
700
836
701
702
837
def common_ancestor(self, other, self_revno=None, other_revno=None):
703
838
"""
704
>>> import commit
839
>>> from bzrlib.commit import commit
705
840
>>> sb = ScratchBranch(files=['foo', 'foo~'])
706
841
>>> sb.common_ancestor(sb) == (None, None)
707
842
True
708
>>> commit.commit(sb, "Committing first revision", verbose=False)
843
>>> commit(sb, "Committing first revision", verbose=False)
709
844
>>> sb.common_ancestor(sb)[0]
710
845
1
711
846
>>> clone = sb.clone()
712
>>> commit.commit(sb, "Committing second revision", verbose=False)
847
>>> commit(sb, "Committing second revision", verbose=False)
713
848
>>> sb.common_ancestor(sb)[0]
714
849
2
715
850
>>> sb.common_ancestor(clone)[0]
716
851
1
717
>>> commit.commit(clone, "Committing divergent second revision",
852
>>> commit(clone, "Committing divergent second revision",
718
853
... verbose=False)
719
854
>>> sb.common_ancestor(clone)[0]
720
855
1
753
888
return len(self.revision_history())
754
889
755
890
756
def last_patch(self):
891
def last_revision(self):
757
892
"""Return last patch hash, or None if no history.
758
893
"""
759
894
ph = self.revision_history()
764
899
765
900
766
901
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
767
"""
902
"""Return a list of new revisions that would perfectly fit.
903
768
904
If self and other have not diverged, return a list of the revisions
769
905
present in other, but missing from self.
770
906
790
926
Traceback (most recent call last):
791
927
DivergedBranches: These branches have diverged.
792
928
"""
929
# FIXME: If the branches have diverged, but the latest
930
# revision in this branch is completely merged into the other,
931
# then we should still be able to pull.
793
932
self_history = self.revision_history()
794
933
self_len = len(self_history)
795
934
other_history = other.revision_history()
801
940
802
941
if stop_revision is None:
803
942
stop_revision = other_len
804
elif stop_revision > other_len:
805
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
806
943
else:
944
assert isinstance(stop_revision, int)
945
if stop_revision > other_len:
946
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
807
947
return other_history[self_len:stop_revision]
808
948
809
810
949
def update_revisions(self, other, stop_revision=None):
811
"""Pull in all new revisions from other branch.
812
813
>>> from bzrlib.commit import commit
814
>>> bzrlib.trace.silent = True
815
>>> br1 = ScratchBranch(files=['foo', 'bar'])
816
>>> br1.add('foo')
817
>>> br1.add('bar')
818
>>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
819
>>> br2 = ScratchBranch()
820
>>> br2.update_revisions(br1)
821
Added 2 texts.
822
Added 1 inventories.
823
Added 1 revisions.
824
>>> br2.revision_history()
825
[u'REVISION-ID-1']
826
>>> br2.update_revisions(br1)
827
Added 0 texts.
828
Added 0 inventories.
829
Added 0 revisions.
830
>>> br1.text_store.total_size() == br2.text_store.total_size()
831
True
832
"""
833
progress = bzrlib.ui.ui_factory.progress_bar()
834
progress.update('comparing histories')
835
revision_ids = self.missing_revisions(other, stop_revision)
836
count = self.install_revisions(other, revision_ids, progress=progress)
837
self.append_revision(*revision_ids)
838
print "Added %d revisions." % count
839
840
841
def install_revisions(self, other, revision_ids, progress=None):
842
if hasattr(other.revision_store, "prefetch"):
843
other.revision_store.prefetch(revision_ids)
844
if hasattr(other.inventory_store, "prefetch"):
845
inventory_ids = [other.get_revision(r).inventory_id
846
for r in revision_ids]
847
other.inventory_store.prefetch(inventory_ids)
848
849
revisions = []
850
needed_texts = set()
851
i = 0
852
for rev_id in revision_ids:
853
i += 1
854
if progress:
855
progress.update('fetching revision', i, len(revision_ids))
856
rev = other.get_revision(rev_id)
857
revisions.append(rev)
858
inv = other.get_inventory(str(rev.inventory_id))
859
for key, entry in inv.iter_entries():
860
if entry.text_id is None:
861
continue
862
if entry.text_id not in self.text_store:
863
needed_texts.add(entry.text_id)
864
865
if progress:
866
progress.clear()
867
868
count = self.text_store.copy_multi(other.text_store, needed_texts)
869
print "Added %d texts." % count
870
inventory_ids = [ f.inventory_id for f in revisions ]
871
count = self.inventory_store.copy_multi(other.inventory_store,
872
inventory_ids)
873
print "Added %d inventories." % count
874
revision_ids = [ f.revision_id for f in revisions]
875
count = self.revision_store.copy_multi(other.revision_store,
876
revision_ids)
877
return count
878
950
"""Pull in new perfect-fit revisions."""
951
from bzrlib.fetch import greedy_fetch
952
from bzrlib.revision import get_intervening_revisions
953
if stop_revision is None:
954
stop_revision = other.last_revision()
955
greedy_fetch(to_branch=self, from_branch=other,
956
revision=stop_revision)
957
pullable_revs = self.missing_revisions(
958
other, other.revision_id_to_revno(stop_revision))
959
if pullable_revs:
960
greedy_fetch(to_branch=self,
961
from_branch=other,
962
revision=pullable_revs[-1])
963
self.append_revision(*pullable_revs)
964
965
879
966
def commit(self, *args, **kw):
880
from bzrlib.commit import commit
881
commit(self, *args, **kw)
882
883
884
def lookup_revision(self, revision):
885
"""Return the revision identifier for a given revision information."""
886
revno, info = self.get_revision_info(revision)
887
return info
888
889
def get_revision_info(self, revision):
890
"""Return (revno, revision id) for revision identifier.
891
892
revision can be an integer, in which case it is assumed to be revno (though
893
this will translate negative values into positive ones)
894
revision can also be a string, in which case it is parsed for something like
895
'date:' or 'revid:' etc.
896
"""
897
if revision is None:
898
return 0, None
899
revno = None
900
try:# Convert to int if possible
901
revision = int(revision)
902
except ValueError:
903
pass
904
revs = self.revision_history()
905
if isinstance(revision, int):
906
if revision == 0:
907
return 0, None
908
# Mabye we should do this first, but we don't need it if revision == 0
909
if revision < 0:
910
revno = len(revs) + revision + 1
911
else:
912
revno = revision
913
elif isinstance(revision, basestring):
914
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
915
if revision.startswith(prefix):
916
revno = func(self, revs, revision)
917
break
918
else:
919
raise BzrError('No namespace registered for string: %r' % revision)
920
921
if revno is None or revno <= 0 or revno > len(revs):
922
raise BzrError("no such revision %s" % revision)
923
return revno, revs[revno-1]
924
925
def _namespace_revno(self, revs, revision):
926
"""Lookup a revision by revision number"""
927
assert revision.startswith('revno:')
928
try:
929
return int(revision[6:])
930
except ValueError:
931
return None
932
REVISION_NAMESPACES['revno:'] = _namespace_revno
933
934
def _namespace_revid(self, revs, revision):
935
assert revision.startswith('revid:')
936
try:
937
return revs.index(revision[6:]) + 1
938
except ValueError:
939
return None
940
REVISION_NAMESPACES['revid:'] = _namespace_revid
941
942
def _namespace_last(self, revs, revision):
943
assert revision.startswith('last:')
944
try:
945
offset = int(revision[5:])
946
except ValueError:
947
return None
948
else:
949
if offset <= 0:
950
raise BzrError('You must supply a positive value for --revision last:XXX')
951
return len(revs) - offset + 1
952
REVISION_NAMESPACES['last:'] = _namespace_last
953
954
def _namespace_tag(self, revs, revision):
955
assert revision.startswith('tag:')
956
raise BzrError('tag: namespace registered, but not implemented.')
957
REVISION_NAMESPACES['tag:'] = _namespace_tag
958
959
def _namespace_date(self, revs, revision):
960
assert revision.startswith('date:')
961
import datetime
962
# Spec for date revisions:
963
# date:value
964
# value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
965
# it can also start with a '+/-/='. '+' says match the first
966
# entry after the given date. '-' is match the first entry before the date
967
# '=' is match the first entry after, but still on the given date.
968
#
969
# +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
970
# -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
971
# =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
972
# May 13th, 2005 at 0:00
973
#
974
# So the proper way of saying 'give me all entries for today' is:
975
# -r {date:+today}:{date:-tomorrow}
976
# The default is '=' when not supplied
977
val = revision[5:]
978
match_style = '='
979
if val[:1] in ('+', '-', '='):
980
match_style = val[:1]
981
val = val[1:]
982
983
today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
984
if val.lower() == 'yesterday':
985
dt = today - datetime.timedelta(days=1)
986
elif val.lower() == 'today':
987
dt = today
988
elif val.lower() == 'tomorrow':
989
dt = today + datetime.timedelta(days=1)
990
else:
991
import re
992
# This should be done outside the function to avoid recompiling it.
993
_date_re = re.compile(
994
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
995
r'(,|T)?\s*'
996
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
997
)
998
m = _date_re.match(val)
999
if not m or (not m.group('date') and not m.group('time')):
1000
raise BzrError('Invalid revision date %r' % revision)
1001
1002
if m.group('date'):
1003
year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
1004
else:
1005
year, month, day = today.year, today.month, today.day
1006
if m.group('time'):
1007
hour = int(m.group('hour'))
1008
minute = int(m.group('minute'))
1009
if m.group('second'):
1010
second = int(m.group('second'))
1011
else:
1012
second = 0
1013
else:
1014
hour, minute, second = 0,0,0
1015
1016
dt = datetime.datetime(year=year, month=month, day=day,
1017
hour=hour, minute=minute, second=second)
1018
first = dt
1019
last = None
1020
reversed = False
1021
if match_style == '-':
1022
reversed = True
1023
elif match_style == '=':
1024
last = dt + datetime.timedelta(days=1)
1025
1026
if reversed:
1027
for i in range(len(revs)-1, -1, -1):
1028
r = self.get_revision(revs[i])
1029
# TODO: Handle timezone.
1030
dt = datetime.datetime.fromtimestamp(r.timestamp)
1031
if first >= dt and (last is None or dt >= last):
1032
return i+1
1033
else:
1034
for i in range(len(revs)):
1035
r = self.get_revision(revs[i])
1036
# TODO: Handle timezone.
1037
dt = datetime.datetime.fromtimestamp(r.timestamp)
1038
if first <= dt and (last is None or dt <= last):
1039
return i+1
1040
REVISION_NAMESPACES['date:'] = _namespace_date
967
from bzrlib.commit import Commit
968
Commit().commit(self, *args, **kw)
969
970
def revision_id_to_revno(self, revision_id):
971
"""Given a revision id, return its revno"""
972
if revision_id is None:
973
return 0
974
history = self.revision_history()
975
try:
976
return history.index(revision_id) + 1
977
except ValueError:
978
raise bzrlib.errors.NoSuchRevision(self, revision_id)
979
980
def get_rev_id(self, revno, history=None):
981
"""Find the revision id of the specified revno."""
982
if revno == 0:
983
return None
984
if history is None:
985
history = self.revision_history()
986
elif revno <= 0 or revno > len(history):
987
raise bzrlib.errors.NoSuchRevision(self, revno)
988
return history[revno - 1]
1041
989
1042
990
def revision_tree(self, revision_id):
1043
991
"""Return Tree for a revision on this branch.
1050
998
return EmptyTree()
1051
999
else:
1052
1000
inv = self.get_revision_inventory(revision_id)
1053
return RevisionTree(self.text_store, inv)
1001
return RevisionTree(self.weave_store, inv, revision_id)
1054
1002
1055
1003
1056
1004
def working_tree(self):
1057
1005
"""Return a `Tree` for the working copy."""
1058
from workingtree import WorkingTree
1059
return WorkingTree(self.base, self.read_working_inventory())
1006
from bzrlib.workingtree import WorkingTree
1007
# TODO: In the future, WorkingTree should utilize Transport
1008
# RobertCollins 20051003 - I don't think it should - working trees are
1009
# much more complex to keep consistent than our careful .bzr subset.
1010
# instead, we should say that working trees are local only, and optimise
1011
# for that.
1012
return WorkingTree(self._transport.base, self.read_working_inventory())
1060
1013
1061
1014
1062
1015
def basis_tree(self):
1064
1017
1065
1018
If there are no revisions yet, return an `EmptyTree`.
1066
1019
"""
1067
r = self.last_patch()
1068
if r == None:
1069
return EmptyTree()
1070
else:
1071
return RevisionTree(self.text_store, self.get_revision_inventory(r))
1072
1020
return self.revision_tree(self.last_revision())
1073
1021
1074
1022
1075
1023
def rename_one(self, from_rel, to_rel):
1107
1055
1108
1056
inv.rename(file_id, to_dir_id, to_tail)
1109
1057
1110
print "%s => %s" % (from_rel, to_rel)
1111
1112
1058
from_abs = self.abspath(from_rel)
1113
1059
to_abs = self.abspath(to_rel)
1114
1060
try:
1115
os.rename(from_abs, to_abs)
1061
rename(from_abs, to_abs)
1116
1062
except OSError, e:
1117
1063
raise BzrError("failed to rename %r to %r: %s"
1118
1064
% (from_abs, to_abs, e[1]),
1133
1079
1134
1080
Note that to_name is only the last component of the new name;
1135
1081
this doesn't change the directory.
1082
1083
This returns a list of (from_path, to_path) pairs for each
1084
entry that is moved.
1136
1085
"""
1086
result = []
1137
1087
self.lock_write()
1138
1088
try:
1139
1089
## TODO: Option to move IDs only
1174
1124
for f in from_paths:
1175
1125
name_tail = splitpath(f)[-1]
1176
1126
dest_path = appendpath(to_name, name_tail)
1177
print "%s => %s" % (f, dest_path)
1127
result.append((f, dest_path))
1178
1128
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1179
1129
try:
1180
os.rename(self.abspath(f), self.abspath(dest_path))
1130
rename(self.abspath(f), self.abspath(dest_path))
1181
1131
except OSError, e:
1182
1132
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1183
1133
["rename rolled back"])
1186
1136
finally:
1187
1137
self.unlock()
1188
1138
1139
return result
1140
1189
1141
1190
1142
def revert(self, filenames, old_tree=None, backups=True):
1191
1143
"""Restore selected files to the versions from a previous tree.
1237
1189
These are revisions that have been merged into the working
1238
1190
directory but not yet committed.
1239
1191
"""
1240
cfn = self.controlfilename('pending-merges')
1241
if not os.path.exists(cfn):
1192
cfn = self._rel_controlfilename('pending-merges')
1193
if not self._transport.has(cfn):
1242
1194
return []
1243
1195
p = []
1244
1196
for l in self.controlfile('pending-merges', 'r').readlines():
1246
1198
return p
1247
1199
1248
1200
1249
def add_pending_merge(self, revision_id):
1250
from bzrlib.revision import validate_revision_id
1251
1252
validate_revision_id(revision_id)
1253
1201
def add_pending_merge(self, *revision_ids):
1202
# TODO: Perhaps should check at this point that the
1203
# history of the revision is actually present?
1254
1204
p = self.pending_merges()
1255
if revision_id in p:
1256
return
1257
p.append(revision_id)
1258
self.set_pending_merges(p)
1259
1205
updated = False
1206
for rev_id in revision_ids:
1207
if rev_id in p:
1208
continue
1209
p.append(rev_id)
1210
updated = True
1211
if updated:
1212
self.set_pending_merges(p)
1260
1213
1261
1214
def set_pending_merges(self, rev_list):
1215
self.lock_write()
1216
try:
1217
self.put_controlfile('pending-merges', '\n'.join(rev_list))
1218
finally:
1219
self.unlock()
1220
1221
1222
def get_parent(self):
1223
"""Return the parent location of the branch.
1224
1225
This is the default location for push/pull/missing. The usual
1226
pattern is that the user can override it by specifying a
1227
location.
1228
"""
1229
import errno
1230
_locs = ['parent', 'pull', 'x-pull']
1231
for l in _locs:
1232
try:
1233
return self.controlfile(l, 'r').read().strip('\n')
1234
except IOError, e:
1235
if e.errno != errno.ENOENT:
1236
raise
1237
return None
1238
1239
1240
def set_parent(self, url):
1241
# TODO: Maybe delete old location files?
1262
1242
from bzrlib.atomicfile import AtomicFile
1263
1243
self.lock_write()
1264
1244
try:
1265
f = AtomicFile(self.controlfilename('pending-merges'))
1245
f = AtomicFile(self.controlfilename('parent'))
1266
1246
try:
1267
for l in rev_list:
1268
print >>f, l
1247
f.write(url + '\n')
1269
1248
f.commit()
1270
1249
finally:
1271
1250
f.close()
1272
1251
finally:
1273
1252
self.unlock()
1274
1253
1275
1276
1277
class ScratchBranch(Branch):
1254
def check_revno(self, revno):
1255
"""\
1256
Check whether a revno corresponds to any revision.
1257
Zero (the NULL revision) is considered valid.
1258
"""
1259
if revno != 0:
1260
self.check_real_revno(revno)
1261
1262
def check_real_revno(self, revno):
1263
"""\
1264
Check whether a revno corresponds to a real revision.
1265
Zero (the NULL revision) is considered invalid
1266
"""
1267
if revno < 1 or revno > self.revno():
1268
raise InvalidRevisionNumber(revno)
1269
1270
1271
1272
1273
1274
class ScratchBranch(_Branch):
1278
1275
"""Special test class: a branch that cleans up after itself.
1279
1276
1280
1277
>>> b = ScratchBranch()
1297
1294
if base is None:
1298
1295
base = mkdtemp()
1299
1296
init = True
1300
Branch.__init__(self, base, init=init)
1297
if isinstance(base, basestring):
1298
base = get_transport(base)
1299
_Branch.__init__(self, base, init=init)
1301
1300
for d in dirs:
1302
os.mkdir(self.abspath(d))
1301
self._transport.mkdir(d)
1303
1302
1304
1303
for f in files:
1305
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
1304
self._transport.put(f, 'content of %s' % f)
1306
1305
1307
1306
1308
1307
def clone(self):
1309
1308
"""
1310
1309
>>> orig = ScratchBranch(files=["file1", "file2"])
1311
1310
>>> clone = orig.clone()
1312
>>> os.path.samefile(orig.base, clone.base)
1311
>>> if os.name != 'nt':
1312
... os.path.samefile(orig.base, clone.base)
1313
... else:
1314
... orig.base == clone.base
1315
...
1313
1316
False
1314
1317
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1315
1318
True
1320
1323
os.rmdir(base)
1321
1324
copytree(self.base, base, symlinks=True)
1322
1325
return ScratchBranch(base=base)
1323
1326
1324
1327
def __del__(self):
1325
1328
self.destroy()
1326
1329
1339
1342
for name in files:
1340
1343
os.chmod(os.path.join(root, name), 0700)
1341
1344
rmtree(self.base)
1342
self.base = None
1345
self._transport = None
1343
1346
1344
1347
1345
1348
1395
1398
"""Return a new tree-root file id."""
1396
1399
return gen_file_id('TREE_ROOT')
1397
1400
1401
Loggerhead is a web-based interface for Breezy
Version: 2.0.1