« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 75
- compare with another revision
- download diff
- download tarball
- view history from revision 75
- Committer: mbp at sourcefrog
- Date: 2005-03-23 23:52:10 UTC
- Revision ID: mbp@sourcefrog.net-20050323235210-5464746b93c39ed0
more notes on darcs
- 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
838
839
def install_revisions(self, other, revision_ids, pb):
840
if hasattr(other.revision_store, "prefetch"):
841
other.revision_store.prefetch(revision_ids)
842
if hasattr(other.inventory_store, "prefetch"):
843
inventory_ids = [other.get_revision(r).inventory_id
844
for r in revision_ids]
845
other.inventory_store.prefetch(inventory_ids)
846
847
if pb is None:
848
pb = bzrlib.ui.ui_factory.progress_bar()
849
850
revisions = []
851
needed_texts = set()
852
i = 0
853
854
failures = set()
855
for i, rev_id in enumerate(revision_ids):
856
pb.update('fetching revision', i+1, len(revision_ids))
857
try:
858
rev = other.get_revision(rev_id)
859
except bzrlib.errors.NoSuchRevision:
860
failures.add(rev_id)
861
continue
862
863
revisions.append(rev)
864
inv = other.get_inventory(str(rev.inventory_id))
865
for key, entry in inv.iter_entries():
866
if entry.text_id is None:
867
continue
868
if entry.text_id not in self.text_store:
869
needed_texts.add(entry.text_id)
870
871
pb.clear()
872
873
count, cp_fail = self.text_store.copy_multi(other.text_store,
874
needed_texts)
875
print "Added %d texts." % count
876
inventory_ids = [ f.inventory_id for f in revisions ]
877
count, cp_fail = self.inventory_store.copy_multi(other.inventory_store,
878
inventory_ids)
879
print "Added %d inventories." % count
880
revision_ids = [ f.revision_id for f in revisions]
881
882
count, cp_fail = self.revision_store.copy_multi(other.revision_store,
883
revision_ids,
884
permit_failure=True)
885
assert len(cp_fail) == 0
886
return count, failures
887
888
889
def commit(self, *args, **kw):
890
from bzrlib.commit import commit
891
commit(self, *args, **kw)
892
893
894
def lookup_revision(self, revision):
895
"""Return the revision identifier for a given revision information."""
896
revno, info = self.get_revision_info(revision)
897
return info
898
899
900
def revision_id_to_revno(self, revision_id):
901
"""Given a revision id, return its revno"""
902
history = self.revision_history()
903
try:
904
return history.index(revision_id) + 1
905
except ValueError:
906
raise bzrlib.errors.NoSuchRevision(self, revision_id)
907
908
909
def get_revision_info(self, revision):
910
"""Return (revno, revision id) for revision identifier.
911
912
revision can be an integer, in which case it is assumed to be revno (though
913
this will translate negative values into positive ones)
914
revision can also be a string, in which case it is parsed for something like
915
'date:' or 'revid:' etc.
916
"""
917
if revision is None:
918
return 0, None
919
revno = None
920
try:# Convert to int if possible
921
revision = int(revision)
922
except ValueError:
923
pass
924
revs = self.revision_history()
925
if isinstance(revision, int):
926
if revision == 0:
927
return 0, None
928
# Mabye we should do this first, but we don't need it if revision == 0
929
if revision < 0:
930
revno = len(revs) + revision + 1
931
else:
932
revno = revision
933
elif isinstance(revision, basestring):
934
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
935
if revision.startswith(prefix):
936
revno = func(self, revs, revision)
937
break
938
else:
939
raise BzrError('No namespace registered for string: %r' % revision)
940
941
if revno is None or revno <= 0 or revno > len(revs):
942
raise BzrError("no such revision %s" % revision)
943
return revno, revs[revno-1]
944
945
def _namespace_revno(self, revs, revision):
946
"""Lookup a revision by revision number"""
947
assert revision.startswith('revno:')
948
try:
949
return int(revision[6:])
950
except ValueError:
951
return None
952
REVISION_NAMESPACES['revno:'] = _namespace_revno
953
954
def _namespace_revid(self, revs, revision):
955
assert revision.startswith('revid:')
956
try:
957
return revs.index(revision[6:]) + 1
958
except ValueError:
959
return None
960
REVISION_NAMESPACES['revid:'] = _namespace_revid
961
962
def _namespace_last(self, revs, revision):
963
assert revision.startswith('last:')
964
try:
965
offset = int(revision[5:])
966
except ValueError:
967
return None
968
else:
969
if offset <= 0:
970
raise BzrError('You must supply a positive value for --revision last:XXX')
971
return len(revs) - offset + 1
972
REVISION_NAMESPACES['last:'] = _namespace_last
973
974
def _namespace_tag(self, revs, revision):
975
assert revision.startswith('tag:')
976
raise BzrError('tag: namespace registered, but not implemented.')
977
REVISION_NAMESPACES['tag:'] = _namespace_tag
978
979
def _namespace_date(self, revs, revision):
980
assert revision.startswith('date:')
981
import datetime
982
# Spec for date revisions:
983
# date:value
984
# value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
985
# it can also start with a '+/-/='. '+' says match the first
986
# entry after the given date. '-' is match the first entry before the date
987
# '=' is match the first entry after, but still on the given date.
988
#
989
# +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
990
# -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
991
# =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
992
# May 13th, 2005 at 0:00
993
#
994
# So the proper way of saying 'give me all entries for today' is:
995
# -r {date:+today}:{date:-tomorrow}
996
# The default is '=' when not supplied
997
val = revision[5:]
998
match_style = '='
999
if val[:1] in ('+', '-', '='):
1000
match_style = val[:1]
1001
val = val[1:]
1002
1003
today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
1004
if val.lower() == 'yesterday':
1005
dt = today - datetime.timedelta(days=1)
1006
elif val.lower() == 'today':
1007
dt = today
1008
elif val.lower() == 'tomorrow':
1009
dt = today + datetime.timedelta(days=1)
1010
else:
1011
import re
1012
# This should be done outside the function to avoid recompiling it.
1013
_date_re = re.compile(
1014
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
1015
r'(,|T)?\s*'
1016
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
1017
)
1018
m = _date_re.match(val)
1019
if not m or (not m.group('date') and not m.group('time')):
1020
raise BzrError('Invalid revision date %r' % revision)
1021
1022
if m.group('date'):
1023
year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
1024
else:
1025
year, month, day = today.year, today.month, today.day
1026
if m.group('time'):
1027
hour = int(m.group('hour'))
1028
minute = int(m.group('minute'))
1029
if m.group('second'):
1030
second = int(m.group('second'))
1031
else:
1032
second = 0
1033
else:
1034
hour, minute, second = 0,0,0
1035
1036
dt = datetime.datetime(year=year, month=month, day=day,
1037
hour=hour, minute=minute, second=second)
1038
first = dt
1039
last = None
1040
reversed = False
1041
if match_style == '-':
1042
reversed = True
1043
elif match_style == '=':
1044
last = dt + datetime.timedelta(days=1)
1045
1046
if reversed:
1047
for i in range(len(revs)-1, -1, -1):
1048
r = self.get_revision(revs[i])
1049
# TODO: Handle timezone.
1050
dt = datetime.datetime.fromtimestamp(r.timestamp)
1051
if first >= dt and (last is None or dt >= last):
1052
return i+1
1053
else:
1054
for i in range(len(revs)):
1055
r = self.get_revision(revs[i])
1056
# TODO: Handle timezone.
1057
dt = datetime.datetime.fromtimestamp(r.timestamp)
1058
if first <= dt and (last is None or dt <= last):
1059
return i+1
1060
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
1061
622
1062
623
def revision_tree(self, revision_id):
1063
624
"""Return Tree for a revision on this branch.
1064
625
1065
626
`revision_id` may be None for the null revision, in which case
1066
627
an `EmptyTree` is returned."""
1067
# TODO: refactor this to use an existing revision object
1068
# so we don't need to read it in twice.
628
1069
629
if revision_id == None:
1070
630
return EmptyTree()
1071
631
else:
1075
635
1076
636
def working_tree(self):
1077
637
"""Return a `Tree` for the working copy."""
1078
from workingtree import WorkingTree
1079
638
return WorkingTree(self.base, self.read_working_inventory())
1080
639
1081
640
1083
642
"""Return `Tree` object for last revision.
1084
643
1085
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
1086
655
"""
1087
656
r = self.last_patch()
1088
657
if r == None:
1092
661
1093
662
1094
663
1095
def rename_one(self, from_rel, to_rel):
1096
"""Rename one file.
1097
1098
This can change the directory or the filename or both.
1099
"""
1100
self.lock_write()
1101
try:
1102
tree = self.working_tree()
1103
inv = tree.inventory
1104
if not tree.has_filename(from_rel):
1105
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
1106
if tree.has_filename(to_rel):
1107
raise BzrError("can't rename: new working file %r already exists" % to_rel)
1108
1109
file_id = inv.path2id(from_rel)
1110
if file_id == None:
1111
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
1112
1113
if inv.path2id(to_rel):
1114
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
1115
1116
to_dir, to_tail = os.path.split(to_rel)
1117
to_dir_id = inv.path2id(to_dir)
1118
if to_dir_id == None and to_dir != '':
1119
raise BzrError("can't determine destination directory id for %r" % to_dir)
1120
1121
mutter("rename_one:")
1122
mutter(" file_id {%s}" % file_id)
1123
mutter(" from_rel %r" % from_rel)
1124
mutter(" to_rel %r" % to_rel)
1125
mutter(" to_dir %r" % to_dir)
1126
mutter(" to_dir_id {%s}" % to_dir_id)
1127
1128
inv.rename(file_id, to_dir_id, to_tail)
1129
1130
print "%s => %s" % (from_rel, to_rel)
1131
1132
from_abs = self.abspath(from_rel)
1133
to_abs = self.abspath(to_rel)
1134
try:
1135
os.rename(from_abs, to_abs)
1136
except OSError, e:
1137
raise BzrError("failed to rename %r to %r: %s"
1138
% (from_abs, to_abs, e[1]),
1139
["rename rolled back"])
1140
1141
self._write_inventory(inv)
1142
finally:
1143
self.unlock()
1144
1145
1146
def move(self, from_paths, to_name):
1147
"""Rename files.
1148
1149
to_name must exist as a versioned directory.
1150
1151
If to_name exists and is a directory, the files are moved into
1152
it, keeping their old names. If it is a directory,
1153
1154
Note that to_name is only the last component of the new name;
1155
this doesn't change the directory.
1156
"""
1157
self.lock_write()
1158
try:
1159
## TODO: Option to move IDs only
1160
assert not isinstance(from_paths, basestring)
1161
tree = self.working_tree()
1162
inv = tree.inventory
1163
to_abs = self.abspath(to_name)
1164
if not isdir(to_abs):
1165
raise BzrError("destination %r is not a directory" % to_abs)
1166
if not tree.has_filename(to_name):
1167
raise BzrError("destination %r not in working directory" % to_abs)
1168
to_dir_id = inv.path2id(to_name)
1169
if to_dir_id == None and to_name != '':
1170
raise BzrError("destination %r is not a versioned directory" % to_name)
1171
to_dir_ie = inv[to_dir_id]
1172
if to_dir_ie.kind not in ('directory', 'root_directory'):
1173
raise BzrError("destination %r is not a directory" % to_abs)
1174
1175
to_idpath = inv.get_idpath(to_dir_id)
1176
1177
for f in from_paths:
1178
if not tree.has_filename(f):
1179
raise BzrError("%r does not exist in working tree" % f)
1180
f_id = inv.path2id(f)
1181
if f_id == None:
1182
raise BzrError("%r is not versioned" % f)
1183
name_tail = splitpath(f)[-1]
1184
dest_path = appendpath(to_name, name_tail)
1185
if tree.has_filename(dest_path):
1186
raise BzrError("destination %r already exists" % dest_path)
1187
if f_id in to_idpath:
1188
raise BzrError("can't move %r to a subdirectory of itself" % f)
1189
1190
# OK, so there's a race here, it's possible that someone will
1191
# create a file in this interval and then the rename might be
1192
# left half-done. But we should have caught most problems.
1193
1194
for f in from_paths:
1195
name_tail = splitpath(f)[-1]
1196
dest_path = appendpath(to_name, name_tail)
1197
print "%s => %s" % (f, dest_path)
1198
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1199
try:
1200
os.rename(self.abspath(f), self.abspath(dest_path))
1201
except OSError, e:
1202
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1203
["rename rolled back"])
1204
1205
self._write_inventory(inv)
1206
finally:
1207
self.unlock()
1208
1209
1210
def revert(self, filenames, old_tree=None, backups=True):
1211
"""Restore selected files to the versions from a previous tree.
1212
1213
backups
1214
If true (default) backups are made of files before
1215
they're renamed.
1216
"""
1217
from bzrlib.errors import NotVersionedError, BzrError
1218
from bzrlib.atomicfile import AtomicFile
1219
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
1220
713
1221
inv = self.read_working_inventory()
1222
if old_tree is None:
1223
old_tree = self.basis_tree()
1224
old_inv = old_tree.inventory
1225
1226
nids = []
1227
for fn in filenames:
1228
file_id = inv.path2id(fn)
1229
if not file_id:
1230
raise NotVersionedError("not a versioned file", fn)
1231
if not old_inv.has_id(file_id):
1232
raise BzrError("file not present in old tree", fn, file_id)
1233
nids.append((fn, file_id))
1234
1235
# TODO: Rename back if it was previously at a different location
1236
1237
# TODO: If given a directory, restore the entire contents from
1238
# the previous version.
1239
1240
# TODO: Make a backup to a temporary file.
1241
1242
# TODO: If the file previously didn't exist, delete it?
1243
for fn, file_id in nids:
1244
backup_file(fn)
1245
1246
f = AtomicFile(fn, 'wb')
1247
try:
1248
f.write(old_tree.get_file(file_id).read())
1249
f.commit()
1250
finally:
1251
f.close()
1252
1253
1254
def pending_merges(self):
1255
"""Return a list of pending merges.
1256
1257
These are revisions that have been merged into the working
1258
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
1259
719
"""
1260
cfn = self.controlfilename('pending-merges')
1261
if not os.path.exists(cfn):
1262
return []
1263
p = []
1264
for l in self.controlfile('pending-merges', 'r').readlines():
1265
p.append(l.rstrip('\n'))
1266
return p
1267
1268
1269
def add_pending_merge(self, revision_id):
1270
from bzrlib.revision import validate_revision_id
1271
1272
validate_revision_id(revision_id)
1273
1274
p = self.pending_merges()
1275
if revision_id in p:
1276
return
1277
p.append(revision_id)
1278
self.set_pending_merges(p)
1279
1280
1281
def set_pending_merges(self, rev_list):
1282
from bzrlib.atomicfile import AtomicFile
1283
self.lock_write()
1284
try:
1285
f = AtomicFile(self.controlfilename('pending-merges'))
1286
try:
1287
for l in rev_list:
1288
print >>f, l
1289
f.commit()
1290
finally:
1291
f.close()
1292
finally:
1293
self.unlock()
1294
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
1295
754
1296
755
1297
756
class ScratchBranch(Branch):
1301
760
>>> isdir(b.base)
1302
761
True
1303
762
>>> bd = b.base
1304
>>> b.destroy()
763
>>> del b
1305
764
>>> isdir(bd)
1306
765
False
1307
766
"""
1308
def __init__(self, files=[], dirs=[], base=None):
767
def __init__(self, files = []):
1309
768
"""Make a test branch.
1310
769
1311
770
This creates a temporary directory and runs init-tree in it.
1312
771
1313
772
If any files are listed, they are created in the working copy.
1314
773
"""
1315
from tempfile import mkdtemp
1316
init = False
1317
if base is None:
1318
base = mkdtemp()
1319
init = True
1320
Branch.__init__(self, base, init=init)
1321
for d in dirs:
1322
os.mkdir(self.abspath(d))
1323
774
Branch.__init__(self, tempfile.mkdtemp(), init=True)
1324
775
for f in files:
1325
776
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
1326
777
1327
778
1328
def clone(self):
1329
"""
1330
>>> orig = ScratchBranch(files=["file1", "file2"])
1331
>>> clone = orig.clone()
1332
>>> os.path.samefile(orig.base, clone.base)
1333
False
1334
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1335
True
1336
"""
1337
from shutil import copytree
1338
from tempfile import mkdtemp
1339
base = mkdtemp()
1340
os.rmdir(base)
1341
copytree(self.base, base, symlinks=True)
1342
return ScratchBranch(base=base)
1343
1344
779
def __del__(self):
1345
self.destroy()
1346
1347
def destroy(self):
1348
780
"""Destroy the test branch, removing the scratch directory."""
1349
from shutil import rmtree
1350
try:
1351
if self.base:
1352
mutter("delete ScratchBranch %s" % self.base)
1353
rmtree(self.base)
1354
except OSError, e:
1355
# Work around for shutil.rmtree failing on Windows when
1356
# readonly files are encountered
1357
mutter("hit exception in destroying ScratchBranch: %s" % e)
1358
for root, dirs, files in os.walk(self.base, topdown=False):
1359
for name in files:
1360
os.chmod(os.path.join(root, name), 0700)
1361
rmtree(self.base)
1362
self.base = None
781
shutil.rmtree(self.base)
1363
782
1364
783
1365
784
1382
801
1383
802
1384
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
1385
811
def gen_file_id(name):
1386
812
"""Return new file id.
1387
813
1388
814
This should probably generate proper UUIDs, but for the moment we
1389
815
cope with just randomness because running uuidgen every time is
1390
816
slow."""
1391
import re
1392
from binascii import hexlify
1393
from time import time
1394
1395
# get last component
1396
817
idx = name.rfind('/')
1397
818
if idx != -1:
1398
819
name = name[idx+1 : ]
1399
idx = name.rfind('\\')
1400
if idx != -1:
1401
name = name[idx+1 : ]
1402
820
1403
# make it not a hidden file
1404
821
name = name.lstrip('.')
1405
822
1406
# remove any wierd characters; we don't escape them but rather
1407
# just pull them out
1408
name = re.sub(r'[^\w.]', '', name)
1409
1410
823
s = hexlify(rand_bytes(8))
1411
return '-'.join((name, compact_date(time()), s))
1412
1413
1414
def gen_root_id():
1415
"""Return a new tree-root file id."""
1416
return gen_file_id('TREE_ROOT')
824
return '-'.join((name, compact_date(time.time()), s))
825
1417
826
Loggerhead is a web-based interface for Breezy
Version: 2.0.1