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