« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: mbp at sourcefrog
- Date: 2005-03-09 04:08:15 UTC
- Revision ID: mbp@sourcefrog.net-20050309040815-13242001617e4a06
import from baz patch-364
- files removed:
- .bzrignore
- contrib
- contrib/bash
- contrib/zsh
- doc
- elementtree
- notes
- urlgrabber
- files renamed:
- bzrlib/commands.py => bzr.py
- files modified:
- README
added
removed
bzrlib/branch.py
1
# Copyright (C) 2005 Canonical Ltd
1
#! /usr/bin/env python
2
# -*- coding: UTF-8 -*-
2
3
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
24
25
import bzrlib
25
26
from inventory import Inventory
26
27
from trace import mutter, note
27
from tree import Tree, EmptyTree, RevisionTree
28
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
28
29
from inventory import InventoryEntry, Inventory
29
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
30
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, chomp, \
30
31
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
31
joinpath, sha_string, file_kind, local_time_offset, appendpath
32
joinpath, sha_string, file_kind
32
33
from store import ImmutableStore
33
34
from revision import Revision
34
from errors import bailout, BzrError
35
from errors import bailout
35
36
from textui import show_status
37
from diff import diff_trees
36
38
37
39
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
38
40
## TODO: Maybe include checks for common corruption of newlines, etc?
39
41
40
42
41
43
42
def find_branch(f, **args):
43
if f and (f.startswith('http://') or f.startswith('https://')):
44
import remotebranch
45
return remotebranch.RemoteBranch(f, **args)
46
else:
47
return Branch(f, **args)
48
49
50
def find_branch_root(f=None):
51
"""Find the branch root enclosing f, or pwd.
52
53
f may be a filename or a URL.
54
55
It is not necessary that f exists.
56
57
Basically we keep looking up until we find the control directory or
58
run into the root."""
59
if f == None:
60
f = os.getcwd()
61
elif hasattr(os.path, 'realpath'):
62
f = os.path.realpath(f)
63
else:
64
f = os.path.abspath(f)
65
if not os.path.exists(f):
66
raise BzrError('%r does not exist' % f)
67
68
69
orig_f = f
70
71
while True:
72
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
73
return f
74
head, tail = os.path.split(f)
75
if head == f:
76
# reached the root, whatever that may be
77
raise BzrError('%r is not in a branch' % orig_f)
78
f = head
79
80
44
81
45
82
46
######################################################################
85
49
class Branch:
86
50
"""Branch holding a history of revisions.
87
51
88
base
89
Base directory of the branch.
52
:todo: Perhaps use different stores for different classes of object,
53
so that we can keep track of how much space each one uses,
54
or garbage-collect them.
55
56
:todo: Add a RemoteBranch subclass. For the basic case of read-only
57
HTTP access this should be very easy by,
58
just redirecting controlfile access into HTTP requests.
59
We would need a RemoteStore working similarly.
60
61
:todo: Keep the on-disk branch locked while the object exists.
62
63
:todo: mkdir() method.
90
64
"""
91
_lockmode = None
92
93
def __init__(self, base, init=False, find_root=True, lock_mode='w'):
65
def __init__(self, base, init=False):
94
66
"""Create new branch object at a particular location.
95
67
96
base -- Base directory for the branch.
97
98
init -- If True, create new control files in a previously
68
:param base: Base directory for the branch.
69
70
:param init: If True, create new control files in a previously
99
71
unversioned directory. If False, the branch must already
100
72
be versioned.
101
73
102
find_root -- If true and init is false, find the root of the
103
existing branch containing base.
104
105
74
In the test suite, creation of new trees is tested using the
106
75
`ScratchBranch` class.
107
76
"""
77
self.base = os.path.realpath(base)
108
78
if init:
109
self.base = os.path.realpath(base)
110
79
self._make_control()
111
elif find_root:
112
self.base = find_branch_root(base)
113
80
else:
114
self.base = os.path.realpath(base)
115
81
if not isdir(self.controlfilename('.')):
116
82
bailout("not a bzr branch: %s" % quotefn(base),
117
83
['use "bzr init" to initialize a new working tree',
118
84
'current bzr can only operate from top-of-tree'])
119
self._check_format()
120
self.lock(lock_mode)
85
self._check_format()
121
86
122
87
self.text_store = ImmutableStore(self.controlfilename('text-store'))
123
88
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
131
96
__repr__ = __str__
132
97
133
98
134
135
def lock(self, mode='w'):
136
"""Lock the on-disk branch, excluding other processes."""
137
try:
138
import fcntl, errno
139
140
if mode == 'w':
141
lm = fcntl.LOCK_EX
142
om = os.O_WRONLY | os.O_CREAT
143
elif mode == 'r':
144
lm = fcntl.LOCK_SH
145
om = os.O_RDONLY
146
else:
147
raise BzrError("invalid locking mode %r" % mode)
148
149
try:
150
lockfile = os.open(self.controlfilename('branch-lock'), om)
151
except OSError, e:
152
if e.errno == errno.ENOENT:
153
# might not exist on branches from <0.0.4
154
self.controlfile('branch-lock', 'w').close()
155
lockfile = os.open(self.controlfilename('branch-lock'), om)
156
else:
157
raise e
158
159
fcntl.lockf(lockfile, lm)
160
def unlock():
161
fcntl.lockf(lockfile, fcntl.LOCK_UN)
162
os.close(lockfile)
163
self._lockmode = None
164
self.unlock = unlock
165
self._lockmode = mode
166
except ImportError:
167
warning("please write a locking method for platform %r" % sys.platform)
168
def unlock():
169
self._lockmode = None
170
self.unlock = unlock
171
self._lockmode = mode
172
173
174
def _need_readlock(self):
175
if self._lockmode not in ['r', 'w']:
176
raise BzrError('need read lock on branch, only have %r' % self._lockmode)
177
178
def _need_writelock(self):
179
if self._lockmode not in ['w']:
180
raise BzrError('need write lock on branch, only have %r' % self._lockmode)
181
182
183
def abspath(self, name):
184
"""Return absolute filename for something in the branch"""
99
def _rel(self, name):
100
"""Return filename relative to branch top"""
185
101
return os.path.join(self.base, name)
186
187
188
def relpath(self, path):
189
"""Return path relative to this branch of something inside it.
190
191
Raises an error if path is not in this branch."""
192
rp = os.path.realpath(path)
193
# FIXME: windows
194
if not rp.startswith(self.base):
195
bailout("path %r is not within branch %r" % (rp, self.base))
196
rp = rp[len(self.base):]
197
rp = rp.lstrip(os.sep)
198
return rp
199
102
200
103
201
104
def controlfilename(self, file_or_path):
202
105
"""Return location relative to branch."""
206
109
207
110
208
111
def controlfile(self, file_or_path, mode='r'):
209
"""Open a control file for this branch.
210
211
There are two classes of file in the control directory: text
212
and binary. binary files are untranslated byte streams. Text
213
control files are stored with Unix newlines and in UTF-8, even
214
if the platform or locale defaults are different.
215
216
Controlfiles should almost never be opened in write mode but
217
rather should be atomically copied and replaced using atomicfile.
218
"""
219
220
fn = self.controlfilename(file_or_path)
221
222
if mode == 'rb' or mode == 'wb':
223
return file(fn, mode)
224
elif mode == 'r' or mode == 'w':
225
# open in binary mode anyhow so there's no newline translation;
226
# codecs uses line buffering by default; don't want that.
227
import codecs
228
return codecs.open(fn, mode + 'b', 'utf-8',
229
buffering=60000)
230
else:
231
raise BzrError("invalid controlfile mode %r" % mode)
232
112
"""Open a control file for this branch"""
113
return file(self.controlfilename(file_or_path), mode)
233
114
234
115
235
116
def _make_control(self):
241
122
for d in ('text-store', 'inventory-store', 'revision-store'):
242
123
os.mkdir(self.controlfilename(d))
243
124
for f in ('revision-history', 'merged-patches',
244
'pending-merged-patches', 'branch-name',
245
'branch-lock'):
125
'pending-merged-patches', 'branch-name'):
246
126
self.controlfile(f, 'w').write('')
247
127
mutter('created control directory in ' + self.base)
248
128
Inventory().write_xml(self.controlfile('inventory','w'))
255
135
256
136
In the future, we might need different in-memory Branch
257
137
classes to support downlevel branches. But not yet.
258
"""
259
# This ignores newlines so that we can open branches created
260
# on Windows from Linux and so on. I think it might be better
261
# to always make all internal files in unix format.
262
fmt = self.controlfile('branch-format', 'r').read()
263
fmt.replace('\r\n', '')
138
"""
139
# read in binary mode to detect newline wierdness.
140
fmt = self.controlfile('branch-format', 'rb').read()
264
141
if fmt != BZR_BRANCH_FORMAT:
265
142
bailout('sorry, branch format %r not supported' % fmt,
266
143
['use a different bzr version',
269
146
270
147
def read_working_inventory(self):
271
148
"""Read the working inventory."""
272
self._need_readlock()
273
149
before = time.time()
274
# ElementTree does its own conversion from UTF-8, so open in
275
# binary.
276
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
150
inv = Inventory.read_xml(self.controlfile('inventory', 'r'))
277
151
mutter("loaded inventory of %d items in %f"
278
152
% (len(inv), time.time() - before))
279
153
return inv
285
159
That is to say, the inventory describing changes underway, that
286
160
will be committed to the next revision.
287
161
"""
288
self._need_writelock()
289
## TODO: factor out to atomicfile? is rename safe on windows?
290
## TODO: Maybe some kind of clean/dirty marker on inventory?
291
tmpfname = self.controlfilename('inventory.tmp')
292
tmpf = file(tmpfname, 'wb')
293
inv.write_xml(tmpf)
294
tmpf.close()
295
inv_fname = self.controlfilename('inventory')
296
if sys.platform == 'win32':
297
os.remove(inv_fname)
298
os.rename(tmpfname, inv_fname)
299
mutter('wrote working inventory')
162
inv.write_xml(self.controlfile('inventory', 'w'))
163
mutter('wrote inventory to %s' % quotefn(self.controlfilename('inventory')))
300
164
301
165
302
166
inventory = property(read_working_inventory, _write_inventory, None,
306
170
def add(self, files, verbose=False):
307
171
"""Make files versioned.
308
172
309
Note that the command line normally calls smart_add instead.
310
311
173
This puts the files in the Added state, so that they will be
312
174
recorded by the next commit.
313
175
314
TODO: Perhaps have an option to add the ids even if the files do
176
:todo: Perhaps have an option to add the ids even if the files do
315
177
not (yet) exist.
316
178
317
TODO: Perhaps return the ids of the files? But then again it
179
:todo: Perhaps return the ids of the files? But then again it
318
180
is easy to retrieve them if they're needed.
319
181
320
TODO: Option to specify file id.
182
:todo: Option to specify file id.
321
183
322
TODO: Adding a directory should optionally recurse down and
184
:todo: Adding a directory should optionally recurse down and
323
185
add all non-ignored children. Perhaps do that in a
324
186
higher-level method.
187
188
>>> b = ScratchBranch(files=['foo'])
189
>>> 'foo' in b.unknowns()
190
True
191
>>> b.show_status()
192
? foo
193
>>> b.add('foo')
194
>>> 'foo' in b.unknowns()
195
False
196
>>> bool(b.inventory.path2id('foo'))
197
True
198
>>> b.show_status()
199
A foo
200
201
>>> b.add('foo')
202
Traceback (most recent call last):
203
...
204
BzrError: ('foo is already versioned', [])
205
206
>>> b.add(['nothere'])
207
Traceback (most recent call last):
208
BzrError: ('cannot add: not a regular file or directory: nothere', [])
325
209
"""
326
self._need_writelock()
327
210
328
211
# TODO: Re-adding a file that is removed in the working copy
329
212
# should probably put it back with the previous ID.
340
223
if len(fp) == 0:
341
224
bailout("cannot add top-level %r" % f)
342
225
343
fullpath = os.path.normpath(self.abspath(f))
344
345
try:
346
kind = file_kind(fullpath)
347
except OSError:
348
# maybe something better?
349
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
350
351
if kind != 'file' and kind != 'directory':
352
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
353
354
file_id = gen_file_id(f)
355
inv.add_path(f, kind=kind, file_id=file_id)
356
226
fullpath = os.path.normpath(self._rel(f))
227
228
if isfile(fullpath):
229
kind = 'file'
230
elif isdir(fullpath):
231
kind = 'directory'
232
else:
233
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
234
235
if len(fp) > 1:
236
parent_name = joinpath(fp[:-1])
237
mutter("lookup parent %r" % parent_name)
238
parent_id = inv.path2id(parent_name)
239
if parent_id == None:
240
bailout("cannot add: parent %r is not versioned"
241
% joinpath(fp[:-1]))
242
else:
243
parent_id = None
244
245
file_id = _gen_file_id(fp[-1])
246
inv.add(InventoryEntry(file_id, fp[-1], kind=kind, parent_id=parent_id))
357
247
if verbose:
358
248
show_status('A', kind, quotefn(f))
359
249
360
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
361
250
mutter("add file %s file_id:{%s} kind=%r parent_id={%s}"
251
% (f, file_id, kind, parent_id))
362
252
self._write_inventory(inv)
363
253
364
254
365
def print_file(self, file, revno):
366
"""Print `file` to stdout."""
367
self._need_readlock()
368
tree = self.revision_tree(self.lookup_revision(revno))
369
# use inventory as it was in that revision
370
file_id = tree.inventory.path2id(file)
371
if not file_id:
372
bailout("%r is not present in revision %d" % (file, revno))
373
tree.print_file(file_id)
374
375
255
376
256
def remove(self, files, verbose=False):
377
257
"""Mark nominated files for removal from the inventory.
378
258
379
259
This does not remove their text. This does not run on
380
260
381
TODO: Refuse to remove modified files unless --force is given?
382
383
TODO: Do something useful with directories.
384
385
TODO: Should this remove the text or not? Tough call; not
261
:todo: Refuse to remove modified files unless --force is given?
262
263
>>> b = ScratchBranch(files=['foo'])
264
>>> b.add('foo')
265
>>> b.inventory.has_filename('foo')
266
True
267
>>> b.remove('foo')
268
>>> b.working_tree().has_filename('foo')
269
True
270
>>> b.inventory.has_filename('foo')
271
False
272
273
>>> b = ScratchBranch(files=['foo'])
274
>>> b.add('foo')
275
>>> b.commit('one')
276
>>> b.remove('foo')
277
>>> b.commit('two')
278
>>> b.inventory.has_filename('foo')
279
False
280
>>> b.basis_tree().has_filename('foo')
281
False
282
>>> b.working_tree().has_filename('foo')
283
True
284
285
:todo: Do something useful with directories.
286
287
:todo: Should this remove the text or not? Tough call; not
386
288
removing may be useful and the user can just use use rm, and
387
289
is the opposite of add. Removing it is consistent with most
388
290
other tools. Maybe an option.
389
291
"""
390
292
## TODO: Normalize names
391
293
## TODO: Remove nested loops; better scalability
392
self._need_writelock()
393
294
394
295
if isinstance(files, types.StringTypes):
395
296
files = [files]
396
297
397
tree = self.working_tree()
398
inv = tree.inventory
298
inv = self.read_working_inventory()
399
299
400
300
# do this before any modifications
401
301
for f in files:
404
304
bailout("cannot remove unversioned file %s" % quotefn(f))
405
305
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
406
306
if verbose:
407
# having remove it, it must be either ignored or unknown
408
if tree.is_ignored(f):
409
new_status = 'I'
410
else:
411
new_status = '?'
412
show_status(new_status, inv[fid].kind, quotefn(f))
307
show_status('D', inv[fid].kind, quotefn(f))
413
308
del inv[fid]
414
309
415
310
self._write_inventory(inv)
434
329
return self.working_tree().unknowns()
435
330
436
331
437
def append_revision(self, revision_id):
438
mutter("add {%s} to revision-history" % revision_id)
439
rev_history = self.revision_history()
440
441
tmprhname = self.controlfilename('revision-history.tmp')
442
rhname = self.controlfilename('revision-history')
443
444
f = file(tmprhname, 'wt')
445
rev_history.append(revision_id)
446
f.write('\n'.join(rev_history))
447
f.write('\n')
448
f.close()
449
450
if sys.platform == 'win32':
451
os.remove(rhname)
452
os.rename(tmprhname, rhname)
453
332
def commit(self, message, timestamp=None, committer=None,
333
verbose=False):
334
"""Commit working copy as a new revision.
335
336
The basic approach is to add all the file texts into the
337
store, then the inventory, then make a new revision pointing
338
to that inventory and store that.
339
340
This is not quite safe if the working copy changes during the
341
commit; for the moment that is simply not allowed. A better
342
approach is to make a temporary copy of the files before
343
computing their hashes, and then add those hashes in turn to
344
the inventory. This should mean at least that there are no
345
broken hash pointers. There is no way we can get a snapshot
346
of the whole directory at an instant. This would also have to
347
be robust against files disappearing, moving, etc. So the
348
whole thing is a bit hard.
349
350
:param timestamp: if not None, seconds-since-epoch for a
351
postdated/predated commit.
352
"""
353
354
## TODO: Show branch names
355
356
# TODO: Don't commit if there are no changes, unless forced?
357
358
# First walk over the working inventory; and both update that
359
# and also build a new revision inventory. The revision
360
# inventory needs to hold the text-id, sha1 and size of the
361
# actual file versions committed in the revision. (These are
362
# not present in the working inventory.) We also need to
363
# detect missing/deleted files, and remove them from the
364
# working inventory.
365
366
work_inv = self.read_working_inventory()
367
inv = Inventory()
368
basis = self.basis_tree()
369
basis_inv = basis.inventory
370
missing_ids = []
371
for path, entry in work_inv.iter_entries():
372
## TODO: Cope with files that have gone missing.
373
374
## TODO: Check that the file kind has not changed from the previous
375
## revision of this file (if any).
376
377
entry = entry.copy()
378
379
p = self._rel(path)
380
file_id = entry.file_id
381
mutter('commit prep file %s, id %r ' % (p, file_id))
382
383
if not os.path.exists(p):
384
mutter(" file is missing, removing from inventory")
385
if verbose:
386
show_status('D', entry.kind, quotefn(path))
387
missing_ids.append(file_id)
388
continue
389
390
# TODO: Handle files that have been deleted
391
392
# TODO: Maybe a special case for empty files? Seems a
393
# waste to store them many times.
394
395
inv.add(entry)
396
397
if basis_inv.has_id(file_id):
398
old_kind = basis_inv[file_id].kind
399
if old_kind != entry.kind:
400
bailout("entry %r changed kind from %r to %r"
401
% (file_id, old_kind, entry.kind))
402
403
if entry.kind == 'directory':
404
if not isdir(p):
405
bailout("%s is entered as directory but not a directory" % quotefn(p))
406
elif entry.kind == 'file':
407
if not isfile(p):
408
bailout("%s is entered as file but is not a file" % quotefn(p))
409
410
content = file(p, 'rb').read()
411
412
entry.text_sha1 = sha_string(content)
413
entry.text_size = len(content)
414
415
old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
416
if (old_ie
417
and (old_ie.text_size == entry.text_size)
418
and (old_ie.text_sha1 == entry.text_sha1)):
419
## assert content == basis.get_file(file_id).read()
420
entry.text_id = basis_inv[file_id].text_id
421
mutter(' unchanged from previous text_id {%s}' %
422
entry.text_id)
423
424
else:
425
entry.text_id = _gen_file_id(entry.name)
426
self.text_store.add(content, entry.text_id)
427
mutter(' stored with text_id {%s}' % entry.text_id)
428
if verbose:
429
if not old_ie:
430
state = 'A'
431
elif (old_ie.name == entry.name
432
and old_ie.parent_id == entry.parent_id):
433
state = 'R'
434
else:
435
state = 'M'
436
437
show_status(state, entry.kind, quotefn(path))
438
439
for file_id in missing_ids:
440
# have to do this later so we don't mess up the iterator.
441
# since parents may be removed before their children we
442
# have to test.
443
444
# FIXME: There's probably a better way to do this; perhaps
445
# the workingtree should know how to filter itself.
446
if work_inv.has_id(file_id):
447
del work_inv[file_id]
448
449
450
inv_id = rev_id = _gen_revision_id(time.time())
451
452
inv_tmp = tempfile.TemporaryFile()
453
inv.write_xml(inv_tmp)
454
inv_tmp.seek(0)
455
self.inventory_store.add(inv_tmp, inv_id)
456
mutter('new inventory_id is {%s}' % inv_id)
457
458
self._write_inventory(work_inv)
459
460
if timestamp == None:
461
timestamp = time.time()
462
463
if committer == None:
464
committer = username()
465
466
mutter("building commit log message")
467
rev = Revision(timestamp=timestamp,
468
committer=committer,
469
precursor = self.last_patch(),
470
message = message,
471
inventory_id=inv_id,
472
revision_id=rev_id)
473
474
rev_tmp = tempfile.TemporaryFile()
475
rev.write_xml(rev_tmp)
476
rev_tmp.seek(0)
477
self.revision_store.add(rev_tmp, rev_id)
478
mutter("new revision_id is {%s}" % rev_id)
479
480
## XXX: Everything up to here can simply be orphaned if we abort
481
## the commit; it will leave junk files behind but that doesn't
482
## matter.
483
484
## TODO: Read back the just-generated changeset, and make sure it
485
## applies and recreates the right state.
486
487
## TODO: Also calculate and store the inventory SHA1
488
mutter("committing patch r%d" % (self.revno() + 1))
489
490
mutter("append to revision-history")
491
self.controlfile('revision-history', 'at').write(rev_id + '\n')
492
493
mutter("done!")
454
494
455
495
456
496
def get_revision(self, revision_id):
457
497
"""Return the Revision object for a named revision"""
458
self._need_readlock()
459
498
r = Revision.read_xml(self.revision_store[revision_id])
460
499
assert r.revision_id == revision_id
461
500
return r
464
503
def get_inventory(self, inventory_id):
465
504
"""Get Inventory object by hash.
466
505
467
TODO: Perhaps for this and similar methods, take a revision
506
:todo: Perhaps for this and similar methods, take a revision
468
507
parameter which can be either an integer revno or a
469
508
string hash."""
470
self._need_readlock()
471
509
i = Inventory.read_xml(self.inventory_store[inventory_id])
472
510
return i
473
511
474
512
475
513
def get_revision_inventory(self, revision_id):
476
514
"""Return inventory of a past revision."""
477
self._need_readlock()
478
515
if revision_id == None:
479
516
return Inventory()
480
517
else:
487
524
>>> ScratchBranch().revision_history()
488
525
[]
489
526
"""
490
self._need_readlock()
491
return [l.rstrip('\r\n') for l in self.controlfile('revision-history', 'r').readlines()]
492
493
494
def enum_history(self, direction):
495
"""Return (revno, revision_id) for history of branch.
496
497
direction
498
'forward' is from earliest to latest
499
'reverse' is from latest to earliest
500
"""
501
rh = self.revision_history()
502
if direction == 'forward':
503
i = 1
504
for rid in rh:
505
yield i, rid
506
i += 1
507
elif direction == 'reverse':
508
i = len(rh)
509
while i > 0:
510
yield i, rh[i-1]
511
i -= 1
512
else:
513
raise BzrError('invalid history direction %r' % direction)
527
return [chomp(l) for l in self.controlfile('revision-history').readlines()]
514
528
515
529
516
530
def revno(self):
518
532
519
533
That is equivalent to the number of revisions committed to
520
534
this branch.
535
536
>>> b = ScratchBranch()
537
>>> b.revno()
538
0
539
>>> b.commit('no foo')
540
>>> b.revno()
541
1
521
542
"""
522
543
return len(self.revision_history())
523
544
524
545
525
546
def last_patch(self):
526
547
"""Return last patch hash, or None if no history.
548
549
>>> ScratchBranch().last_patch() == None
550
True
527
551
"""
528
552
ph = self.revision_history()
529
553
if ph:
530
554
return ph[-1]
531
else:
532
return None
533
534
535
def commit(self, *args, **kw):
536
"""Deprecated"""
537
from bzrlib.commit import commit
538
commit(self, *args, **kw)
539
555
540
556
541
557
def lookup_revision(self, revno):
542
558
"""Return revision hash for revision number."""
547
563
# list is 0-based; revisions are 1-based
548
564
return self.revision_history()[revno-1]
549
565
except IndexError:
550
raise BzrError("no such revision %s" % revno)
566
bailout("no such revision %s" % revno)
551
567
552
568
553
569
def revision_tree(self, revision_id):
555
571
556
572
`revision_id` may be None for the null revision, in which case
557
573
an `EmptyTree` is returned."""
558
self._need_readlock()
574
559
575
if revision_id == None:
560
576
return EmptyTree()
561
577
else:
565
581
566
582
def working_tree(self):
567
583
"""Return a `Tree` for the working copy."""
568
from workingtree import WorkingTree
569
584
return WorkingTree(self.base, self.read_working_inventory())
570
585
571
586
573
588
"""Return `Tree` object for last revision.
574
589
575
590
If there are no revisions yet, return an `EmptyTree`.
591
592
>>> b = ScratchBranch(files=['foo'])
593
>>> b.basis_tree().has_filename('foo')
594
False
595
>>> b.working_tree().has_filename('foo')
596
True
597
>>> b.add('foo')
598
>>> b.commit('add foo')
599
>>> b.basis_tree().has_filename('foo')
600
True
576
601
"""
577
602
r = self.last_patch()
578
603
if r == None:
582
607
583
608
584
609
585
def rename_one(self, from_rel, to_rel):
586
"""Rename one file.
587
588
This can change the directory or the filename or both.
589
"""
590
self._need_writelock()
591
tree = self.working_tree()
592
inv = tree.inventory
593
if not tree.has_filename(from_rel):
594
bailout("can't rename: old working file %r does not exist" % from_rel)
595
if tree.has_filename(to_rel):
596
bailout("can't rename: new working file %r already exists" % to_rel)
597
598
file_id = inv.path2id(from_rel)
599
if file_id == None:
600
bailout("can't rename: old name %r is not versioned" % from_rel)
601
602
if inv.path2id(to_rel):
603
bailout("can't rename: new name %r is already versioned" % to_rel)
604
605
to_dir, to_tail = os.path.split(to_rel)
606
to_dir_id = inv.path2id(to_dir)
607
if to_dir_id == None and to_dir != '':
608
bailout("can't determine destination directory id for %r" % to_dir)
609
610
mutter("rename_one:")
611
mutter(" file_id {%s}" % file_id)
612
mutter(" from_rel %r" % from_rel)
613
mutter(" to_rel %r" % to_rel)
614
mutter(" to_dir %r" % to_dir)
615
mutter(" to_dir_id {%s}" % to_dir_id)
616
617
inv.rename(file_id, to_dir_id, to_tail)
618
619
print "%s => %s" % (from_rel, to_rel)
620
621
from_abs = self.abspath(from_rel)
622
to_abs = self.abspath(to_rel)
623
try:
624
os.rename(from_abs, to_abs)
625
except OSError, e:
626
bailout("failed to rename %r to %r: %s"
627
% (from_abs, to_abs, e[1]),
628
["rename rolled back"])
629
630
self._write_inventory(inv)
631
632
633
634
def move(self, from_paths, to_name):
635
"""Rename files.
636
637
to_name must exist as a versioned directory.
638
639
If to_name exists and is a directory, the files are moved into
640
it, keeping their old names. If it is a directory,
641
642
Note that to_name is only the last component of the new name;
643
this doesn't change the directory.
644
"""
645
self._need_writelock()
646
## TODO: Option to move IDs only
647
assert not isinstance(from_paths, basestring)
648
tree = self.working_tree()
649
inv = tree.inventory
650
to_abs = self.abspath(to_name)
651
if not isdir(to_abs):
652
bailout("destination %r is not a directory" % to_abs)
653
if not tree.has_filename(to_name):
654
bailout("destination %r not in working directory" % to_abs)
655
to_dir_id = inv.path2id(to_name)
656
if to_dir_id == None and to_name != '':
657
bailout("destination %r is not a versioned directory" % to_name)
658
to_dir_ie = inv[to_dir_id]
659
if to_dir_ie.kind not in ('directory', 'root_directory'):
660
bailout("destination %r is not a directory" % to_abs)
661
662
to_idpath = Set(inv.get_idpath(to_dir_id))
663
664
for f in from_paths:
665
if not tree.has_filename(f):
666
bailout("%r does not exist in working tree" % f)
667
f_id = inv.path2id(f)
668
if f_id == None:
669
bailout("%r is not versioned" % f)
670
name_tail = splitpath(f)[-1]
671
dest_path = appendpath(to_name, name_tail)
672
if tree.has_filename(dest_path):
673
bailout("destination %r already exists" % dest_path)
674
if f_id in to_idpath:
675
bailout("can't move %r to a subdirectory of itself" % f)
676
677
# OK, so there's a race here, it's possible that someone will
678
# create a file in this interval and then the rename might be
679
# left half-done. But we should have caught most problems.
680
681
for f in from_paths:
682
name_tail = splitpath(f)[-1]
683
dest_path = appendpath(to_name, name_tail)
684
print "%s => %s" % (f, dest_path)
685
inv.rename(inv.path2id(f), to_dir_id, name_tail)
686
try:
687
os.rename(self.abspath(f), self.abspath(dest_path))
688
except OSError, e:
689
bailout("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
690
["rename rolled back"])
691
692
self._write_inventory(inv)
693
694
610
def write_log(self, utc=False):
611
"""Write out human-readable log of commits to this branch
612
613
:param utc: If true, show dates in universal time, not local time."""
614
revno = 1
615
precursor = None
616
for p in self.revision_history():
617
print '-' * 40
618
print 'revno:', revno
619
## TODO: Show hash if --id is given.
620
##print 'revision-hash:', p
621
rev = self.get_revision(p)
622
print 'committer:', rev.committer
623
print 'timestamp: %s' % (format_date(rev.timestamp, utc))
624
625
## opportunistic consistency check, same as check_patch_chaining
626
if rev.precursor != precursor:
627
bailout("mismatched precursor!")
628
629
print 'message:'
630
if not rev.message:
631
print ' (no message)'
632
else:
633
for l in rev.message.split('\n'):
634
print ' ' + l
635
636
revno += 1
637
precursor = p
638
639
640
641
def show_status(branch, show_all=False):
642
"""Display single-line status for non-ignored working files.
643
644
The list is show sorted in order by file name.
645
646
>>> b = ScratchBranch(files=['foo', 'foo~'])
647
>>> b.show_status()
648
? foo
649
>>> b.add('foo')
650
>>> b.show_status()
651
A foo
652
>>> b.commit("add foo")
653
>>> b.show_status()
654
655
:todo: Get state for single files.
656
657
:todo: Perhaps show a slash at the end of directory names.
658
659
"""
660
661
# We have to build everything into a list first so that it can
662
# sorted by name, incorporating all the different sources.
663
664
# FIXME: Rather than getting things in random order and then sorting,
665
# just step through in order.
666
667
# Interesting case: the old ID for a file has been removed,
668
# but a new file has been created under that name.
669
670
old = branch.basis_tree()
671
old_inv = old.inventory
672
new = branch.working_tree()
673
new_inv = new.inventory
674
675
for fs, fid, oldname, newname, kind in diff_trees(old, new):
676
if fs == 'R':
677
show_status(fs, kind,
678
oldname + ' => ' + newname)
679
elif fs == 'A' or fs == 'M':
680
show_status(fs, kind, newname)
681
elif fs == 'D':
682
show_status(fs, kind, oldname)
683
elif fs == '.':
684
if show_all:
685
show_status(fs, kind, newname)
686
elif fs == 'I':
687
if show_all:
688
show_status(fs, kind, newname)
689
elif fs == '?':
690
show_status(fs, kind, newname)
691
else:
692
bailout("wierd file state %r" % ((fs, fid),))
693
695
694
696
695
697
696
class ScratchBranch(Branch):
701
700
>>> isdir(b.base)
702
701
True
703
702
>>> bd = b.base
704
>>> b.destroy()
703
>>> del b
705
704
>>> isdir(bd)
706
705
False
707
706
"""
708
def __init__(self, files=[], dirs=[]):
707
def __init__(self, files = []):
709
708
"""Make a test branch.
710
709
711
710
This creates a temporary directory and runs init-tree in it.
713
712
If any files are listed, they are created in the working copy.
714
713
"""
715
714
Branch.__init__(self, tempfile.mkdtemp(), init=True)
716
for d in dirs:
717
os.mkdir(self.abspath(d))
718
719
715
for f in files:
720
716
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
721
717
722
718
723
719
def __del__(self):
724
self.destroy()
725
726
def destroy(self):
727
720
"""Destroy the test branch, removing the scratch directory."""
728
try:
729
mutter("delete ScratchBranch %s" % self.base)
730
shutil.rmtree(self.base)
731
except OSError, e:
732
# Work around for shutil.rmtree failing on Windows when
733
# readonly files are encountered
734
mutter("hit exception in destroying ScratchBranch: %s" % e)
735
for root, dirs, files in os.walk(self.base, topdown=False):
736
for name in files:
737
os.chmod(os.path.join(root, name), 0700)
738
shutil.rmtree(self.base)
739
self.base = None
721
shutil.rmtree(self.base)
740
722
741
723
742
724
752
734
## mutter('check %r for control file' % ((head, tail), ))
753
735
if tail == bzrlib.BZRDIR:
754
736
return True
755
if filename == head:
756
break
757
737
filename = head
758
738
return False
759
739
760
740
761
741
762
def gen_file_id(name):
742
def _gen_revision_id(when):
743
"""Return new revision-id."""
744
s = '%s-%s-' % (user_email(), compact_date(when))
745
s += hexlify(rand_bytes(8))
746
return s
747
748
749
def _gen_file_id(name):
763
750
"""Return new file id.
764
751
765
752
This should probably generate proper UUIDs, but for the moment we
766
753
cope with just randomness because running uuidgen every time is
767
754
slow."""
768
idx = name.rfind('/')
769
if idx != -1:
770
name = name[idx+1 : ]
771
idx = name.rfind('\\')
772
if idx != -1:
773
name = name[idx+1 : ]
774
775
name = name.lstrip('.')
776
755
assert '/' not in name
756
while name[0] == '.':
757
name = name[1:]
777
758
s = hexlify(rand_bytes(8))
778
759
return '-'.join((name, compact_date(time.time()), s))
760
761
Loggerhead is a web-based interface for Breezy
Version: 2.0.1