« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 132
- compare with another revision
- download diff
- download tarball
- view history from revision 132
- Committer: mbp at sourcefrog
- Date: 2005-03-29 02:41:07 UTC
- Revision ID: mbp@sourcefrog.net-20050329024107-7fd789f7ca7d64ab
Tree.is_ignored returns the pattern that matched, if any
- files added:
- bzrlib/tests.py
- files removed:
- .rsyncexclude
- contrib
- contrib/bash
- contrib/zsh
- patches
- urlgrabber
- files modified:
- .bzrignore
added
removed
bzrlib/branch.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
18
from sets import Set
19
18
20
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
19
21
import traceback, socket, fnmatch, difflib, time
20
22
from binascii import hexlify
22
24
import bzrlib
23
25
from inventory import Inventory
24
26
from trace import mutter, note
25
from tree import Tree, EmptyTree, RevisionTree
27
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
26
28
from inventory import InventoryEntry, Inventory
27
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
29
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, chomp, \
28
30
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
29
joinpath, sha_string, file_kind, local_time_offset, appendpath
31
joinpath, sha_string, file_kind, local_time_offset
30
32
from store import ImmutableStore
31
33
from revision import Revision
32
from errors import BzrError
34
from errors import bailout
33
35
from textui import show_status
36
from diff import diff_trees
34
37
35
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
36
39
## TODO: Maybe include checks for common corruption of newlines, etc?
37
40
38
41
39
42
40
def find_branch(f, **args):
41
if f and (f.startswith('http://') or f.startswith('https://')):
42
import remotebranch
43
return remotebranch.RemoteBranch(f, **args)
44
else:
45
return Branch(f, **args)
46
47
48
49
def _relpath(base, path):
50
"""Return path relative to base, or raise exception.
51
52
The path may be either an absolute path or a path relative to the
53
current working directory.
54
55
Lifted out of Branch.relpath for ease of testing.
56
57
os.path.commonprefix (python2.4) has a bad bug that it works just
58
on string prefixes, assuming that '/u' is a prefix of '/u2'. This
59
avoids that problem."""
60
rp = os.path.abspath(path)
61
62
s = []
63
head = rp
64
while len(head) >= len(base):
65
if head == base:
66
break
67
head, tail = os.path.split(head)
68
if tail:
69
s.insert(0, tail)
70
else:
71
from errors import NotBranchError
72
raise NotBranchError("path %r is not within branch %r" % (rp, base))
73
74
return os.sep.join(s)
75
76
77
43
def find_branch_root(f=None):
78
44
"""Find the branch root enclosing f, or pwd.
79
45
80
f may be a filename or a URL.
81
82
46
It is not necessary that f exists.
83
47
84
48
Basically we keep looking up until we find the control directory or
85
49
run into the root."""
86
if f == None:
50
if f is None:
87
51
f = os.getcwd()
88
52
elif hasattr(os.path, 'realpath'):
89
53
f = os.path.realpath(f)
90
54
else:
91
55
f = os.path.abspath(f)
92
if not os.path.exists(f):
93
raise BzrError('%r does not exist' % f)
94
95
56
96
57
orig_f = f
97
58
59
last_f = f
98
60
while True:
99
61
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
100
62
return f
101
63
head, tail = os.path.split(f)
102
64
if head == f:
103
65
# reached the root, whatever that may be
104
raise BzrError('%r is not in a branch' % orig_f)
66
bailout('%r is not in a branch' % orig_f)
105
67
f = head
106
68
107
class DivergedBranches(Exception):
108
def __init__(self, branch1, branch2):
109
self.branch1 = branch1
110
self.branch2 = branch2
111
Exception.__init__(self, "These branches have diverged.")
69
112
70
113
71
######################################################################
114
72
# branch objects
115
73
116
class Branch(object):
74
class Branch:
117
75
"""Branch holding a history of revisions.
118
76
119
base
120
Base directory of the branch.
121
122
_lock_mode
123
None, or 'r' or 'w'
124
125
_lock_count
126
If _lock_mode is true, a positive count of the number of times the
127
lock has been taken.
128
129
_lock
130
Lock object from bzrlib.lock.
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.
131
89
"""
132
base = None
133
_lock_mode = None
134
_lock_count = None
135
_lock = None
136
137
90
def __init__(self, base, init=False, find_root=True):
138
91
"""Create new branch object at a particular location.
139
92
140
base -- Base directory for the branch.
93
:param base: Base directory for the branch.
141
94
142
init -- If True, create new control files in a previously
95
:param init: If True, create new control files in a previously
143
96
unversioned directory. If False, the branch must already
144
97
be versioned.
145
98
146
find_root -- If true and init is false, find the root of the
99
:param find_root: If true and init is false, find the root of the
147
100
existing branch containing base.
148
101
149
102
In the test suite, creation of new trees is tested using the
157
110
else:
158
111
self.base = os.path.realpath(base)
159
112
if not isdir(self.controlfilename('.')):
160
from errors import NotBranchError
161
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
162
['use "bzr init" to initialize a new working tree',
163
'current bzr can only operate from top-of-tree'])
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'])
164
116
self._check_format()
165
117
166
118
self.text_store = ImmutableStore(self.controlfilename('text-store'))
175
127
__repr__ = __str__
176
128
177
129
178
def __del__(self):
179
if self._lock_mode or self._lock:
180
from warnings import warn
181
warn("branch %r was not explicitly unlocked" % self)
182
self._lock.unlock()
183
184
185
186
def lock_write(self):
187
if self._lock_mode:
188
if self._lock_mode != 'w':
189
from errors import LockError
190
raise LockError("can't upgrade to a write lock from %r" %
191
self._lock_mode)
192
self._lock_count += 1
193
else:
194
from bzrlib.lock import WriteLock
195
196
self._lock = WriteLock(self.controlfilename('branch-lock'))
197
self._lock_mode = 'w'
198
self._lock_count = 1
199
200
201
202
def lock_read(self):
203
if self._lock_mode:
204
assert self._lock_mode in ('r', 'w'), \
205
"invalid lock mode %r" % self._lock_mode
206
self._lock_count += 1
207
else:
208
from bzrlib.lock import ReadLock
209
210
self._lock = ReadLock(self.controlfilename('branch-lock'))
211
self._lock_mode = 'r'
212
self._lock_count = 1
213
214
215
216
def unlock(self):
217
if not self._lock_mode:
218
from errors import LockError
219
raise LockError('branch %r is not locked' % (self))
220
221
if self._lock_count > 1:
222
self._lock_count -= 1
223
else:
224
self._lock.unlock()
225
self._lock = None
226
self._lock_mode = self._lock_count = None
227
228
229
130
def abspath(self, name):
230
131
"""Return absolute filename for something in the branch"""
231
132
return os.path.join(self.base, name)
235
136
"""Return path relative to this branch of something inside it.
236
137
237
138
Raises an error if path is not in this branch."""
238
return _relpath(self.base, path)
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
239
146
240
147
241
148
def controlfilename(self, file_or_path):
246
153
247
154
248
155
def controlfile(self, file_or_path, mode='r'):
249
"""Open a control file for this branch.
250
251
There are two classes of file in the control directory: text
252
and binary. binary files are untranslated byte streams. Text
253
control files are stored with Unix newlines and in UTF-8, even
254
if the platform or locale defaults are different.
255
256
Controlfiles should almost never be opened in write mode but
257
rather should be atomically copied and replaced using atomicfile.
258
"""
259
260
fn = self.controlfilename(file_or_path)
261
262
if mode == 'rb' or mode == 'wb':
263
return file(fn, mode)
264
elif mode == 'r' or mode == 'w':
265
# open in binary mode anyhow so there's no newline translation;
266
# codecs uses line buffering by default; don't want that.
267
import codecs
268
return codecs.open(fn, mode + 'b', 'utf-8',
269
buffering=60000)
270
else:
271
raise BzrError("invalid controlfile mode %r" % mode)
272
156
"""Open a control file for this branch"""
157
return file(self.controlfilename(file_or_path), mode)
273
158
274
159
275
160
def _make_control(self):
281
166
for d in ('text-store', 'inventory-store', 'revision-store'):
282
167
os.mkdir(self.controlfilename(d))
283
168
for f in ('revision-history', 'merged-patches',
284
'pending-merged-patches', 'branch-name',
285
'branch-lock'):
169
'pending-merged-patches', 'branch-name'):
286
170
self.controlfile(f, 'w').write('')
287
171
mutter('created control directory in ' + self.base)
288
172
Inventory().write_xml(self.controlfile('inventory','w'))
295
179
296
180
In the future, we might need different in-memory Branch
297
181
classes to support downlevel branches. But not yet.
298
"""
299
# This ignores newlines so that we can open branches created
300
# on Windows from Linux and so on. I think it might be better
301
# to always make all internal files in unix format.
302
fmt = self.controlfile('branch-format', 'r').read()
303
fmt.replace('\r\n', '')
182
"""
183
# read in binary mode to detect newline wierdness.
184
fmt = self.controlfile('branch-format', 'rb').read()
304
185
if fmt != BZR_BRANCH_FORMAT:
305
raise BzrError('sorry, branch format %r not supported' % fmt,
306
['use a different bzr version',
307
'or remove the .bzr directory and "bzr init" again'])
308
186
bailout('sorry, branch format %r not supported' % fmt,
187
['use a different bzr version',
188
'or remove the .bzr directory and "bzr init" again'])
309
189
310
190
311
191
def read_working_inventory(self):
312
192
"""Read the working inventory."""
313
193
before = time.time()
314
# ElementTree does its own conversion from UTF-8, so open in
315
# binary.
316
self.lock_read()
317
try:
318
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
319
mutter("loaded inventory of %d items in %f"
320
% (len(inv), time.time() - before))
321
return inv
322
finally:
323
self.unlock()
324
194
inv = Inventory.read_xml(self.controlfile('inventory', 'r'))
195
mutter("loaded inventory of %d items in %f"
196
% (len(inv), time.time() - before))
197
return inv
198
325
199
326
200
def _write_inventory(self, inv):
327
201
"""Update the working inventory.
332
206
## TODO: factor out to atomicfile? is rename safe on windows?
333
207
## TODO: Maybe some kind of clean/dirty marker on inventory?
334
208
tmpfname = self.controlfilename('inventory.tmp')
335
tmpf = file(tmpfname, 'wb')
209
tmpf = file(tmpfname, 'w')
336
210
inv.write_xml(tmpf)
337
211
tmpf.close()
338
inv_fname = self.controlfilename('inventory')
339
if sys.platform == 'win32':
340
os.remove(inv_fname)
341
os.rename(tmpfname, inv_fname)
212
os.rename(tmpfname, self.controlfilename('inventory'))
342
213
mutter('wrote working inventory')
343
214
344
215
345
216
inventory = property(read_working_inventory, _write_inventory, None,
346
217
"""Inventory for the working copy.""")
347
218
348
219
349
def add(self, files, verbose=False, ids=None):
220
def add(self, files, verbose=False):
350
221
"""Make files versioned.
351
222
352
Note that the command line normally calls smart_add instead.
353
354
223
This puts the files in the Added state, so that they will be
355
224
recorded by the next commit.
356
225
357
files
358
List of paths to add, relative to the base of the tree.
359
360
ids
361
If set, use these instead of automatically generated ids.
362
Must be the same length as the list of files, but may
363
contain None for ids that are to be autogenerated.
364
365
TODO: Perhaps have an option to add the ids even if the files do
366
not (yet) exist.
367
368
TODO: Perhaps return the ids of the files? But then again it
369
is easy to retrieve them if they're needed.
370
371
TODO: Adding a directory should optionally recurse down and
372
add all non-ignored children. Perhaps do that in a
373
higher-level method.
226
:todo: Perhaps have an option to add the ids even if the files do
227
not (yet) exist.
228
229
:todo: Perhaps return the ids of the files? But then again it
230
is easy to retrieve them if they're needed.
231
232
:todo: Option to specify file id.
233
234
:todo: Adding a directory should optionally recurse down and
235
add all non-ignored children. Perhaps do that in a
236
higher-level method.
237
238
>>> b = ScratchBranch(files=['foo'])
239
>>> 'foo' in b.unknowns()
240
True
241
>>> b.show_status()
242
? foo
243
>>> b.add('foo')
244
>>> 'foo' in b.unknowns()
245
False
246
>>> bool(b.inventory.path2id('foo'))
247
True
248
>>> b.show_status()
249
A foo
250
251
>>> b.add('foo')
252
Traceback (most recent call last):
253
...
254
BzrError: ('foo is already versioned', [])
255
256
>>> b.add(['nothere'])
257
Traceback (most recent call last):
258
BzrError: ('cannot add: not a regular file or directory: nothere', [])
374
259
"""
260
375
261
# TODO: Re-adding a file that is removed in the working copy
376
262
# should probably put it back with the previous ID.
377
263
if isinstance(files, types.StringTypes):
378
assert(ids is None or isinstance(ids, types.StringTypes))
379
264
files = [files]
380
if ids is not None:
381
ids = [ids]
382
383
if ids is None:
384
ids = [None] * len(files)
385
else:
386
assert(len(ids) == len(files))
387
388
self.lock_write()
389
try:
390
inv = self.read_working_inventory()
391
for f,file_id in zip(files, ids):
392
if is_control_file(f):
393
raise BzrError("cannot add control file %s" % quotefn(f))
394
395
fp = splitpath(f)
396
397
if len(fp) == 0:
398
raise BzrError("cannot add top-level %r" % f)
399
400
fullpath = os.path.normpath(self.abspath(f))
401
402
try:
403
kind = file_kind(fullpath)
404
except OSError:
405
# maybe something better?
406
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
407
408
if kind != 'file' and kind != 'directory':
409
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
410
411
if file_id is None:
412
file_id = gen_file_id(f)
413
inv.add_path(f, kind=kind, file_id=file_id)
414
415
if verbose:
416
show_status('A', kind, quotefn(f))
417
418
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
419
420
self._write_inventory(inv)
421
finally:
422
self.unlock()
423
424
425
def print_file(self, file, revno):
426
"""Print `file` to stdout."""
427
self.lock_read()
428
try:
429
tree = self.revision_tree(self.lookup_revision(revno))
430
# use inventory as it was in that revision
431
file_id = tree.inventory.path2id(file)
432
if not file_id:
433
raise BzrError("%r is not present in revision %d" % (file, revno))
434
tree.print_file(file_id)
435
finally:
436
self.unlock()
265
266
inv = self.read_working_inventory()
267
for f in files:
268
if is_control_file(f):
269
bailout("cannot add control file %s" % quotefn(f))
270
271
fp = splitpath(f)
272
273
if len(fp) == 0:
274
bailout("cannot add top-level %r" % f)
275
276
fullpath = os.path.normpath(self.abspath(f))
277
278
try:
279
kind = file_kind(fullpath)
280
except OSError:
281
# maybe something better?
282
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
283
284
if kind != 'file' and kind != 'directory':
285
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
286
287
file_id = gen_file_id(f)
288
inv.add_path(f, kind=kind, file_id=file_id)
289
290
if verbose:
291
show_status('A', kind, quotefn(f))
292
293
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
294
295
self._write_inventory(inv)
296
437
297
438
298
439
299
def remove(self, files, verbose=False):
441
301
442
302
This does not remove their text. This does not run on
443
303
444
TODO: Refuse to remove modified files unless --force is given?
445
446
TODO: Do something useful with directories.
447
448
TODO: Should this remove the text or not? Tough call; not
304
:todo: Refuse to remove modified files unless --force is given?
305
306
>>> b = ScratchBranch(files=['foo'])
307
>>> b.add('foo')
308
>>> b.inventory.has_filename('foo')
309
True
310
>>> b.remove('foo')
311
>>> b.working_tree().has_filename('foo')
312
True
313
>>> b.inventory.has_filename('foo')
314
False
315
316
>>> b = ScratchBranch(files=['foo'])
317
>>> b.add('foo')
318
>>> b.commit('one')
319
>>> b.remove('foo')
320
>>> b.commit('two')
321
>>> b.inventory.has_filename('foo')
322
False
323
>>> b.basis_tree().has_filename('foo')
324
False
325
>>> b.working_tree().has_filename('foo')
326
True
327
328
:todo: Do something useful with directories.
329
330
:todo: Should this remove the text or not? Tough call; not
449
331
removing may be useful and the user can just use use rm, and
450
332
is the opposite of add. Removing it is consistent with most
451
333
other tools. Maybe an option.
452
334
"""
453
335
## TODO: Normalize names
454
336
## TODO: Remove nested loops; better scalability
337
455
338
if isinstance(files, types.StringTypes):
456
339
files = [files]
457
458
self.lock_write()
459
460
try:
461
tree = self.working_tree()
462
inv = tree.inventory
463
464
# do this before any modifications
465
for f in files:
466
fid = inv.path2id(f)
467
if not fid:
468
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
469
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
470
if verbose:
471
# having remove it, it must be either ignored or unknown
472
if tree.is_ignored(f):
473
new_status = 'I'
474
else:
475
new_status = '?'
476
show_status(new_status, inv[fid].kind, quotefn(f))
477
del inv[fid]
478
479
self._write_inventory(inv)
480
finally:
481
self.unlock()
482
483
484
# FIXME: this doesn't need to be a branch method
485
def set_inventory(self, new_inventory_list):
486
inv = Inventory()
487
for path, file_id, parent, kind in new_inventory_list:
488
name = os.path.basename(path)
489
if name == "":
490
continue
491
inv.add(InventoryEntry(file_id, name, kind, parent))
340
341
tree = self.working_tree()
342
inv = tree.inventory
343
344
# do this before any modifications
345
for f in files:
346
fid = inv.path2id(f)
347
if not fid:
348
bailout("cannot remove unversioned file %s" % quotefn(f))
349
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
350
if verbose:
351
# having remove it, it must be either ignored or unknown
352
if tree.is_ignored(f):
353
new_status = 'I'
354
else:
355
new_status = '?'
356
show_status(new_status, inv[fid].kind, quotefn(f))
357
del inv[fid]
358
492
359
self._write_inventory(inv)
493
360
494
361
511
378
return self.working_tree().unknowns()
512
379
513
380
514
def append_revision(self, revision_id):
515
mutter("add {%s} to revision-history" % revision_id)
516
rev_history = self.revision_history()
517
518
tmprhname = self.controlfilename('revision-history.tmp')
519
rhname = self.controlfilename('revision-history')
520
521
f = file(tmprhname, 'wt')
522
rev_history.append(revision_id)
523
f.write('\n'.join(rev_history))
524
f.write('\n')
381
def commit(self, message, timestamp=None, timezone=None,
382
committer=None,
383
verbose=False):
384
"""Commit working copy as a new revision.
385
386
The basic approach is to add all the file texts into the
387
store, then the inventory, then make a new revision pointing
388
to that inventory and store that.
389
390
This is not quite safe if the working copy changes during the
391
commit; for the moment that is simply not allowed. A better
392
approach is to make a temporary copy of the files before
393
computing their hashes, and then add those hashes in turn to
394
the inventory. This should mean at least that there are no
395
broken hash pointers. There is no way we can get a snapshot
396
of the whole directory at an instant. This would also have to
397
be robust against files disappearing, moving, etc. So the
398
whole thing is a bit hard.
399
400
:param timestamp: if not None, seconds-since-epoch for a
401
postdated/predated commit.
402
"""
403
404
## TODO: Show branch names
405
406
# TODO: Don't commit if there are no changes, unless forced?
407
408
# First walk over the working inventory; and both update that
409
# and also build a new revision inventory. The revision
410
# inventory needs to hold the text-id, sha1 and size of the
411
# actual file versions committed in the revision. (These are
412
# not present in the working inventory.) We also need to
413
# detect missing/deleted files, and remove them from the
414
# working inventory.
415
416
work_inv = self.read_working_inventory()
417
inv = Inventory()
418
basis = self.basis_tree()
419
basis_inv = basis.inventory
420
missing_ids = []
421
for path, entry in work_inv.iter_entries():
422
## TODO: Cope with files that have gone missing.
423
424
## TODO: Check that the file kind has not changed from the previous
425
## revision of this file (if any).
426
427
entry = entry.copy()
428
429
p = self.abspath(path)
430
file_id = entry.file_id
431
mutter('commit prep file %s, id %r ' % (p, file_id))
432
433
if not os.path.exists(p):
434
mutter(" file is missing, removing from inventory")
435
if verbose:
436
show_status('D', entry.kind, quotefn(path))
437
missing_ids.append(file_id)
438
continue
439
440
# TODO: Handle files that have been deleted
441
442
# TODO: Maybe a special case for empty files? Seems a
443
# waste to store them many times.
444
445
inv.add(entry)
446
447
if basis_inv.has_id(file_id):
448
old_kind = basis_inv[file_id].kind
449
if old_kind != entry.kind:
450
bailout("entry %r changed kind from %r to %r"
451
% (file_id, old_kind, entry.kind))
452
453
if entry.kind == 'directory':
454
if not isdir(p):
455
bailout("%s is entered as directory but not a directory" % quotefn(p))
456
elif entry.kind == 'file':
457
if not isfile(p):
458
bailout("%s is entered as file but is not a file" % quotefn(p))
459
460
content = file(p, 'rb').read()
461
462
entry.text_sha1 = sha_string(content)
463
entry.text_size = len(content)
464
465
old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
466
if (old_ie
467
and (old_ie.text_size == entry.text_size)
468
and (old_ie.text_sha1 == entry.text_sha1)):
469
## assert content == basis.get_file(file_id).read()
470
entry.text_id = basis_inv[file_id].text_id
471
mutter(' unchanged from previous text_id {%s}' %
472
entry.text_id)
473
474
else:
475
entry.text_id = gen_file_id(entry.name)
476
self.text_store.add(content, entry.text_id)
477
mutter(' stored with text_id {%s}' % entry.text_id)
478
if verbose:
479
if not old_ie:
480
state = 'A'
481
elif (old_ie.name == entry.name
482
and old_ie.parent_id == entry.parent_id):
483
state = 'M'
484
else:
485
state = 'R'
486
487
show_status(state, entry.kind, quotefn(path))
488
489
for file_id in missing_ids:
490
# have to do this later so we don't mess up the iterator.
491
# since parents may be removed before their children we
492
# have to test.
493
494
# FIXME: There's probably a better way to do this; perhaps
495
# the workingtree should know how to filter itself.
496
if work_inv.has_id(file_id):
497
del work_inv[file_id]
498
499
500
inv_id = rev_id = _gen_revision_id(time.time())
501
502
inv_tmp = tempfile.TemporaryFile()
503
inv.write_xml(inv_tmp)
504
inv_tmp.seek(0)
505
self.inventory_store.add(inv_tmp, inv_id)
506
mutter('new inventory_id is {%s}' % inv_id)
507
508
self._write_inventory(work_inv)
509
510
if timestamp == None:
511
timestamp = time.time()
512
513
if committer == None:
514
committer = username()
515
516
if timezone == None:
517
timezone = local_time_offset()
518
519
mutter("building commit log message")
520
rev = Revision(timestamp=timestamp,
521
timezone=timezone,
522
committer=committer,
523
precursor = self.last_patch(),
524
message = message,
525
inventory_id=inv_id,
526
revision_id=rev_id)
527
528
rev_tmp = tempfile.TemporaryFile()
529
rev.write_xml(rev_tmp)
530
rev_tmp.seek(0)
531
self.revision_store.add(rev_tmp, rev_id)
532
mutter("new revision_id is {%s}" % rev_id)
533
534
## XXX: Everything up to here can simply be orphaned if we abort
535
## the commit; it will leave junk files behind but that doesn't
536
## matter.
537
538
## TODO: Read back the just-generated changeset, and make sure it
539
## applies and recreates the right state.
540
541
## TODO: Also calculate and store the inventory SHA1
542
mutter("committing patch r%d" % (self.revno() + 1))
543
544
mutter("append to revision-history")
545
f = self.controlfile('revision-history', 'at')
546
f.write(rev_id + '\n')
525
547
f.close()
526
548
527
if sys.platform == 'win32':
528
os.remove(rhname)
529
os.rename(tmprhname, rhname)
530
549
if verbose:
550
note("commited r%d" % self.revno())
531
551
532
552
533
553
def get_revision(self, revision_id):
540
560
def get_inventory(self, inventory_id):
541
561
"""Get Inventory object by hash.
542
562
543
TODO: Perhaps for this and similar methods, take a revision
563
:todo: Perhaps for this and similar methods, take a revision
544
564
parameter which can be either an integer revno or a
545
565
string hash."""
546
566
i = Inventory.read_xml(self.inventory_store[inventory_id])
561
581
>>> ScratchBranch().revision_history()
562
582
[]
563
583
"""
564
self.lock_read()
565
try:
566
return [l.rstrip('\r\n') for l in
567
self.controlfile('revision-history', 'r').readlines()]
568
finally:
569
self.unlock()
570
571
572
def common_ancestor(self, other, self_revno=None, other_revno=None):
573
"""
574
>>> import commit
575
>>> sb = ScratchBranch(files=['foo', 'foo~'])
576
>>> sb.common_ancestor(sb) == (None, None)
577
True
578
>>> commit.commit(sb, "Committing first revision", verbose=False)
579
>>> sb.common_ancestor(sb)[0]
580
1
581
>>> clone = sb.clone()
582
>>> commit.commit(sb, "Committing second revision", verbose=False)
583
>>> sb.common_ancestor(sb)[0]
584
2
585
>>> sb.common_ancestor(clone)[0]
586
1
587
>>> commit.commit(clone, "Committing divergent second revision",
588
... verbose=False)
589
>>> sb.common_ancestor(clone)[0]
590
1
591
>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
592
True
593
>>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
594
True
595
>>> clone2 = sb.clone()
596
>>> sb.common_ancestor(clone2)[0]
597
2
598
>>> sb.common_ancestor(clone2, self_revno=1)[0]
599
1
600
>>> sb.common_ancestor(clone2, other_revno=1)[0]
601
1
602
"""
603
my_history = self.revision_history()
604
other_history = other.revision_history()
605
if self_revno is None:
606
self_revno = len(my_history)
607
if other_revno is None:
608
other_revno = len(other_history)
609
indices = range(min((self_revno, other_revno)))
610
indices.reverse()
611
for r in indices:
612
if my_history[r] == other_history[r]:
613
return r+1, my_history[r]
614
return None, None
615
616
def enum_history(self, direction):
617
"""Return (revno, revision_id) for history of branch.
618
619
direction
620
'forward' is from earliest to latest
621
'reverse' is from latest to earliest
622
"""
623
rh = self.revision_history()
624
if direction == 'forward':
625
i = 1
626
for rid in rh:
627
yield i, rid
628
i += 1
629
elif direction == 'reverse':
630
i = len(rh)
631
while i > 0:
632
yield i, rh[i-1]
633
i -= 1
634
else:
635
raise ValueError('invalid history direction', direction)
584
return [chomp(l) for l in self.controlfile('revision-history').readlines()]
636
585
637
586
638
587
def revno(self):
640
589
641
590
That is equivalent to the number of revisions committed to
642
591
this branch.
592
593
>>> b = ScratchBranch()
594
>>> b.revno()
595
0
596
>>> b.commit('no foo')
597
>>> b.revno()
598
1
643
599
"""
644
600
return len(self.revision_history())
645
601
646
602
647
603
def last_patch(self):
648
604
"""Return last patch hash, or None if no history.
605
606
>>> ScratchBranch().last_patch() == None
607
True
649
608
"""
650
609
ph = self.revision_history()
651
610
if ph:
652
611
return ph[-1]
653
else:
654
return None
655
656
657
def missing_revisions(self, other):
658
"""
659
If self and other have not diverged, return a list of the revisions
660
present in other, but missing from self.
661
662
>>> from bzrlib.commit import commit
663
>>> bzrlib.trace.silent = True
664
>>> br1 = ScratchBranch()
665
>>> br2 = ScratchBranch()
666
>>> br1.missing_revisions(br2)
667
[]
668
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
669
>>> br1.missing_revisions(br2)
670
[u'REVISION-ID-1']
671
>>> br2.missing_revisions(br1)
672
[]
673
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
674
>>> br1.missing_revisions(br2)
675
[]
676
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
677
>>> br1.missing_revisions(br2)
678
[u'REVISION-ID-2A']
679
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
680
>>> br1.missing_revisions(br2)
681
Traceback (most recent call last):
682
DivergedBranches: These branches have diverged.
683
"""
684
self_history = self.revision_history()
685
self_len = len(self_history)
686
other_history = other.revision_history()
687
other_len = len(other_history)
688
common_index = min(self_len, other_len) -1
689
if common_index >= 0 and \
690
self_history[common_index] != other_history[common_index]:
691
raise DivergedBranches(self, other)
692
if self_len < other_len:
693
return other_history[self_len:]
694
return []
695
696
697
def update_revisions(self, other):
698
"""If self and other have not diverged, ensure self has all the
699
revisions in other
700
701
>>> from bzrlib.commit import commit
702
>>> bzrlib.trace.silent = True
703
>>> br1 = ScratchBranch(files=['foo', 'bar'])
704
>>> br1.add('foo')
705
>>> br1.add('bar')
706
>>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
707
>>> br2 = ScratchBranch()
708
>>> br2.update_revisions(br1)
709
Added 2 texts.
710
Added 1 inventories.
711
Added 1 revisions.
712
>>> br2.revision_history()
713
[u'REVISION-ID-1']
714
>>> br2.update_revisions(br1)
715
Added 0 texts.
716
Added 0 inventories.
717
Added 0 revisions.
718
>>> br1.text_store.total_size() == br2.text_store.total_size()
719
True
720
"""
721
revision_ids = self.missing_revisions(other)
722
revisions = [other.get_revision(f) for f in revision_ids]
723
needed_texts = sets.Set()
724
for rev in revisions:
725
inv = other.get_inventory(str(rev.inventory_id))
726
for key, entry in inv.iter_entries():
727
if entry.text_id is None:
728
continue
729
if entry.text_id not in self.text_store:
730
needed_texts.add(entry.text_id)
731
count = self.text_store.copy_multi(other.text_store, needed_texts)
732
print "Added %d texts." % count
733
inventory_ids = [ f.inventory_id for f in revisions ]
734
count = self.inventory_store.copy_multi(other.inventory_store,
735
inventory_ids)
736
print "Added %d inventories." % count
737
revision_ids = [ f.revision_id for f in revisions]
738
count = self.revision_store.copy_multi(other.revision_store,
739
revision_ids)
740
for revision_id in revision_ids:
741
self.append_revision(revision_id)
742
print "Added %d revisions." % count
743
744
745
def commit(self, *args, **kw):
746
"""Deprecated"""
747
from bzrlib.commit import commit
748
commit(self, *args, **kw)
749
612
750
613
751
614
def lookup_revision(self, revno):
752
615
"""Return revision hash for revision number."""
757
620
# list is 0-based; revisions are 1-based
758
621
return self.revision_history()[revno-1]
759
622
except IndexError:
760
raise BzrError("no such revision %s" % revno)
623
bailout("no such revision %s" % revno)
761
624
762
625
763
626
def revision_tree(self, revision_id):
765
628
766
629
`revision_id` may be None for the null revision, in which case
767
630
an `EmptyTree` is returned."""
768
# TODO: refactor this to use an existing revision object
769
# so we don't need to read it in twice.
631
770
632
if revision_id == None:
771
633
return EmptyTree()
772
634
else:
776
638
777
639
def working_tree(self):
778
640
"""Return a `Tree` for the working copy."""
779
from workingtree import WorkingTree
780
641
return WorkingTree(self.base, self.read_working_inventory())
781
642
782
643
784
645
"""Return `Tree` object for last revision.
785
646
786
647
If there are no revisions yet, return an `EmptyTree`.
648
649
>>> b = ScratchBranch(files=['foo'])
650
>>> b.basis_tree().has_filename('foo')
651
False
652
>>> b.working_tree().has_filename('foo')
653
True
654
>>> b.add('foo')
655
>>> b.commit('add foo')
656
>>> b.basis_tree().has_filename('foo')
657
True
787
658
"""
788
659
r = self.last_patch()
789
660
if r == None:
793
664
794
665
795
666
796
def rename_one(self, from_rel, to_rel):
797
"""Rename one file.
798
799
This can change the directory or the filename or both.
800
"""
801
self.lock_write()
802
try:
803
tree = self.working_tree()
804
inv = tree.inventory
805
if not tree.has_filename(from_rel):
806
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
807
if tree.has_filename(to_rel):
808
raise BzrError("can't rename: new working file %r already exists" % to_rel)
809
810
file_id = inv.path2id(from_rel)
811
if file_id == None:
812
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
813
814
if inv.path2id(to_rel):
815
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
816
817
to_dir, to_tail = os.path.split(to_rel)
818
to_dir_id = inv.path2id(to_dir)
819
if to_dir_id == None and to_dir != '':
820
raise BzrError("can't determine destination directory id for %r" % to_dir)
821
822
mutter("rename_one:")
823
mutter(" file_id {%s}" % file_id)
824
mutter(" from_rel %r" % from_rel)
825
mutter(" to_rel %r" % to_rel)
826
mutter(" to_dir %r" % to_dir)
827
mutter(" to_dir_id {%s}" % to_dir_id)
828
829
inv.rename(file_id, to_dir_id, to_tail)
830
831
print "%s => %s" % (from_rel, to_rel)
832
833
from_abs = self.abspath(from_rel)
834
to_abs = self.abspath(to_rel)
835
try:
836
os.rename(from_abs, to_abs)
837
except OSError, e:
838
raise BzrError("failed to rename %r to %r: %s"
839
% (from_abs, to_abs, e[1]),
840
["rename rolled back"])
841
842
self._write_inventory(inv)
843
finally:
844
self.unlock()
845
846
847
def move(self, from_paths, to_name):
848
"""Rename files.
849
850
to_name must exist as a versioned directory.
851
852
If to_name exists and is a directory, the files are moved into
853
it, keeping their old names. If it is a directory,
854
855
Note that to_name is only the last component of the new name;
856
this doesn't change the directory.
857
"""
858
self.lock_write()
859
try:
860
## TODO: Option to move IDs only
861
assert not isinstance(from_paths, basestring)
862
tree = self.working_tree()
863
inv = tree.inventory
864
to_abs = self.abspath(to_name)
865
if not isdir(to_abs):
866
raise BzrError("destination %r is not a directory" % to_abs)
867
if not tree.has_filename(to_name):
868
raise BzrError("destination %r not in working directory" % to_abs)
869
to_dir_id = inv.path2id(to_name)
870
if to_dir_id == None and to_name != '':
871
raise BzrError("destination %r is not a versioned directory" % to_name)
872
to_dir_ie = inv[to_dir_id]
873
if to_dir_ie.kind not in ('directory', 'root_directory'):
874
raise BzrError("destination %r is not a directory" % to_abs)
875
876
to_idpath = inv.get_idpath(to_dir_id)
877
878
for f in from_paths:
879
if not tree.has_filename(f):
880
raise BzrError("%r does not exist in working tree" % f)
881
f_id = inv.path2id(f)
882
if f_id == None:
883
raise BzrError("%r is not versioned" % f)
884
name_tail = splitpath(f)[-1]
885
dest_path = appendpath(to_name, name_tail)
886
if tree.has_filename(dest_path):
887
raise BzrError("destination %r already exists" % dest_path)
888
if f_id in to_idpath:
889
raise BzrError("can't move %r to a subdirectory of itself" % f)
890
891
# OK, so there's a race here, it's possible that someone will
892
# create a file in this interval and then the rename might be
893
# left half-done. But we should have caught most problems.
894
895
for f in from_paths:
896
name_tail = splitpath(f)[-1]
897
dest_path = appendpath(to_name, name_tail)
898
print "%s => %s" % (f, dest_path)
899
inv.rename(inv.path2id(f), to_dir_id, name_tail)
900
try:
901
os.rename(self.abspath(f), self.abspath(dest_path))
902
except OSError, e:
903
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
904
["rename rolled back"])
905
906
self._write_inventory(inv)
907
finally:
908
self.unlock()
909
667
def write_log(self, show_timezone='original'):
668
"""Write out human-readable log of commits to this branch
669
670
:param utc: If true, show dates in universal time, not local time."""
671
## TODO: Option to choose either original, utc or local timezone
672
revno = 1
673
precursor = None
674
for p in self.revision_history():
675
print '-' * 40
676
print 'revno:', revno
677
## TODO: Show hash if --id is given.
678
##print 'revision-hash:', p
679
rev = self.get_revision(p)
680
print 'committer:', rev.committer
681
print 'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
682
show_timezone))
683
684
## opportunistic consistency check, same as check_patch_chaining
685
if rev.precursor != precursor:
686
bailout("mismatched precursor!")
687
688
print 'message:'
689
if not rev.message:
690
print ' (no message)'
691
else:
692
for l in rev.message.split('\n'):
693
print ' ' + l
694
695
revno += 1
696
precursor = p
697
698
699
700
def show_status(branch, show_all=False):
701
"""Display single-line status for non-ignored working files.
702
703
The list is show sorted in order by file name.
704
705
>>> b = ScratchBranch(files=['foo', 'foo~'])
706
>>> b.show_status()
707
? foo
708
>>> b.add('foo')
709
>>> b.show_status()
710
A foo
711
>>> b.commit("add foo")
712
>>> b.show_status()
713
>>> os.unlink(b.abspath('foo'))
714
>>> b.show_status()
715
D foo
716
717
718
:todo: Get state for single files.
719
720
:todo: Perhaps show a slash at the end of directory names.
721
722
"""
723
724
# We have to build everything into a list first so that it can
725
# sorted by name, incorporating all the different sources.
726
727
# FIXME: Rather than getting things in random order and then sorting,
728
# just step through in order.
729
730
# Interesting case: the old ID for a file has been removed,
731
# but a new file has been created under that name.
732
733
old = branch.basis_tree()
734
old_inv = old.inventory
735
new = branch.working_tree()
736
new_inv = new.inventory
737
738
for fs, fid, oldname, newname, kind in diff_trees(old, new):
739
if fs == 'R':
740
show_status(fs, kind,
741
oldname + ' => ' + newname)
742
elif fs == 'A' or fs == 'M':
743
show_status(fs, kind, newname)
744
elif fs == 'D':
745
show_status(fs, kind, oldname)
746
elif fs == '.':
747
if show_all:
748
show_status(fs, kind, newname)
749
elif fs == 'I':
750
if show_all:
751
show_status(fs, kind, newname)
752
elif fs == '?':
753
show_status(fs, kind, newname)
754
else:
755
bailout("wierd file state %r" % ((fs, fid),))
756
910
757
911
758
912
759
class ScratchBranch(Branch):
916
763
>>> isdir(b.base)
917
764
True
918
765
>>> bd = b.base
919
>>> b.destroy()
766
>>> del b
920
767
>>> isdir(bd)
921
768
False
922
769
"""
923
def __init__(self, files=[], dirs=[], base=None):
770
def __init__(self, files=[], dirs=[]):
924
771
"""Make a test branch.
925
772
926
773
This creates a temporary directory and runs init-tree in it.
927
774
928
775
If any files are listed, they are created in the working copy.
929
776
"""
930
init = False
931
if base is None:
932
base = tempfile.mkdtemp()
933
init = True
934
Branch.__init__(self, base, init=init)
777
Branch.__init__(self, tempfile.mkdtemp(), init=True)
935
778
for d in dirs:
936
779
os.mkdir(self.abspath(d))
937
780
939
782
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
940
783
941
784
942
def clone(self):
943
"""
944
>>> orig = ScratchBranch(files=["file1", "file2"])
945
>>> clone = orig.clone()
946
>>> os.path.samefile(orig.base, clone.base)
947
False
948
>>> os.path.isfile(os.path.join(clone.base, "file1"))
949
True
950
"""
951
base = tempfile.mkdtemp()
952
os.rmdir(base)
953
shutil.copytree(self.base, base, symlinks=True)
954
return ScratchBranch(base=base)
955
956
785
def __del__(self):
957
self.destroy()
958
959
def destroy(self):
960
786
"""Destroy the test branch, removing the scratch directory."""
961
try:
962
if self.base:
963
mutter("delete ScratchBranch %s" % self.base)
964
shutil.rmtree(self.base)
965
except OSError, e:
966
# Work around for shutil.rmtree failing on Windows when
967
# readonly files are encountered
968
mutter("hit exception in destroying ScratchBranch: %s" % e)
969
for root, dirs, files in os.walk(self.base, topdown=False):
970
for name in files:
971
os.chmod(os.path.join(root, name), 0700)
972
shutil.rmtree(self.base)
973
self.base = None
787
shutil.rmtree(self.base)
974
788
975
789
976
790
993
807
994
808
995
809
810
def _gen_revision_id(when):
811
"""Return new revision-id."""
812
s = '%s-%s-' % (user_email(), compact_date(when))
813
s += hexlify(rand_bytes(8))
814
return s
815
816
996
817
def gen_file_id(name):
997
818
"""Return new file id.
998
819
999
820
This should probably generate proper UUIDs, but for the moment we
1000
821
cope with just randomness because running uuidgen every time is
1001
822
slow."""
1002
import re
1003
1004
# get last component
1005
823
idx = name.rfind('/')
1006
824
if idx != -1:
1007
825
name = name[idx+1 : ]
1008
idx = name.rfind('\\')
1009
if idx != -1:
1010
name = name[idx+1 : ]
1011
826
1012
# make it not a hidden file
1013
827
name = name.lstrip('.')
1014
828
1015
# remove any wierd characters; we don't escape them but rather
1016
# just pull them out
1017
name = re.sub(r'[^\w.]', '', name)
1018
1019
829
s = hexlify(rand_bytes(8))
1020
830
return '-'.join((name, compact_date(time.time()), s))
831
832
Loggerhead is a web-based interface for Breezy
Version: 2.0.1