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