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