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