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