« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 24
- compare with another revision
- download diff
- download tarball
- view history from revision 24
- Committer: mbp at sourcefrog
- Date: 2005-03-11 23:23:53 UTC
- Revision ID: mbp@sourcefrog.net-20050311232353-f5e33da490872c6a
Add .bzrignore file
- files added:
- doc/faq.txt
- files removed:
- .rsyncexclude
- contrib
- contrib/bash
- contrib/zsh
- elementtree
- urlgrabber
- files renamed:
- bzrlib/commands.py => bzr.py
- files modified:
- .bzrignore
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, local_time_offset
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
162
## TODO: factor out to atomicfile? is rename safe on windows?
290
## TODO: Maybe some kind of clean/dirty marker on inventory?
291
163
tmpfname = self.controlfilename('inventory.tmp')
292
tmpf = file(tmpfname, 'wb')
164
tmpf = file(tmpfname, 'w')
293
165
inv.write_xml(tmpf)
294
166
tmpf.close()
295
inv_fname = self.controlfilename('inventory')
296
if sys.platform == 'win32':
297
os.remove(inv_fname)
298
os.rename(tmpfname, inv_fname)
167
os.rename(tmpfname, self.controlfilename('inventory'))
299
168
mutter('wrote working inventory')
300
169
301
170
306
175
def add(self, files, verbose=False):
307
176
"""Make files versioned.
308
177
309
Note that the command line normally calls smart_add instead.
310
311
178
This puts the files in the Added state, so that they will be
312
179
recorded by the next commit.
313
180
314
TODO: Perhaps have an option to add the ids even if the files do
181
:todo: Perhaps have an option to add the ids even if the files do
315
182
not (yet) exist.
316
183
317
TODO: Perhaps return the ids of the files? But then again it
184
:todo: Perhaps return the ids of the files? But then again it
318
185
is easy to retrieve them if they're needed.
319
186
320
TODO: Option to specify file id.
187
:todo: Option to specify file id.
321
188
322
TODO: Adding a directory should optionally recurse down and
189
:todo: Adding a directory should optionally recurse down and
323
190
add all non-ignored children. Perhaps do that in a
324
191
higher-level method.
192
193
>>> b = ScratchBranch(files=['foo'])
194
>>> 'foo' in b.unknowns()
195
True
196
>>> b.show_status()
197
? foo
198
>>> b.add('foo')
199
>>> 'foo' in b.unknowns()
200
False
201
>>> bool(b.inventory.path2id('foo'))
202
True
203
>>> b.show_status()
204
A foo
205
206
>>> b.add('foo')
207
Traceback (most recent call last):
208
...
209
BzrError: ('foo is already versioned', [])
210
211
>>> b.add(['nothere'])
212
Traceback (most recent call last):
213
BzrError: ('cannot add: not a regular file or directory: nothere', [])
325
214
"""
326
self._need_writelock()
327
215
328
216
# TODO: Re-adding a file that is removed in the working copy
329
217
# should probably put it back with the previous ID.
340
228
if len(fp) == 0:
341
229
bailout("cannot add top-level %r" % f)
342
230
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
231
fullpath = os.path.normpath(self._rel(f))
232
233
if isfile(fullpath):
234
kind = 'file'
235
elif isdir(fullpath):
236
kind = 'directory'
237
else:
238
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
239
240
if len(fp) > 1:
241
parent_name = joinpath(fp[:-1])
242
mutter("lookup parent %r" % parent_name)
243
parent_id = inv.path2id(parent_name)
244
if parent_id == None:
245
bailout("cannot add: parent %r is not versioned"
246
% joinpath(fp[:-1]))
247
else:
248
parent_id = None
249
250
file_id = _gen_file_id(fp[-1])
251
inv.add(InventoryEntry(file_id, fp[-1], kind=kind, parent_id=parent_id))
357
252
if verbose:
358
253
show_status('A', kind, quotefn(f))
359
254
360
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
361
255
mutter("add file %s file_id:{%s} kind=%r parent_id={%s}"
256
% (f, file_id, kind, parent_id))
362
257
self._write_inventory(inv)
363
258
364
259
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
260
376
261
def remove(self, files, verbose=False):
377
262
"""Mark nominated files for removal from the inventory.
378
263
379
264
This does not remove their text. This does not run on
380
265
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
266
:todo: Refuse to remove modified files unless --force is given?
267
268
>>> b = ScratchBranch(files=['foo'])
269
>>> b.add('foo')
270
>>> b.inventory.has_filename('foo')
271
True
272
>>> b.remove('foo')
273
>>> b.working_tree().has_filename('foo')
274
True
275
>>> b.inventory.has_filename('foo')
276
False
277
278
>>> b = ScratchBranch(files=['foo'])
279
>>> b.add('foo')
280
>>> b.commit('one')
281
>>> b.remove('foo')
282
>>> b.commit('two')
283
>>> b.inventory.has_filename('foo')
284
False
285
>>> b.basis_tree().has_filename('foo')
286
False
287
>>> b.working_tree().has_filename('foo')
288
True
289
290
:todo: Do something useful with directories.
291
292
:todo: Should this remove the text or not? Tough call; not
386
293
removing may be useful and the user can just use use rm, and
387
294
is the opposite of add. Removing it is consistent with most
388
295
other tools. Maybe an option.
389
296
"""
390
297
## TODO: Normalize names
391
298
## TODO: Remove nested loops; better scalability
392
self._need_writelock()
393
299
394
300
if isinstance(files, types.StringTypes):
395
301
files = [files]
396
302
397
tree = self.working_tree()
398
inv = tree.inventory
303
inv = self.read_working_inventory()
399
304
400
305
# do this before any modifications
401
306
for f in files:
404
309
bailout("cannot remove unversioned file %s" % quotefn(f))
405
310
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
406
311
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))
312
show_status('D', inv[fid].kind, quotefn(f))
413
313
del inv[fid]
414
314
415
315
self._write_inventory(inv)
434
334
return self.working_tree().unknowns()
435
335
436
336
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
337
def commit(self, message, timestamp=None, timezone=None,
338
committer=None,
339
verbose=False):
340
"""Commit working copy as a new revision.
341
342
The basic approach is to add all the file texts into the
343
store, then the inventory, then make a new revision pointing
344
to that inventory and store that.
345
346
This is not quite safe if the working copy changes during the
347
commit; for the moment that is simply not allowed. A better
348
approach is to make a temporary copy of the files before
349
computing their hashes, and then add those hashes in turn to
350
the inventory. This should mean at least that there are no
351
broken hash pointers. There is no way we can get a snapshot
352
of the whole directory at an instant. This would also have to
353
be robust against files disappearing, moving, etc. So the
354
whole thing is a bit hard.
355
356
:param timestamp: if not None, seconds-since-epoch for a
357
postdated/predated commit.
358
"""
359
360
## TODO: Show branch names
361
362
# TODO: Don't commit if there are no changes, unless forced?
363
364
# First walk over the working inventory; and both update that
365
# and also build a new revision inventory. The revision
366
# inventory needs to hold the text-id, sha1 and size of the
367
# actual file versions committed in the revision. (These are
368
# not present in the working inventory.) We also need to
369
# detect missing/deleted files, and remove them from the
370
# working inventory.
371
372
work_inv = self.read_working_inventory()
373
inv = Inventory()
374
basis = self.basis_tree()
375
basis_inv = basis.inventory
376
missing_ids = []
377
for path, entry in work_inv.iter_entries():
378
## TODO: Cope with files that have gone missing.
379
380
## TODO: Check that the file kind has not changed from the previous
381
## revision of this file (if any).
382
383
entry = entry.copy()
384
385
p = self._rel(path)
386
file_id = entry.file_id
387
mutter('commit prep file %s, id %r ' % (p, file_id))
388
389
if not os.path.exists(p):
390
mutter(" file is missing, removing from inventory")
391
if verbose:
392
show_status('D', entry.kind, quotefn(path))
393
missing_ids.append(file_id)
394
continue
395
396
# TODO: Handle files that have been deleted
397
398
# TODO: Maybe a special case for empty files? Seems a
399
# waste to store them many times.
400
401
inv.add(entry)
402
403
if basis_inv.has_id(file_id):
404
old_kind = basis_inv[file_id].kind
405
if old_kind != entry.kind:
406
bailout("entry %r changed kind from %r to %r"
407
% (file_id, old_kind, entry.kind))
408
409
if entry.kind == 'directory':
410
if not isdir(p):
411
bailout("%s is entered as directory but not a directory" % quotefn(p))
412
elif entry.kind == 'file':
413
if not isfile(p):
414
bailout("%s is entered as file but is not a file" % quotefn(p))
415
416
content = file(p, 'rb').read()
417
418
entry.text_sha1 = sha_string(content)
419
entry.text_size = len(content)
420
421
old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
422
if (old_ie
423
and (old_ie.text_size == entry.text_size)
424
and (old_ie.text_sha1 == entry.text_sha1)):
425
## assert content == basis.get_file(file_id).read()
426
entry.text_id = basis_inv[file_id].text_id
427
mutter(' unchanged from previous text_id {%s}' %
428
entry.text_id)
429
430
else:
431
entry.text_id = _gen_file_id(entry.name)
432
self.text_store.add(content, entry.text_id)
433
mutter(' stored with text_id {%s}' % entry.text_id)
434
if verbose:
435
if not old_ie:
436
state = 'A'
437
elif (old_ie.name == entry.name
438
and old_ie.parent_id == entry.parent_id):
439
state = 'R'
440
else:
441
state = 'M'
442
443
show_status(state, entry.kind, quotefn(path))
444
445
for file_id in missing_ids:
446
# have to do this later so we don't mess up the iterator.
447
# since parents may be removed before their children we
448
# have to test.
449
450
# FIXME: There's probably a better way to do this; perhaps
451
# the workingtree should know how to filter itself.
452
if work_inv.has_id(file_id):
453
del work_inv[file_id]
454
455
456
inv_id = rev_id = _gen_revision_id(time.time())
457
458
inv_tmp = tempfile.TemporaryFile()
459
inv.write_xml(inv_tmp)
460
inv_tmp.seek(0)
461
self.inventory_store.add(inv_tmp, inv_id)
462
mutter('new inventory_id is {%s}' % inv_id)
463
464
self._write_inventory(work_inv)
465
466
if timestamp == None:
467
timestamp = time.time()
468
469
if committer == None:
470
committer = username()
471
472
if timezone == None:
473
timezone = local_time_offset()
474
475
mutter("building commit log message")
476
rev = Revision(timestamp=timestamp,
477
timezone=timezone,
478
committer=committer,
479
precursor = self.last_patch(),
480
message = message,
481
inventory_id=inv_id,
482
revision_id=rev_id)
483
484
rev_tmp = tempfile.TemporaryFile()
485
rev.write_xml(rev_tmp)
486
rev_tmp.seek(0)
487
self.revision_store.add(rev_tmp, rev_id)
488
mutter("new revision_id is {%s}" % rev_id)
489
490
## XXX: Everything up to here can simply be orphaned if we abort
491
## the commit; it will leave junk files behind but that doesn't
492
## matter.
493
494
## TODO: Read back the just-generated changeset, and make sure it
495
## applies and recreates the right state.
496
497
## TODO: Also calculate and store the inventory SHA1
498
mutter("committing patch r%d" % (self.revno() + 1))
499
500
mutter("append to revision-history")
501
self.controlfile('revision-history', 'at').write(rev_id + '\n')
502
503
mutter("done!")
454
504
455
505
456
506
def get_revision(self, revision_id):
457
507
"""Return the Revision object for a named revision"""
458
self._need_readlock()
459
508
r = Revision.read_xml(self.revision_store[revision_id])
460
509
assert r.revision_id == revision_id
461
510
return r
464
513
def get_inventory(self, inventory_id):
465
514
"""Get Inventory object by hash.
466
515
467
TODO: Perhaps for this and similar methods, take a revision
516
:todo: Perhaps for this and similar methods, take a revision
468
517
parameter which can be either an integer revno or a
469
518
string hash."""
470
self._need_readlock()
471
519
i = Inventory.read_xml(self.inventory_store[inventory_id])
472
520
return i
473
521
474
522
475
523
def get_revision_inventory(self, revision_id):
476
524
"""Return inventory of a past revision."""
477
self._need_readlock()
478
525
if revision_id == None:
479
526
return Inventory()
480
527
else:
487
534
>>> ScratchBranch().revision_history()
488
535
[]
489
536
"""
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)
537
return [chomp(l) for l in self.controlfile('revision-history').readlines()]
514
538
515
539
516
540
def revno(self):
518
542
519
543
That is equivalent to the number of revisions committed to
520
544
this branch.
545
546
>>> b = ScratchBranch()
547
>>> b.revno()
548
0
549
>>> b.commit('no foo')
550
>>> b.revno()
551
1
521
552
"""
522
553
return len(self.revision_history())
523
554
524
555
525
556
def last_patch(self):
526
557
"""Return last patch hash, or None if no history.
558
559
>>> ScratchBranch().last_patch() == None
560
True
527
561
"""
528
562
ph = self.revision_history()
529
563
if ph:
530
564
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
565
540
566
541
567
def lookup_revision(self, revno):
542
568
"""Return revision hash for revision number."""
547
573
# list is 0-based; revisions are 1-based
548
574
return self.revision_history()[revno-1]
549
575
except IndexError:
550
raise BzrError("no such revision %s" % revno)
576
bailout("no such revision %s" % revno)
551
577
552
578
553
579
def revision_tree(self, revision_id):
555
581
556
582
`revision_id` may be None for the null revision, in which case
557
583
an `EmptyTree` is returned."""
558
self._need_readlock()
584
559
585
if revision_id == None:
560
586
return EmptyTree()
561
587
else:
565
591
566
592
def working_tree(self):
567
593
"""Return a `Tree` for the working copy."""
568
from workingtree import WorkingTree
569
594
return WorkingTree(self.base, self.read_working_inventory())
570
595
571
596
573
598
"""Return `Tree` object for last revision.
574
599
575
600
If there are no revisions yet, return an `EmptyTree`.
601
602
>>> b = ScratchBranch(files=['foo'])
603
>>> b.basis_tree().has_filename('foo')
604
False
605
>>> b.working_tree().has_filename('foo')
606
True
607
>>> b.add('foo')
608
>>> b.commit('add foo')
609
>>> b.basis_tree().has_filename('foo')
610
True
576
611
"""
577
612
r = self.last_patch()
578
613
if r == None:
582
617
583
618
584
619
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
def write_log(self, show_timezone='original'):
621
"""Write out human-readable log of commits to this branch
622
623
:param utc: If true, show dates in universal time, not local time."""
624
## TODO: Option to choose either original, utc or local timezone
625
revno = 1
626
precursor = None
627
for p in self.revision_history():
628
print '-' * 40
629
print 'revno:', revno
630
## TODO: Show hash if --id is given.
631
##print 'revision-hash:', p
632
rev = self.get_revision(p)
633
print 'committer:', rev.committer
634
print 'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
635
show_timezone))
636
637
## opportunistic consistency check, same as check_patch_chaining
638
if rev.precursor != precursor:
639
bailout("mismatched precursor!")
640
641
print 'message:'
642
if not rev.message:
643
print ' (no message)'
644
else:
645
for l in rev.message.split('\n'):
646
print ' ' + l
647
648
revno += 1
649
precursor = p
650
651
652
653
def show_status(branch, show_all=False):
654
"""Display single-line status for non-ignored working files.
655
656
The list is show sorted in order by file name.
657
658
>>> b = ScratchBranch(files=['foo', 'foo~'])
659
>>> b.show_status()
660
? foo
661
>>> b.add('foo')
662
>>> b.show_status()
663
A foo
664
>>> b.commit("add foo")
665
>>> b.show_status()
666
>>> os.unlink(b._rel('foo'))
667
>>> b.show_status()
668
D foo
620
669
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.
670
671
:todo: Get state for single files.
672
673
:todo: Perhaps show a slash at the end of directory names.
674
644
675
"""
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
676
677
# We have to build everything into a list first so that it can
678
# sorted by name, incorporating all the different sources.
679
680
# FIXME: Rather than getting things in random order and then sorting,
681
# just step through in order.
682
683
# Interesting case: the old ID for a file has been removed,
684
# but a new file has been created under that name.
685
686
old = branch.basis_tree()
687
old_inv = old.inventory
688
new = branch.working_tree()
689
new_inv = new.inventory
690
691
for fs, fid, oldname, newname, kind in diff_trees(old, new):
692
if fs == 'R':
693
show_status(fs, kind,
694
oldname + ' => ' + newname)
695
elif fs == 'A' or fs == 'M':
696
show_status(fs, kind, newname)
697
elif fs == 'D':
698
show_status(fs, kind, oldname)
699
elif fs == '.':
700
if show_all:
701
show_status(fs, kind, newname)
702
elif fs == 'I':
703
if show_all:
704
show_status(fs, kind, newname)
705
elif fs == '?':
706
show_status(fs, kind, newname)
707
else:
708
bailout("wierd file state %r" % ((fs, fid),))
709
695
710
696
711
697
712
class ScratchBranch(Branch):
701
716
>>> isdir(b.base)
702
717
True
703
718
>>> bd = b.base
704
>>> b.destroy()
719
>>> del b
705
720
>>> isdir(bd)
706
721
False
707
722
"""
708
def __init__(self, files=[], dirs=[]):
723
def __init__(self, files = []):
709
724
"""Make a test branch.
710
725
711
726
This creates a temporary directory and runs init-tree in it.
713
728
If any files are listed, they are created in the working copy.
714
729
"""
715
730
Branch.__init__(self, tempfile.mkdtemp(), init=True)
716
for d in dirs:
717
os.mkdir(self.abspath(d))
718
719
731
for f in files:
720
732
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
721
733
722
734
723
735
def __del__(self):
724
self.destroy()
725
726
def destroy(self):
727
736
"""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
737
shutil.rmtree(self.base)
740
738
741
739
742
740
752
750
## mutter('check %r for control file' % ((head, tail), ))
753
751
if tail == bzrlib.BZRDIR:
754
752
return True
755
if filename == head:
756
break
757
753
filename = head
758
754
return False
759
755
760
756
761
757
762
def gen_file_id(name):
758
def _gen_revision_id(when):
759
"""Return new revision-id."""
760
s = '%s-%s-' % (user_email(), compact_date(when))
761
s += hexlify(rand_bytes(8))
762
return s
763
764
765
def _gen_file_id(name):
763
766
"""Return new file id.
764
767
765
768
This should probably generate proper UUIDs, but for the moment we
766
769
cope with just randomness because running uuidgen every time is
767
770
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
771
assert '/' not in name
772
while name[0] == '.':
773
name = name[1:]
777
774
s = hexlify(rand_bytes(8))
778
775
return '-'.join((name, compact_date(time.time()), s))
776
777
Loggerhead is a web-based interface for Breezy
Version: 2.0.1