« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1393.2.4
- compare with another revision
- download diff
- download tarball
- view history from revision 1393.2.4
- Committer: John Arbash Meinel
- Date: 2005-09-29 21:13:03 UTC
- mto: (1393.1.12)
- mto: This revision was merged to the branch mainline in revision 1396.
- Revision ID: john@arbash-meinel.com-20050929211303-7f1f9bf969d65dc3
All tests pass.
- files added:
- .rsyncexclude
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/store
- bzrlib/transport
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/urlgrabber
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- patches
- tools
- files removed:
- bzrlib/tests.py
- files renamed:
- bzrlib/store.py => bzrlib/store/__init__.py
- elementtree/ => bzrlib/util/elementtree/
- bzrlib/newinventory.py => contrib/newinventory.py
- files modified:
- .bzrignore
added
removed
bzrlib/branch.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
18
from sets import Set
18
import sys
19
import os
20
import errno
21
from warnings import warn
22
from cStringIO import StringIO
19
23
20
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
21
import traceback, socket, fnmatch, difflib, time
22
from binascii import hexlify
23
24
24
25
import bzrlib
25
from inventory import Inventory
26
from trace import mutter, note
27
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
28
from inventory import InventoryEntry, Inventory
29
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, chomp, \
30
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
31
joinpath, sha_string, file_kind, local_time_offset, appendpath
32
from store import ImmutableStore
33
from revision import Revision
34
from errors import bailout
35
from textui import show_status
36
from diff import diff_trees
37
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
26
from bzrlib.trace import mutter, note
27
from bzrlib.osutils import (isdir, quotefn, compact_date, rand_bytes,
28
rename, splitpath, sha_file, appendpath,
29
file_kind)
30
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
31
NoSuchRevision, HistoryMissing, NotBranchError,
32
DivergedBranches, LockError, UnlistableStore,
33
UnlistableBranch, NoSuchFile)
34
from bzrlib.textui import show_status
35
from bzrlib.revision import Revision, validate_revision_id, is_ancestor
36
from bzrlib.delta import compare_trees
37
from bzrlib.tree import EmptyTree, RevisionTree
38
from bzrlib.inventory import Inventory
39
from bzrlib.store import copy_all
40
from bzrlib.store.compressed_text import CompressedTextStore
41
from bzrlib.store.text import TextStore
42
from bzrlib.store.weave import WeaveStore
43
from bzrlib.transport import Transport, get_transport
44
import bzrlib.xml5
45
import bzrlib.ui
46
47
48
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
49
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
39
50
## TODO: Maybe include checks for common corruption of newlines, etc?
40
51
41
52
42
43
def find_branch_root(f=None):
44
"""Find the branch root enclosing f, or pwd.
45
46
It is not necessary that f exists.
53
# TODO: Some operations like log might retrieve the same revisions
54
# repeatedly to calculate deltas. We could perhaps have a weakref
55
# cache in memory to make this faster. In general anything can be
56
# cached in memory between lock and unlock operations.
57
58
def find_branch(*ignored, **ignored_too):
59
# XXX: leave this here for about one release, then remove it
60
raise NotImplementedError('find_branch() is not supported anymore, '
61
'please use one of the new branch constructors')
62
def _relpath(base, path):
63
"""Return path relative to base, or raise exception.
64
65
The path may be either an absolute path or a path relative to the
66
current working directory.
67
68
Lifted out of Branch.relpath for ease of testing.
69
70
os.path.commonprefix (python2.4) has a bad bug that it works just
71
on string prefixes, assuming that '/u' is a prefix of '/u2'. This
72
avoids that problem."""
73
rp = os.path.abspath(path)
74
75
s = []
76
head = rp
77
while len(head) >= len(base):
78
if head == base:
79
break
80
head, tail = os.path.split(head)
81
if tail:
82
s.insert(0, tail)
83
else:
84
raise NotBranchError("path %r is not within branch %r" % (rp, base))
85
86
return os.sep.join(s)
87
88
89
def find_branch_root(t):
90
"""Find the branch root enclosing the transport's base.
91
92
t is a Transport object.
93
94
It is not necessary that the base of t exists.
47
95
48
96
Basically we keep looking up until we find the control directory or
49
run into the root."""
50
if f is None:
51
f = os.getcwd()
52
elif hasattr(os.path, 'realpath'):
53
f = os.path.realpath(f)
54
else:
55
f = os.path.abspath(f)
56
57
orig_f = f
58
59
last_f = f
97
run into the root. If there isn't one, raises NotBranchError.
98
"""
99
orig_base = t.base
60
100
while True:
61
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
62
return f
63
head, tail = os.path.split(f)
64
if head == f:
101
if t.has(bzrlib.BZRDIR):
102
return t
103
new_t = t.clone('..')
104
if new_t.base == t.base:
65
105
# reached the root, whatever that may be
66
bailout('%r is not in a branch' % orig_f)
67
f = head
68
106
raise NotBranchError('%s is not in a branch' % orig_base)
107
t = new_t
69
108
70
109
71
110
######################################################################
72
111
# branch objects
73
112
74
class Branch:
113
class Branch(object):
75
114
"""Branch holding a history of revisions.
76
115
77
:todo: Perhaps use different stores for different classes of object,
78
so that we can keep track of how much space each one uses,
79
or garbage-collect them.
80
81
:todo: Add a RemoteBranch subclass. For the basic case of read-only
82
HTTP access this should be very easy by,
83
just redirecting controlfile access into HTTP requests.
84
We would need a RemoteStore working similarly.
85
86
:todo: Keep the on-disk branch locked while the object exists.
87
88
:todo: mkdir() method.
89
"""
90
def __init__(self, base, init=False, find_root=True):
116
base
117
Base directory/url of the branch.
118
"""
119
base = None
120
121
def __init__(self, *ignored, **ignored_too):
122
raise NotImplementedError('The Branch class is abstract')
123
124
@staticmethod
125
def open_downlevel(base):
126
"""Open a branch which may be of an old format.
127
128
Only local branches are supported."""
129
return _Branch(base, relax_version_check=True)
130
131
@staticmethod
132
def open(base):
133
"""Open an existing branch, rooted at 'base' (url)"""
134
t = get_transport(base)
135
return _Branch(t)
136
137
@staticmethod
138
def open_containing(url):
139
"""Open an existing branch which contains url.
140
141
This probes for a branch at url, and searches upwards from there.
142
"""
143
t = get_transport(url)
144
t = find_branch_root(t)
145
return _Branch(t)
146
147
@staticmethod
148
def initialize(base):
149
"""Create a new branch, rooted at 'base' (url)"""
150
t = get_transport(base)
151
return _Branch(t, init=True)
152
153
def setup_caching(self, cache_root):
154
"""Subclasses that care about caching should override this, and set
155
up cached stores located under cache_root.
156
"""
157
158
159
class _Branch(Branch):
160
"""A branch stored in the actual filesystem.
161
162
Note that it's "local" in the context of the filesystem; it doesn't
163
really matter if it's on an nfs/smb/afs/coda/... share, as long as
164
it's writable, and can be accessed via the normal filesystem API.
165
166
_lock_mode
167
None, or 'r' or 'w'
168
169
_lock_count
170
If _lock_mode is true, a positive count of the number of times the
171
lock has been taken.
172
173
_lock
174
Lock object from bzrlib.lock.
175
"""
176
# We actually expect this class to be somewhat short-lived; part of its
177
# purpose is to try to isolate what bits of the branch logic are tied to
178
# filesystem access, so that in a later step, we can extricate them to
179
# a separarte ("storage") class.
180
_lock_mode = None
181
_lock_count = None
182
_lock = None
183
_inventory_weave = None
184
185
# Map some sort of prefix into a namespace
186
# stuff like "revno:10", "revid:", etc.
187
# This should match a prefix with a function which accepts
188
REVISION_NAMESPACES = {}
189
190
def push_stores(self, branch_to):
191
"""Copy the content of this branches store to branch_to."""
192
if (self._branch_format != branch_to._branch_format
193
or self._branch_format != 4):
194
from bzrlib.fetch import greedy_fetch
195
mutter("falling back to fetch logic to push between %s(%s) and %s(%s)",
196
self, self._branch_format, branch_to, branch_to._branch_format)
197
greedy_fetch(to_branch=branch_to, from_branch=self,
198
revision=self.last_revision())
199
return
200
201
store_pairs = ((self.text_store, branch_to.text_store),
202
(self.inventory_store, branch_to.inventory_store),
203
(self.revision_store, branch_to.revision_store))
204
try:
205
for from_store, to_store in store_pairs:
206
copy_all(from_store, to_store)
207
except UnlistableStore:
208
raise UnlistableBranch(from_store)
209
210
def __init__(self, transport, init=False,
211
relax_version_check=False):
91
212
"""Create new branch object at a particular location.
92
213
93
:param base: Base directory for the branch.
214
transport -- A Transport object, defining how to access files.
215
(If a string, transport.transport() will be used to
216
create a Transport object)
94
217
95
:param init: If True, create new control files in a previously
218
init -- If True, create new control files in a previously
96
219
unversioned directory. If False, the branch must already
97
220
be versioned.
98
221
99
:param find_root: If true and init is false, find the root of the
100
existing branch containing base.
222
relax_version_check -- If true, the usual check for the branch
223
version is not applied. This is intended only for
224
upgrade/recovery type use; it's not guaranteed that
225
all operations will work on old format branches.
101
226
102
227
In the test suite, creation of new trees is tested using the
103
228
`ScratchBranch` class.
104
229
"""
230
assert isinstance(transport, Transport)
231
self._transport = transport
105
232
if init:
106
self.base = os.path.realpath(base)
107
233
self._make_control()
108
elif find_root:
109
self.base = find_branch_root(base)
110
else:
111
self.base = os.path.realpath(base)
112
if not isdir(self.controlfilename('.')):
113
bailout("not a bzr branch: %s" % quotefn(base),
114
['use "bzr init" to initialize a new working tree',
115
'current bzr can only operate from top-of-tree'])
116
self._check_format()
117
118
self.text_store = ImmutableStore(self.controlfilename('text-store'))
119
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
120
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
121
234
self._check_format(relax_version_check)
235
236
def get_store(name, compressed=True):
237
relpath = self._rel_controlfilename(name)
238
if compressed:
239
store = CompressedTextStore(self._transport.clone(relpath))
240
else:
241
store = TextStore(self._transport.clone(relpath))
242
if self._transport.should_cache():
243
from meta_store import CachedStore
244
cache_path = os.path.join(self.cache_root, name)
245
os.mkdir(cache_path)
246
store = CachedStore(store, cache_path)
247
return store
248
def get_weave(name):
249
relpath = self._rel_controlfilename(name)
250
ws = WeaveStore(self._transport.clone(relpath))
251
if self._transport.should_cache():
252
ws.enable_cache = True
253
return ws
254
255
if self._branch_format == 4:
256
self.inventory_store = get_store('inventory-store')
257
self.text_store = get_store('text-store')
258
self.revision_store = get_store('revision-store')
259
elif self._branch_format == 5:
260
self.control_weaves = get_weave([])
261
self.weave_store = get_weave('weaves')
262
self.revision_store = get_store('revision-store', compressed=False)
122
263
123
264
def __str__(self):
124
return '%s(%r)' % (self.__class__.__name__, self.base)
265
return '%s(%r)' % (self.__class__.__name__, self._transport.base)
125
266
126
267
127
268
__repr__ = __str__
128
269
129
270
271
def __del__(self):
272
if self._lock_mode or self._lock:
273
# XXX: This should show something every time, and be suitable for
274
# headless operation and embedding
275
warn("branch %r was not explicitly unlocked" % self)
276
self._lock.unlock()
277
278
# TODO: It might be best to do this somewhere else,
279
# but it is nice for a Branch object to automatically
280
# cache it's information.
281
# Alternatively, we could have the Transport objects cache requests
282
# See the earlier discussion about how major objects (like Branch)
283
# should never expect their __del__ function to run.
284
if hasattr(self, 'cache_root') and self.cache_root is not None:
285
try:
286
import shutil
287
shutil.rmtree(self.cache_root)
288
except:
289
pass
290
self.cache_root = None
291
292
def _get_base(self):
293
if self._transport:
294
return self._transport.base
295
return None
296
297
base = property(_get_base)
298
299
300
def lock_write(self):
301
# TODO: Upgrade locking to support using a Transport,
302
# and potentially a remote locking protocol
303
if self._lock_mode:
304
if self._lock_mode != 'w':
305
raise LockError("can't upgrade to a write lock from %r" %
306
self._lock_mode)
307
self._lock_count += 1
308
else:
309
self._lock = self._transport.lock_write(
310
self._rel_controlfilename('branch-lock'))
311
self._lock_mode = 'w'
312
self._lock_count = 1
313
314
315
def lock_read(self):
316
if self._lock_mode:
317
assert self._lock_mode in ('r', 'w'), \
318
"invalid lock mode %r" % self._lock_mode
319
self._lock_count += 1
320
else:
321
self._lock = self._transport.lock_read(
322
self._rel_controlfilename('branch-lock'))
323
self._lock_mode = 'r'
324
self._lock_count = 1
325
326
def unlock(self):
327
if not self._lock_mode:
328
raise LockError('branch %r is not locked' % (self))
329
330
if self._lock_count > 1:
331
self._lock_count -= 1
332
else:
333
self._lock.unlock()
334
self._lock = None
335
self._lock_mode = self._lock_count = None
336
130
337
def abspath(self, name):
131
338
"""Return absolute filename for something in the branch"""
132
return os.path.join(self.base, name)
133
339
return self._transport.abspath(name)
134
340
135
341
def relpath(self, path):
136
342
"""Return path relative to this branch of something inside it.
137
343
138
344
Raises an error if path is not in this branch."""
139
rp = os.path.realpath(path)
140
# FIXME: windows
141
if not rp.startswith(self.base):
142
bailout("path %r is not within branch %r" % (rp, self.base))
143
rp = rp[len(self.base):]
144
rp = rp.lstrip(os.sep)
145
return rp
146
345
return self._transport.relpath(path)
346
347
348
def _rel_controlfilename(self, file_or_path):
349
if isinstance(file_or_path, basestring):
350
file_or_path = [file_or_path]
351
return [bzrlib.BZRDIR] + file_or_path
147
352
148
353
def controlfilename(self, file_or_path):
149
354
"""Return location relative to branch."""
150
if isinstance(file_or_path, types.StringTypes):
151
file_or_path = [file_or_path]
152
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
355
return self._transport.abspath(self._rel_controlfilename(file_or_path))
153
356
154
357
155
358
def controlfile(self, file_or_path, mode='r'):
156
"""Open a control file for this branch"""
157
return file(self.controlfilename(file_or_path), mode)
158
359
"""Open a control file for this branch.
360
361
There are two classes of file in the control directory: text
362
and binary. binary files are untranslated byte streams. Text
363
control files are stored with Unix newlines and in UTF-8, even
364
if the platform or locale defaults are different.
365
366
Controlfiles should almost never be opened in write mode but
367
rather should be atomically copied and replaced using atomicfile.
368
"""
369
import codecs
370
371
relpath = self._rel_controlfilename(file_or_path)
372
#TODO: codecs.open() buffers linewise, so it was overloaded with
373
# a much larger buffer, do we need to do the same for getreader/getwriter?
374
if mode == 'rb':
375
return self._transport.get(relpath)
376
elif mode == 'wb':
377
raise BzrError("Branch.controlfile(mode='wb') is not supported, use put_controlfiles")
378
elif mode == 'r':
379
return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
380
elif mode == 'w':
381
raise BzrError("Branch.controlfile(mode='w') is not supported, use put_controlfiles")
382
else:
383
raise BzrError("invalid controlfile mode %r" % mode)
384
385
def put_controlfile(self, path, f, encode=True):
386
"""Write an entry as a controlfile.
387
388
:param path: The path to put the file, relative to the .bzr control
389
directory
390
:param f: A file-like or string object whose contents should be copied.
391
:param encode: If true, encode the contents as utf-8
392
"""
393
self.put_controlfiles([(path, f)], encode=encode)
394
395
def put_controlfiles(self, files, encode=True):
396
"""Write several entries as controlfiles.
397
398
:param files: A list of [(path, file)] pairs, where the path is the directory
399
underneath the bzr control directory
400
:param encode: If true, encode the contents as utf-8
401
"""
402
import codecs
403
ctrl_files = []
404
for path, f in files:
405
if encode:
406
if isinstance(f, basestring):
407
f = f.encode('utf-8', 'replace')
408
else:
409
f = codecs.getwriter('utf-8')(f, errors='replace')
410
path = self._rel_controlfilename(path)
411
ctrl_files.append((path, f))
412
self._transport.put_multi(ctrl_files)
159
413
160
414
def _make_control(self):
161
os.mkdir(self.controlfilename([]))
162
self.controlfile('README', 'w').write(
415
from bzrlib.inventory import Inventory
416
from bzrlib.weavefile import write_weave_v5
417
from bzrlib.weave import Weave
418
419
# Create an empty inventory
420
sio = StringIO()
421
# if we want per-tree root ids then this is the place to set
422
# them; they're not needed for now and so ommitted for
423
# simplicity.
424
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), sio)
425
empty_inv = sio.getvalue()
426
sio = StringIO()
427
bzrlib.weavefile.write_weave_v5(Weave(), sio)
428
empty_weave = sio.getvalue()
429
430
dirs = [[], 'revision-store', 'weaves']
431
files = [('README',
163
432
"This is a Bazaar-NG control directory.\n"
164
"Do not change any files in this directory.")
165
self.controlfile('branch-format', 'wb').write(BZR_BRANCH_FORMAT)
166
for d in ('text-store', 'inventory-store', 'revision-store'):
167
os.mkdir(self.controlfilename(d))
168
for f in ('revision-history', 'merged-patches',
169
'pending-merged-patches', 'branch-name'):
170
self.controlfile(f, 'w').write('')
171
mutter('created control directory in ' + self.base)
172
Inventory().write_xml(self.controlfile('inventory','w'))
173
174
175
def _check_format(self):
433
"Do not change any files in this directory.\n"),
434
('branch-format', BZR_BRANCH_FORMAT_5),
435
('revision-history', ''),
436
('branch-name', ''),
437
('branch-lock', ''),
438
('pending-merges', ''),
439
('inventory', empty_inv),
440
('inventory.weave', empty_weave),
441
('ancestry.weave', empty_weave)
442
]
443
cfn = self._rel_controlfilename
444
self._transport.mkdir_multi([cfn(d) for d in dirs])
445
self.put_controlfiles(files)
446
mutter('created control directory in ' + self._transport.base)
447
448
def _check_format(self, relax_version_check):
176
449
"""Check this branch format is supported.
177
450
178
The current tool only supports the current unstable format.
451
The format level is stored, as an integer, in
452
self._branch_format for code that needs to check it later.
179
453
180
454
In the future, we might need different in-memory Branch
181
455
classes to support downlevel branches. But not yet.
182
456
"""
183
# This ignores newlines so that we can open branches created
184
# on Windows from Linux and so on. I think it might be better
185
# to always make all internal files in unix format.
186
fmt = self.controlfile('branch-format', 'rb').read()
187
fmt.replace('\r\n', '')
188
if fmt != BZR_BRANCH_FORMAT:
189
bailout('sorry, branch format %r not supported' % fmt,
190
['use a different bzr version',
191
'or remove the .bzr directory and "bzr init" again'])
192
457
try:
458
fmt = self.controlfile('branch-format', 'r').read()
459
except NoSuchFile:
460
raise NotBranchError(self.base)
461
462
if fmt == BZR_BRANCH_FORMAT_5:
463
self._branch_format = 5
464
elif fmt == BZR_BRANCH_FORMAT_4:
465
self._branch_format = 4
466
467
if (not relax_version_check
468
and self._branch_format != 5):
469
raise BzrError('sorry, branch format %r not supported' % fmt,
470
['use a different bzr version',
471
'or remove the .bzr directory'
472
' and "bzr init" again'])
473
474
def get_root_id(self):
475
"""Return the id of this branches root"""
476
inv = self.read_working_inventory()
477
return inv.root.file_id
478
479
def set_root_id(self, file_id):
480
inv = self.read_working_inventory()
481
orig_root_id = inv.root.file_id
482
del inv._byid[inv.root.file_id]
483
inv.root.file_id = file_id
484
inv._byid[inv.root.file_id] = inv.root
485
for fid in inv:
486
entry = inv[fid]
487
if entry.parent_id in (None, orig_root_id):
488
entry.parent_id = inv.root.file_id
489
self._write_inventory(inv)
193
490
194
491
def read_working_inventory(self):
195
492
"""Read the working inventory."""
196
before = time.time()
197
inv = Inventory.read_xml(self.controlfile('inventory', 'r'))
198
mutter("loaded inventory of %d items in %f"
199
% (len(inv), time.time() - before))
200
return inv
201
493
self.lock_read()
494
try:
495
# ElementTree does its own conversion from UTF-8, so open in
496
# binary.
497
f = self.controlfile('inventory', 'rb')
498
return bzrlib.xml5.serializer_v5.read_inventory(f)
499
finally:
500
self.unlock()
501
202
502
203
503
def _write_inventory(self, inv):
204
504
"""Update the working inventory.
206
506
That is to say, the inventory describing changes underway, that
207
507
will be committed to the next revision.
208
508
"""
209
## TODO: factor out to atomicfile? is rename safe on windows?
210
## TODO: Maybe some kind of clean/dirty marker on inventory?
211
tmpfname = self.controlfilename('inventory.tmp')
212
tmpf = file(tmpfname, 'w')
213
inv.write_xml(tmpf)
214
tmpf.close()
215
inv_fname = self.controlfilename('inventory')
216
if sys.platform == 'win32':
217
os.remove(inv_fname)
218
os.rename(tmpfname, inv_fname)
509
from cStringIO import StringIO
510
self.lock_write()
511
try:
512
sio = StringIO()
513
bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
514
sio.seek(0)
515
# Transport handles atomicity
516
self.put_controlfile('inventory', sio)
517
finally:
518
self.unlock()
519
219
520
mutter('wrote working inventory')
220
521
221
522
222
523
inventory = property(read_working_inventory, _write_inventory, None,
223
524
"""Inventory for the working copy.""")
224
525
225
526
226
def add(self, files, verbose=False):
527
def add(self, files, ids=None):
227
528
"""Make files versioned.
228
529
530
Note that the command line normally calls smart_add instead,
531
which can automatically recurse.
532
229
533
This puts the files in the Added state, so that they will be
230
534
recorded by the next commit.
231
535
232
:todo: Perhaps have an option to add the ids even if the files do
233
not (yet) exist.
234
235
:todo: Perhaps return the ids of the files? But then again it
236
is easy to retrieve them if they're needed.
237
238
:todo: Option to specify file id.
239
240
:todo: Adding a directory should optionally recurse down and
241
add all non-ignored children. Perhaps do that in a
242
higher-level method.
243
244
>>> b = ScratchBranch(files=['foo'])
245
>>> 'foo' in b.unknowns()
246
True
247
>>> b.show_status()
248
? foo
249
>>> b.add('foo')
250
>>> 'foo' in b.unknowns()
251
False
252
>>> bool(b.inventory.path2id('foo'))
253
True
254
>>> b.show_status()
255
A foo
256
257
>>> b.add('foo')
258
Traceback (most recent call last):
259
...
260
BzrError: ('foo is already versioned', [])
261
262
>>> b.add(['nothere'])
263
Traceback (most recent call last):
264
BzrError: ('cannot add: not a regular file or directory: nothere', [])
536
files
537
List of paths to add, relative to the base of the tree.
538
539
ids
540
If set, use these instead of automatically generated ids.
541
Must be the same length as the list of files, but may
542
contain None for ids that are to be autogenerated.
543
544
TODO: Perhaps have an option to add the ids even if the files do
545
not (yet) exist.
546
547
TODO: Perhaps yield the ids and paths as they're added.
265
548
"""
266
267
549
# TODO: Re-adding a file that is removed in the working copy
268
550
# should probably put it back with the previous ID.
269
if isinstance(files, types.StringTypes):
551
if isinstance(files, basestring):
552
assert(ids is None or isinstance(ids, basestring))
270
553
files = [files]
271
272
inv = self.read_working_inventory()
273
for f in files:
274
if is_control_file(f):
275
bailout("cannot add control file %s" % quotefn(f))
276
277
fp = splitpath(f)
278
279
if len(fp) == 0:
280
bailout("cannot add top-level %r" % f)
281
282
fullpath = os.path.normpath(self.abspath(f))
283
284
try:
285
kind = file_kind(fullpath)
286
except OSError:
287
# maybe something better?
288
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
289
290
if kind != 'file' and kind != 'directory':
291
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
292
293
file_id = gen_file_id(f)
294
inv.add_path(f, kind=kind, file_id=file_id)
295
296
if verbose:
297
show_status('A', kind, quotefn(f))
298
299
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
300
301
self._write_inventory(inv)
302
554
if ids is not None:
555
ids = [ids]
556
557
if ids is None:
558
ids = [None] * len(files)
559
else:
560
assert(len(ids) == len(files))
561
562
self.lock_write()
563
try:
564
inv = self.read_working_inventory()
565
for f,file_id in zip(files, ids):
566
if is_control_file(f):
567
raise BzrError("cannot add control file %s" % quotefn(f))
568
569
fp = splitpath(f)
570
571
if len(fp) == 0:
572
raise BzrError("cannot add top-level %r" % f)
573
574
fullpath = os.path.normpath(self.abspath(f))
575
576
try:
577
kind = file_kind(fullpath)
578
except OSError:
579
# maybe something better?
580
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
581
582
if kind != 'file' and kind != 'directory':
583
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
584
585
if file_id is None:
586
file_id = gen_file_id(f)
587
inv.add_path(f, kind=kind, file_id=file_id)
588
589
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
590
591
self._write_inventory(inv)
592
finally:
593
self.unlock()
594
595
596
def print_file(self, file, revno):
597
"""Print `file` to stdout."""
598
self.lock_read()
599
try:
600
tree = self.revision_tree(self.get_rev_id(revno))
601
# use inventory as it was in that revision
602
file_id = tree.inventory.path2id(file)
603
if not file_id:
604
raise BzrError("%r is not present in revision %s" % (file, revno))
605
tree.print_file(file_id)
606
finally:
607
self.unlock()
303
608
304
609
305
610
def remove(self, files, verbose=False):
307
612
308
613
This does not remove their text. This does not run on
309
614
310
:todo: Refuse to remove modified files unless --force is given?
311
312
>>> b = ScratchBranch(files=['foo'])
313
>>> b.add('foo')
314
>>> b.inventory.has_filename('foo')
315
True
316
>>> b.remove('foo')
317
>>> b.working_tree().has_filename('foo')
318
True
319
>>> b.inventory.has_filename('foo')
320
False
321
322
>>> b = ScratchBranch(files=['foo'])
323
>>> b.add('foo')
324
>>> b.commit('one')
325
>>> b.remove('foo')
326
>>> b.commit('two')
327
>>> b.inventory.has_filename('foo')
328
False
329
>>> b.basis_tree().has_filename('foo')
330
False
331
>>> b.working_tree().has_filename('foo')
332
True
333
334
:todo: Do something useful with directories.
335
336
:todo: Should this remove the text or not? Tough call; not
615
TODO: Refuse to remove modified files unless --force is given?
616
617
TODO: Do something useful with directories.
618
619
TODO: Should this remove the text or not? Tough call; not
337
620
removing may be useful and the user can just use use rm, and
338
621
is the opposite of add. Removing it is consistent with most
339
622
other tools. Maybe an option.
340
623
"""
341
624
## TODO: Normalize names
342
625
## TODO: Remove nested loops; better scalability
343
344
if isinstance(files, types.StringTypes):
626
if isinstance(files, basestring):
345
627
files = [files]
346
347
tree = self.working_tree()
348
inv = tree.inventory
349
350
# do this before any modifications
351
for f in files:
352
fid = inv.path2id(f)
353
if not fid:
354
bailout("cannot remove unversioned file %s" % quotefn(f))
355
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
356
if verbose:
357
# having remove it, it must be either ignored or unknown
358
if tree.is_ignored(f):
359
new_status = 'I'
360
else:
361
new_status = '?'
362
show_status(new_status, inv[fid].kind, quotefn(f))
363
del inv[fid]
364
628
629
self.lock_write()
630
631
try:
632
tree = self.working_tree()
633
inv = tree.inventory
634
635
# do this before any modifications
636
for f in files:
637
fid = inv.path2id(f)
638
if not fid:
639
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
640
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
641
if verbose:
642
# having remove it, it must be either ignored or unknown
643
if tree.is_ignored(f):
644
new_status = 'I'
645
else:
646
new_status = '?'
647
show_status(new_status, inv[fid].kind, quotefn(f))
648
del inv[fid]
649
650
self._write_inventory(inv)
651
finally:
652
self.unlock()
653
654
655
# FIXME: this doesn't need to be a branch method
656
def set_inventory(self, new_inventory_list):
657
from bzrlib.inventory import Inventory, InventoryEntry
658
inv = Inventory(self.get_root_id())
659
for path, file_id, parent, kind in new_inventory_list:
660
name = os.path.basename(path)
661
if name == "":
662
continue
663
inv.add(InventoryEntry(file_id, name, kind, parent))
365
664
self._write_inventory(inv)
366
665
367
666
384
683
return self.working_tree().unknowns()
385
684
386
685
387
def commit(self, message, timestamp=None, timezone=None,
388
committer=None,
389
verbose=False):
390
"""Commit working copy as a new revision.
391
392
The basic approach is to add all the file texts into the
393
store, then the inventory, then make a new revision pointing
394
to that inventory and store that.
395
396
This is not quite safe if the working copy changes during the
397
commit; for the moment that is simply not allowed. A better
398
approach is to make a temporary copy of the files before
399
computing their hashes, and then add those hashes in turn to
400
the inventory. This should mean at least that there are no
401
broken hash pointers. There is no way we can get a snapshot
402
of the whole directory at an instant. This would also have to
403
be robust against files disappearing, moving, etc. So the
404
whole thing is a bit hard.
405
406
:param timestamp: if not None, seconds-since-epoch for a
407
postdated/predated commit.
408
"""
409
410
## TODO: Show branch names
411
412
# TODO: Don't commit if there are no changes, unless forced?
413
414
# First walk over the working inventory; and both update that
415
# and also build a new revision inventory. The revision
416
# inventory needs to hold the text-id, sha1 and size of the
417
# actual file versions committed in the revision. (These are
418
# not present in the working inventory.) We also need to
419
# detect missing/deleted files, and remove them from the
420
# working inventory.
421
422
work_inv = self.read_working_inventory()
423
inv = Inventory()
424
basis = self.basis_tree()
425
basis_inv = basis.inventory
426
missing_ids = []
427
for path, entry in work_inv.iter_entries():
428
## TODO: Cope with files that have gone missing.
429
430
## TODO: Check that the file kind has not changed from the previous
431
## revision of this file (if any).
432
433
entry = entry.copy()
434
435
p = self.abspath(path)
436
file_id = entry.file_id
437
mutter('commit prep file %s, id %r ' % (p, file_id))
438
439
if not os.path.exists(p):
440
mutter(" file is missing, removing from inventory")
441
if verbose:
442
show_status('D', entry.kind, quotefn(path))
443
missing_ids.append(file_id)
444
continue
445
446
# TODO: Handle files that have been deleted
447
448
# TODO: Maybe a special case for empty files? Seems a
449
# waste to store them many times.
450
451
inv.add(entry)
452
453
if basis_inv.has_id(file_id):
454
old_kind = basis_inv[file_id].kind
455
if old_kind != entry.kind:
456
bailout("entry %r changed kind from %r to %r"
457
% (file_id, old_kind, entry.kind))
458
459
if entry.kind == 'directory':
460
if not isdir(p):
461
bailout("%s is entered as directory but not a directory" % quotefn(p))
462
elif entry.kind == 'file':
463
if not isfile(p):
464
bailout("%s is entered as file but is not a file" % quotefn(p))
465
466
content = file(p, 'rb').read()
467
468
entry.text_sha1 = sha_string(content)
469
entry.text_size = len(content)
470
471
old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
472
if (old_ie
473
and (old_ie.text_size == entry.text_size)
474
and (old_ie.text_sha1 == entry.text_sha1)):
475
## assert content == basis.get_file(file_id).read()
476
entry.text_id = basis_inv[file_id].text_id
477
mutter(' unchanged from previous text_id {%s}' %
478
entry.text_id)
479
480
else:
481
entry.text_id = gen_file_id(entry.name)
482
self.text_store.add(content, entry.text_id)
483
mutter(' stored with text_id {%s}' % entry.text_id)
484
if verbose:
485
if not old_ie:
486
state = 'A'
487
elif (old_ie.name == entry.name
488
and old_ie.parent_id == entry.parent_id):
489
state = 'M'
490
else:
491
state = 'R'
492
493
show_status(state, entry.kind, quotefn(path))
494
495
for file_id in missing_ids:
496
# have to do this later so we don't mess up the iterator.
497
# since parents may be removed before their children we
498
# have to test.
499
500
# FIXME: There's probably a better way to do this; perhaps
501
# the workingtree should know how to filter itself.
502
if work_inv.has_id(file_id):
503
del work_inv[file_id]
504
505
506
inv_id = rev_id = _gen_revision_id(time.time())
507
508
inv_tmp = tempfile.TemporaryFile()
509
inv.write_xml(inv_tmp)
510
inv_tmp.seek(0)
511
self.inventory_store.add(inv_tmp, inv_id)
512
mutter('new inventory_id is {%s}' % inv_id)
513
514
self._write_inventory(work_inv)
515
516
if timestamp == None:
517
timestamp = time.time()
518
519
if committer == None:
520
committer = username()
521
522
if timezone == None:
523
timezone = local_time_offset()
524
525
mutter("building commit log message")
526
rev = Revision(timestamp=timestamp,
527
timezone=timezone,
528
committer=committer,
529
precursor = self.last_patch(),
530
message = message,
531
inventory_id=inv_id,
532
revision_id=rev_id)
533
534
rev_tmp = tempfile.TemporaryFile()
535
rev.write_xml(rev_tmp)
536
rev_tmp.seek(0)
537
self.revision_store.add(rev_tmp, rev_id)
538
mutter("new revision_id is {%s}" % rev_id)
539
540
## XXX: Everything up to here can simply be orphaned if we abort
541
## the commit; it will leave junk files behind but that doesn't
542
## matter.
543
544
## TODO: Read back the just-generated changeset, and make sure it
545
## applies and recreates the right state.
546
547
## TODO: Also calculate and store the inventory SHA1
548
mutter("committing patch r%d" % (self.revno() + 1))
549
550
mutter("append to revision-history")
551
f = self.controlfile('revision-history', 'at')
552
f.write(rev_id + '\n')
553
f.close()
554
555
if verbose:
556
note("commited r%d" % self.revno())
686
def append_revision(self, *revision_ids):
687
for revision_id in revision_ids:
688
mutter("add {%s} to revision-history" % revision_id)
689
690
rev_history = self.revision_history()
691
rev_history.extend(revision_ids)
692
693
self.lock_write()
694
try:
695
self.put_controlfile('revision-history', '\n'.join(rev_history))
696
finally:
697
self.unlock()
698
699
700
def has_revision(self, revision_id):
701
"""True if this branch has a copy of the revision.
702
703
This does not necessarily imply the revision is merge
704
or on the mainline."""
705
return (revision_id is None
706
or revision_id in self.revision_store)
707
708
709
def get_revision_xml_file(self, revision_id):
710
"""Return XML file object for revision object."""
711
if not revision_id or not isinstance(revision_id, basestring):
712
raise InvalidRevisionId(revision_id)
713
714
self.lock_read()
715
try:
716
try:
717
return self.revision_store[revision_id]
718
except (IndexError, KeyError):
719
raise bzrlib.errors.NoSuchRevision(self, revision_id)
720
finally:
721
self.unlock()
722
723
724
def get_revision_xml(self, revision_id):
725
return self.get_revision_xml_file(revision_id).read()
557
726
558
727
559
728
def get_revision(self, revision_id):
560
729
"""Return the Revision object for a named revision"""
561
r = Revision.read_xml(self.revision_store[revision_id])
730
xml_file = self.get_revision_xml_file(revision_id)
731
732
try:
733
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
734
except SyntaxError, e:
735
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
736
[revision_id,
737
str(e)])
738
562
739
assert r.revision_id == revision_id
563
740
return r
564
741
565
742
566
def get_inventory(self, inventory_id):
567
"""Get Inventory object by hash.
568
569
:todo: Perhaps for this and similar methods, take a revision
570
parameter which can be either an integer revno or a
571
string hash."""
572
i = Inventory.read_xml(self.inventory_store[inventory_id])
573
return i
743
def get_revision_delta(self, revno):
744
"""Return the delta for one revision.
745
746
The delta is relative to its mainline predecessor, or the
747
empty tree for revision 1.
748
"""
749
assert isinstance(revno, int)
750
rh = self.revision_history()
751
if not (1 <= revno <= len(rh)):
752
raise InvalidRevisionNumber(revno)
753
754
# revno is 1-based; list is 0-based
755
756
new_tree = self.revision_tree(rh[revno-1])
757
if revno == 1:
758
old_tree = EmptyTree()
759
else:
760
old_tree = self.revision_tree(rh[revno-2])
761
762
return compare_trees(old_tree, new_tree)
763
764
def get_revision_sha1(self, revision_id):
765
"""Hash the stored value of a revision, and return it."""
766
return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
767
768
769
def _get_ancestry_weave(self):
770
return self.control_weaves.get_weave('ancestry')
771
772
773
def get_ancestry(self, revision_id):
774
"""Return a list of revision-ids integrated by a revision.
775
"""
776
# strip newlines
777
if revision_id is None:
778
return [None]
779
w = self._get_ancestry_weave()
780
return [None] + [l[:-1] for l in w.get_iter(w.lookup(revision_id))]
781
782
783
def get_inventory_weave(self):
784
return self.control_weaves.get_weave('inventory')
785
786
787
def get_inventory(self, revision_id):
788
"""Get Inventory object by hash."""
789
xml = self.get_inventory_xml(revision_id)
790
return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
791
792
793
def get_inventory_xml(self, revision_id):
794
"""Get inventory XML as a file object."""
795
try:
796
assert isinstance(revision_id, basestring), type(revision_id)
797
iw = self.get_inventory_weave()
798
return iw.get_text(iw.lookup(revision_id))
799
except IndexError:
800
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
801
802
803
def get_inventory_sha1(self, revision_id):
804
"""Return the sha1 hash of the inventory entry
805
"""
806
return self.get_revision(revision_id).inventory_sha1
574
807
575
808
576
809
def get_revision_inventory(self, revision_id):
577
810
"""Return inventory of a past revision."""
811
# TODO: Unify this with get_inventory()
812
# bzr 0.0.6 and later imposes the constraint that the inventory_id
813
# must be the same as its revision, so this is trivial.
578
814
if revision_id == None:
579
return Inventory()
815
return Inventory(self.get_root_id())
580
816
else:
581
return self.get_inventory(self.get_revision(revision_id).inventory_id)
817
return self.get_inventory(revision_id)
582
818
583
819
584
820
def revision_history(self):
585
"""Return sequence of revision hashes on to this branch.
586
587
>>> ScratchBranch().revision_history()
588
[]
589
"""
590
return [chomp(l) for l in self.controlfile('revision-history').readlines()]
821
"""Return sequence of revision hashes on to this branch."""
822
self.lock_read()
823
try:
824
return [l.rstrip('\r\n') for l in
825
self.controlfile('revision-history', 'r').readlines()]
826
finally:
827
self.unlock()
828
829
830
def common_ancestor(self, other, self_revno=None, other_revno=None):
831
"""
832
>>> from bzrlib.commit import commit
833
>>> sb = ScratchBranch(files=['foo', 'foo~'])
834
>>> sb.common_ancestor(sb) == (None, None)
835
True
836
>>> commit(sb, "Committing first revision", verbose=False)
837
>>> sb.common_ancestor(sb)[0]
838
1
839
>>> clone = sb.clone()
840
>>> commit(sb, "Committing second revision", verbose=False)
841
>>> sb.common_ancestor(sb)[0]
842
2
843
>>> sb.common_ancestor(clone)[0]
844
1
845
>>> commit(clone, "Committing divergent second revision",
846
... verbose=False)
847
>>> sb.common_ancestor(clone)[0]
848
1
849
>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
850
True
851
>>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
852
True
853
>>> clone2 = sb.clone()
854
>>> sb.common_ancestor(clone2)[0]
855
2
856
>>> sb.common_ancestor(clone2, self_revno=1)[0]
857
1
858
>>> sb.common_ancestor(clone2, other_revno=1)[0]
859
1
860
"""
861
my_history = self.revision_history()
862
other_history = other.revision_history()
863
if self_revno is None:
864
self_revno = len(my_history)
865
if other_revno is None:
866
other_revno = len(other_history)
867
indices = range(min((self_revno, other_revno)))
868
indices.reverse()
869
for r in indices:
870
if my_history[r] == other_history[r]:
871
return r+1, my_history[r]
872
return None, None
591
873
592
874
593
875
def revno(self):
595
877
596
878
That is equivalent to the number of revisions committed to
597
879
this branch.
598
599
>>> b = ScratchBranch()
600
>>> b.revno()
601
0
602
>>> b.commit('no foo')
603
>>> b.revno()
604
1
605
880
"""
606
881
return len(self.revision_history())
607
882
608
883
609
def last_patch(self):
884
def last_revision(self):
610
885
"""Return last patch hash, or None if no history.
611
612
>>> ScratchBranch().last_patch() == None
613
True
614
886
"""
615
887
ph = self.revision_history()
616
888
if ph:
617
889
return ph[-1]
618
619
620
def lookup_revision(self, revno):
621
"""Return revision hash for revision number."""
890
else:
891
return None
892
893
894
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
895
"""Return a list of new revisions that would perfectly fit.
896
897
If self and other have not diverged, return a list of the revisions
898
present in other, but missing from self.
899
900
>>> from bzrlib.commit import commit
901
>>> bzrlib.trace.silent = True
902
>>> br1 = ScratchBranch()
903
>>> br2 = ScratchBranch()
904
>>> br1.missing_revisions(br2)
905
[]
906
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
907
>>> br1.missing_revisions(br2)
908
[u'REVISION-ID-1']
909
>>> br2.missing_revisions(br1)
910
[]
911
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
912
>>> br1.missing_revisions(br2)
913
[]
914
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
915
>>> br1.missing_revisions(br2)
916
[u'REVISION-ID-2A']
917
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
918
>>> br1.missing_revisions(br2)
919
Traceback (most recent call last):
920
DivergedBranches: These branches have diverged.
921
"""
922
# FIXME: If the branches have diverged, but the latest
923
# revision in this branch is completely merged into the other,
924
# then we should still be able to pull.
925
self_history = self.revision_history()
926
self_len = len(self_history)
927
other_history = other.revision_history()
928
other_len = len(other_history)
929
common_index = min(self_len, other_len) -1
930
if common_index >= 0 and \
931
self_history[common_index] != other_history[common_index]:
932
raise DivergedBranches(self, other)
933
934
if stop_revision is None:
935
stop_revision = other_len
936
else:
937
assert isinstance(stop_revision, int)
938
if stop_revision > other_len:
939
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
940
return other_history[self_len:stop_revision]
941
942
def update_revisions(self, other, stop_revision=None):
943
"""Pull in new perfect-fit revisions."""
944
from bzrlib.fetch import greedy_fetch
945
from bzrlib.revision import get_intervening_revisions
946
if stop_revision is None:
947
stop_revision = other.last_revision()
948
greedy_fetch(to_branch=self, from_branch=other,
949
revision=stop_revision)
950
pullable_revs = self.missing_revisions(
951
other, other.revision_id_to_revno(stop_revision))
952
if pullable_revs:
953
greedy_fetch(to_branch=self,
954
from_branch=other,
955
revision=pullable_revs[-1])
956
self.append_revision(*pullable_revs)
957
958
959
def commit(self, *args, **kw):
960
from bzrlib.commit import Commit
961
Commit().commit(self, *args, **kw)
962
963
def revision_id_to_revno(self, revision_id):
964
"""Given a revision id, return its revno"""
965
if revision_id is None:
966
return 0
967
history = self.revision_history()
968
try:
969
return history.index(revision_id) + 1
970
except ValueError:
971
raise bzrlib.errors.NoSuchRevision(self, revision_id)
972
973
def get_rev_id(self, revno, history=None):
974
"""Find the revision id of the specified revno."""
622
975
if revno == 0:
623
976
return None
624
625
try:
626
# list is 0-based; revisions are 1-based
627
return self.revision_history()[revno-1]
628
except IndexError:
629
bailout("no such revision %s" % revno)
630
977
if history is None:
978
history = self.revision_history()
979
elif revno <= 0 or revno > len(history):
980
raise bzrlib.errors.NoSuchRevision(self, revno)
981
return history[revno - 1]
631
982
632
983
def revision_tree(self, revision_id):
633
984
"""Return Tree for a revision on this branch.
634
985
635
986
`revision_id` may be None for the null revision, in which case
636
987
an `EmptyTree` is returned."""
637
988
# TODO: refactor this to use an existing revision object
989
# so we don't need to read it in twice.
638
990
if revision_id == None:
639
991
return EmptyTree()
640
992
else:
641
993
inv = self.get_revision_inventory(revision_id)
642
return RevisionTree(self.text_store, inv)
994
return RevisionTree(self.weave_store, inv, revision_id)
643
995
644
996
645
997
def working_tree(self):
646
998
"""Return a `Tree` for the working copy."""
647
return WorkingTree(self.base, self.read_working_inventory())
999
from bzrlib.workingtree import WorkingTree
1000
# TODO: In the future, WorkingTree should utilize Transport
1001
return WorkingTree(self._transport.base, self.read_working_inventory())
648
1002
649
1003
650
1004
def basis_tree(self):
651
1005
"""Return `Tree` object for last revision.
652
1006
653
1007
If there are no revisions yet, return an `EmptyTree`.
654
655
>>> b = ScratchBranch(files=['foo'])
656
>>> b.basis_tree().has_filename('foo')
657
False
658
>>> b.working_tree().has_filename('foo')
659
True
660
>>> b.add('foo')
661
>>> b.commit('add foo')
662
>>> b.basis_tree().has_filename('foo')
663
True
664
1008
"""
665
r = self.last_patch()
666
if r == None:
667
return EmptyTree()
668
else:
669
return RevisionTree(self.text_store, self.get_revision_inventory(r))
670
671
672
673
def write_log(self, show_timezone='original'):
674
"""Write out human-readable log of commits to this branch
675
676
:param utc: If true, show dates in universal time, not local time."""
677
## TODO: Option to choose either original, utc or local timezone
678
revno = 1
679
precursor = None
680
for p in self.revision_history():
681
print '-' * 40
682
print 'revno:', revno
683
## TODO: Show hash if --id is given.
684
##print 'revision-hash:', p
685
rev = self.get_revision(p)
686
print 'committer:', rev.committer
687
print 'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
688
show_timezone))
689
690
## opportunistic consistency check, same as check_patch_chaining
691
if rev.precursor != precursor:
692
bailout("mismatched precursor!")
693
694
print 'message:'
695
if not rev.message:
696
print ' (no message)'
697
else:
698
for l in rev.message.split('\n'):
699
print ' ' + l
700
701
revno += 1
702
precursor = p
1009
return self.revision_tree(self.last_revision())
703
1010
704
1011
705
1012
def rename_one(self, from_rel, to_rel):
706
tree = self.working_tree()
707
inv = tree.inventory
708
if not tree.has_filename(from_rel):
709
bailout("can't rename: old working file %r does not exist" % from_rel)
710
if tree.has_filename(to_rel):
711
bailout("can't rename: new working file %r already exists" % to_rel)
712
713
file_id = inv.path2id(from_rel)
714
if file_id == None:
715
bailout("can't rename: old name %r is not versioned" % from_rel)
716
717
if inv.path2id(to_rel):
718
bailout("can't rename: new name %r is already versioned" % to_rel)
719
720
to_dir, to_tail = os.path.split(to_rel)
721
to_dir_id = inv.path2id(to_dir)
722
if to_dir_id == None and to_dir != '':
723
bailout("can't determine destination directory id for %r" % to_dir)
724
725
mutter("rename_one:")
726
mutter(" file_id {%s}" % file_id)
727
mutter(" from_rel %r" % from_rel)
728
mutter(" to_rel %r" % to_rel)
729
mutter(" to_dir %r" % to_dir)
730
mutter(" to_dir_id {%s}" % to_dir_id)
731
732
inv.rename(file_id, to_dir_id, to_tail)
733
os.rename(self.abspath(from_rel), self.abspath(to_rel))
734
735
self._write_inventory(inv)
736
737
738
739
def rename(self, from_paths, to_name):
1013
"""Rename one file.
1014
1015
This can change the directory or the filename or both.
1016
"""
1017
self.lock_write()
1018
try:
1019
tree = self.working_tree()
1020
inv = tree.inventory
1021
if not tree.has_filename(from_rel):
1022
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
1023
if tree.has_filename(to_rel):
1024
raise BzrError("can't rename: new working file %r already exists" % to_rel)
1025
1026
file_id = inv.path2id(from_rel)
1027
if file_id == None:
1028
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
1029
1030
if inv.path2id(to_rel):
1031
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
1032
1033
to_dir, to_tail = os.path.split(to_rel)
1034
to_dir_id = inv.path2id(to_dir)
1035
if to_dir_id == None and to_dir != '':
1036
raise BzrError("can't determine destination directory id for %r" % to_dir)
1037
1038
mutter("rename_one:")
1039
mutter(" file_id {%s}" % file_id)
1040
mutter(" from_rel %r" % from_rel)
1041
mutter(" to_rel %r" % to_rel)
1042
mutter(" to_dir %r" % to_dir)
1043
mutter(" to_dir_id {%s}" % to_dir_id)
1044
1045
inv.rename(file_id, to_dir_id, to_tail)
1046
1047
from_abs = self.abspath(from_rel)
1048
to_abs = self.abspath(to_rel)
1049
try:
1050
rename(from_abs, to_abs)
1051
except OSError, e:
1052
raise BzrError("failed to rename %r to %r: %s"
1053
% (from_abs, to_abs, e[1]),
1054
["rename rolled back"])
1055
1056
self._write_inventory(inv)
1057
finally:
1058
self.unlock()
1059
1060
1061
def move(self, from_paths, to_name):
740
1062
"""Rename files.
741
1063
1064
to_name must exist as a versioned directory.
1065
742
1066
If to_name exists and is a directory, the files are moved into
743
1067
it, keeping their old names. If it is a directory,
744
1068
745
1069
Note that to_name is only the last component of the new name;
746
1070
this doesn't change the directory.
1071
1072
This returns a list of (from_path, to_path) pairs for each
1073
entry that is moved.
747
1074
"""
748
## TODO: Option to move IDs only
749
assert not isinstance(from_paths, basestring)
750
tree = self.working_tree()
751
inv = tree.inventory
752
dest_dir = isdir(self.abspath(to_name))
753
if dest_dir:
754
# TODO: Wind back properly if some can't be moved?
755
dest_dir_id = inv.path2id(to_name)
756
if not dest_dir_id and to_name != '':
757
bailout("destination %r is not a versioned directory" % to_name)
758
for f in from_paths:
759
name_tail = splitpath(f)[-1]
760
dest_path = appendpath(to_name, name_tail)
761
print "%s => %s" % (f, dest_path)
762
inv.rename(inv.path2id(f), dest_dir_id, name_tail)
763
os.rename(self.abspath(f), self.abspath(dest_path))
1075
result = []
1076
self.lock_write()
1077
try:
1078
## TODO: Option to move IDs only
1079
assert not isinstance(from_paths, basestring)
1080
tree = self.working_tree()
1081
inv = tree.inventory
1082
to_abs = self.abspath(to_name)
1083
if not isdir(to_abs):
1084
raise BzrError("destination %r is not a directory" % to_abs)
1085
if not tree.has_filename(to_name):
1086
raise BzrError("destination %r not in working directory" % to_abs)
1087
to_dir_id = inv.path2id(to_name)
1088
if to_dir_id == None and to_name != '':
1089
raise BzrError("destination %r is not a versioned directory" % to_name)
1090
to_dir_ie = inv[to_dir_id]
1091
if to_dir_ie.kind not in ('directory', 'root_directory'):
1092
raise BzrError("destination %r is not a directory" % to_abs)
1093
1094
to_idpath = inv.get_idpath(to_dir_id)
1095
1096
for f in from_paths:
1097
if not tree.has_filename(f):
1098
raise BzrError("%r does not exist in working tree" % f)
1099
f_id = inv.path2id(f)
1100
if f_id == None:
1101
raise BzrError("%r is not versioned" % f)
1102
name_tail = splitpath(f)[-1]
1103
dest_path = appendpath(to_name, name_tail)
1104
if tree.has_filename(dest_path):
1105
raise BzrError("destination %r already exists" % dest_path)
1106
if f_id in to_idpath:
1107
raise BzrError("can't move %r to a subdirectory of itself" % f)
1108
1109
# OK, so there's a race here, it's possible that someone will
1110
# create a file in this interval and then the rename might be
1111
# left half-done. But we should have caught most problems.
1112
1113
for f in from_paths:
1114
name_tail = splitpath(f)[-1]
1115
dest_path = appendpath(to_name, name_tail)
1116
result.append((f, dest_path))
1117
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1118
try:
1119
rename(self.abspath(f), self.abspath(dest_path))
1120
except OSError, e:
1121
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1122
["rename rolled back"])
1123
764
1124
self._write_inventory(inv)
765
else:
766
if len(from_paths) != 1:
767
bailout("when moving multiple files, destination must be a directory")
768
bailout("rename to non-directory %r not implemented sorry" % to_name)
769
770
771
772
def show_status(branch, show_all=False):
773
"""Display single-line status for non-ignored working files.
774
775
The list is show sorted in order by file name.
776
777
>>> b = ScratchBranch(files=['foo', 'foo~'])
778
>>> b.show_status()
779
? foo
780
>>> b.add('foo')
781
>>> b.show_status()
782
A foo
783
>>> b.commit("add foo")
784
>>> b.show_status()
785
>>> os.unlink(b.abspath('foo'))
786
>>> b.show_status()
787
D foo
788
789
790
:todo: Get state for single files.
791
792
:todo: Perhaps show a slash at the end of directory names.
793
794
"""
795
796
# We have to build everything into a list first so that it can
797
# sorted by name, incorporating all the different sources.
798
799
# FIXME: Rather than getting things in random order and then sorting,
800
# just step through in order.
801
802
# Interesting case: the old ID for a file has been removed,
803
# but a new file has been created under that name.
804
805
old = branch.basis_tree()
806
old_inv = old.inventory
807
new = branch.working_tree()
808
new_inv = new.inventory
809
810
for fs, fid, oldname, newname, kind in diff_trees(old, new):
811
if fs == 'R':
812
show_status(fs, kind,
813
oldname + ' => ' + newname)
814
elif fs == 'A' or fs == 'M':
815
show_status(fs, kind, newname)
816
elif fs == 'D':
817
show_status(fs, kind, oldname)
818
elif fs == '.':
819
if show_all:
820
show_status(fs, kind, newname)
821
elif fs == 'I':
822
if show_all:
823
show_status(fs, kind, newname)
824
elif fs == '?':
825
show_status(fs, kind, newname)
826
else:
827
bailout("wierd file state %r" % ((fs, fid),))
828
829
830
831
class ScratchBranch(Branch):
1125
finally:
1126
self.unlock()
1127
1128
return result
1129
1130
1131
def revert(self, filenames, old_tree=None, backups=True):
1132
"""Restore selected files to the versions from a previous tree.
1133
1134
backups
1135
If true (default) backups are made of files before
1136
they're renamed.
1137
"""
1138
from bzrlib.errors import NotVersionedError, BzrError
1139
from bzrlib.atomicfile import AtomicFile
1140
from bzrlib.osutils import backup_file
1141
1142
inv = self.read_working_inventory()
1143
if old_tree is None:
1144
old_tree = self.basis_tree()
1145
old_inv = old_tree.inventory
1146
1147
nids = []
1148
for fn in filenames:
1149
file_id = inv.path2id(fn)
1150
if not file_id:
1151
raise NotVersionedError("not a versioned file", fn)
1152
if not old_inv.has_id(file_id):
1153
raise BzrError("file not present in old tree", fn, file_id)
1154
nids.append((fn, file_id))
1155
1156
# TODO: Rename back if it was previously at a different location
1157
1158
# TODO: If given a directory, restore the entire contents from
1159
# the previous version.
1160
1161
# TODO: Make a backup to a temporary file.
1162
1163
# TODO: If the file previously didn't exist, delete it?
1164
for fn, file_id in nids:
1165
backup_file(fn)
1166
1167
f = AtomicFile(fn, 'wb')
1168
try:
1169
f.write(old_tree.get_file(file_id).read())
1170
f.commit()
1171
finally:
1172
f.close()
1173
1174
1175
def pending_merges(self):
1176
"""Return a list of pending merges.
1177
1178
These are revisions that have been merged into the working
1179
directory but not yet committed.
1180
"""
1181
cfn = self._rel_controlfilename('pending-merges')
1182
if not self._transport.has(cfn):
1183
return []
1184
p = []
1185
for l in self.controlfile('pending-merges', 'r').readlines():
1186
p.append(l.rstrip('\n'))
1187
return p
1188
1189
1190
def add_pending_merge(self, *revision_ids):
1191
# TODO: Perhaps should check at this point that the
1192
# history of the revision is actually present?
1193
for rev_id in revision_ids:
1194
validate_revision_id(rev_id)
1195
1196
p = self.pending_merges()
1197
updated = False
1198
for rev_id in revision_ids:
1199
if rev_id in p:
1200
continue
1201
p.append(rev_id)
1202
updated = True
1203
if updated:
1204
self.set_pending_merges(p)
1205
1206
def set_pending_merges(self, rev_list):
1207
self.lock_write()
1208
try:
1209
self.put_controlfile('pending-merges', '\n'.join(rev_list))
1210
finally:
1211
self.unlock()
1212
1213
1214
def get_parent(self):
1215
"""Return the parent location of the branch.
1216
1217
This is the default location for push/pull/missing. The usual
1218
pattern is that the user can override it by specifying a
1219
location.
1220
"""
1221
import errno
1222
_locs = ['parent', 'pull', 'x-pull']
1223
for l in _locs:
1224
try:
1225
return self.controlfile(l, 'r').read().strip('\n')
1226
except IOError, e:
1227
if e.errno != errno.ENOENT:
1228
raise
1229
return None
1230
1231
1232
def set_parent(self, url):
1233
# TODO: Maybe delete old location files?
1234
from bzrlib.atomicfile import AtomicFile
1235
self.lock_write()
1236
try:
1237
f = AtomicFile(self.controlfilename('parent'))
1238
try:
1239
f.write(url + '\n')
1240
f.commit()
1241
finally:
1242
f.close()
1243
finally:
1244
self.unlock()
1245
1246
def check_revno(self, revno):
1247
"""\
1248
Check whether a revno corresponds to any revision.
1249
Zero (the NULL revision) is considered valid.
1250
"""
1251
if revno != 0:
1252
self.check_real_revno(revno)
1253
1254
def check_real_revno(self, revno):
1255
"""\
1256
Check whether a revno corresponds to a real revision.
1257
Zero (the NULL revision) is considered invalid
1258
"""
1259
if revno < 1 or revno > self.revno():
1260
raise InvalidRevisionNumber(revno)
1261
1262
1263
1264
1265
1266
class ScratchBranch(_Branch):
832
1267
"""Special test class: a branch that cleans up after itself.
833
1268
834
1269
>>> b = ScratchBranch()
835
1270
>>> isdir(b.base)
836
1271
True
837
1272
>>> bd = b.base
838
>>> del b
1273
>>> b.destroy()
839
1274
>>> isdir(bd)
840
1275
False
841
1276
"""
842
def __init__(self, files=[], dirs=[]):
1277
def __init__(self, files=[], dirs=[], base=None):
843
1278
"""Make a test branch.
844
1279
845
1280
This creates a temporary directory and runs init-tree in it.
846
1281
847
1282
If any files are listed, they are created in the working copy.
848
1283
"""
849
Branch.__init__(self, tempfile.mkdtemp(), init=True)
1284
from tempfile import mkdtemp
1285
init = False
1286
if base is None:
1287
base = mkdtemp()
1288
init = True
1289
if isinstance(base, basestring):
1290
base = get_transport(base)
1291
_Branch.__init__(self, base, init=init)
850
1292
for d in dirs:
851
os.mkdir(self.abspath(d))
1293
self._transport.mkdir(d)
852
1294
853
1295
for f in files:
854
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
855
856
1296
self._transport.put(f, 'content of %s' % f)
1297
1298
1299
def clone(self):
1300
"""
1301
>>> orig = ScratchBranch(files=["file1", "file2"])
1302
>>> clone = orig.clone()
1303
>>> if os.name != 'nt':
1304
... os.path.samefile(orig.base, clone.base)
1305
... else:
1306
... orig.base == clone.base
1307
...
1308
False
1309
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1310
True
1311
"""
1312
from shutil import copytree
1313
from tempfile import mkdtemp
1314
base = mkdtemp()
1315
os.rmdir(base)
1316
copytree(self.base, base, symlinks=True)
1317
return ScratchBranch(base=base)
1318
1319
1320
857
1321
def __del__(self):
1322
self.destroy()
1323
1324
def destroy(self):
858
1325
"""Destroy the test branch, removing the scratch directory."""
1326
from shutil import rmtree
859
1327
try:
860
shutil.rmtree(self.base)
861
except OSError:
1328
if self.base:
1329
mutter("delete ScratchBranch %s" % self.base)
1330
rmtree(self.base)
1331
except OSError, e:
862
1332
# Work around for shutil.rmtree failing on Windows when
863
1333
# readonly files are encountered
1334
mutter("hit exception in destroying ScratchBranch: %s" % e)
864
1335
for root, dirs, files in os.walk(self.base, topdown=False):
865
1336
for name in files:
866
1337
os.chmod(os.path.join(root, name), 0700)
867
shutil.rmtree(self.base)
1338
rmtree(self.base)
1339
self._transport = None
868
1340
869
1341
870
1342
887
1359
888
1360
889
1361
890
def _gen_revision_id(when):
891
"""Return new revision-id."""
892
s = '%s-%s-' % (user_email(), compact_date(when))
893
s += hexlify(rand_bytes(8))
894
return s
895
896
897
1362
def gen_file_id(name):
898
1363
"""Return new file id.
899
1364
900
1365
This should probably generate proper UUIDs, but for the moment we
901
1366
cope with just randomness because running uuidgen every time is
902
1367
slow."""
1368
import re
1369
from binascii import hexlify
1370
from time import time
1371
1372
# get last component
903
1373
idx = name.rfind('/')
904
1374
if idx != -1:
905
1375
name = name[idx+1 : ]
1376
idx = name.rfind('\\')
1377
if idx != -1:
1378
name = name[idx+1 : ]
906
1379
1380
# make it not a hidden file
907
1381
name = name.lstrip('.')
908
1382
1383
# remove any wierd characters; we don't escape them but rather
1384
# just pull them out
1385
name = re.sub(r'[^\w.]', '', name)
1386
909
1387
s = hexlify(rand_bytes(8))
910
return '-'.join((name, compact_date(time.time()), s))
1388
return '-'.join((name, compact_date(time()), s))
1389
1390
1391
def gen_root_id():
1392
"""Return a new tree-root file id."""
1393
return gen_file_id('TREE_ROOT')
911
1394
912
1395
Loggerhead is a web-based interface for Breezy
Version: 2.0.1