« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 45
- compare with another revision
- download diff
- download tarball
- view history from revision 45
- Committer: Martin Pool
- Date: 2005-03-14 07:07:24 UTC
- Revision ID: mbp@sourcefrog.net-20050314070724-ba6c85db7d96c508
- add setup.py and install instructions
- rename main script to just bzr
- rename main script to just bzr
- files added:
- bzrlib/tests.py
- files removed:
- .rsyncexclude
- contrib
- contrib/bash
- contrib/zsh
- elementtree
- patches
- urlgrabber
- 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
15
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
17
17
18
19
from sets import Set
20
18
21
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
19
22
import traceback, socket, fnmatch, difflib, time
20
23
from binascii import hexlify
22
25
import bzrlib
23
26
from inventory import Inventory
24
27
from trace import mutter, note
25
from tree import Tree, EmptyTree, RevisionTree
28
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
26
29
from inventory import InventoryEntry, Inventory
27
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
30
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, chomp, \
28
31
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
29
joinpath, sha_string, file_kind, local_time_offset, appendpath
32
joinpath, sha_string, file_kind, local_time_offset
30
33
from store import ImmutableStore
31
34
from revision import Revision
32
from errors import BzrError
35
from errors import bailout
33
36
from textui import show_status
37
from diff import diff_trees
34
38
35
39
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
36
40
## TODO: Maybe include checks for common corruption of newlines, etc?
37
41
38
42
39
43
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
49
def with_writelock(method):
50
"""Method decorator for functions run with the branch locked."""
51
def d(self, *a, **k):
52
# called with self set to the branch
53
self.lock('w')
54
try:
55
return method(self, *a, **k)
56
finally:
57
self.unlock()
58
return d
59
60
61
def with_readlock(method):
62
def d(self, *a, **k):
63
self.lock('r')
64
try:
65
return method(self, *a, **k)
66
finally:
67
self.unlock()
68
return d
69
70
71
def find_branch_root(f=None):
72
"""Find the branch root enclosing f, or pwd.
73
74
f may be a filename or a URL.
75
76
It is not necessary that f exists.
77
78
Basically we keep looking up until we find the control directory or
79
run into the root."""
80
if f == None:
81
f = os.getcwd()
82
elif hasattr(os.path, 'realpath'):
83
f = os.path.realpath(f)
84
else:
85
f = os.path.abspath(f)
86
if not os.path.exists(f):
87
raise BzrError('%r does not exist' % f)
88
89
90
orig_f = f
91
92
while True:
93
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
94
return f
95
head, tail = os.path.split(f)
96
if head == f:
97
# reached the root, whatever that may be
98
raise BzrError('%r is not in a branch' % orig_f)
99
f = head
100
101
44
102
45
103
46
######################################################################
104
47
# branch objects
105
48
106
class Branch(object):
49
class Branch:
107
50
"""Branch holding a history of revisions.
108
51
109
base
110
Base directory of the branch.
111
112
_lock_mode
113
None, or 'r' or 'w'
114
115
_lock_count
116
If _lock_mode is true, a positive count of the number of times the
117
lock has been taken.
118
119
_lockfile
120
Open file used for locking.
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.
121
64
"""
122
base = None
123
_lock_mode = None
124
_lock_count = None
125
126
def __init__(self, base, init=False, find_root=True):
65
def __init__(self, base, init=False):
127
66
"""Create new branch object at a particular location.
128
67
129
base -- Base directory for the branch.
130
131
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
132
71
unversioned directory. If False, the branch must already
133
72
be versioned.
134
73
135
find_root -- If true and init is false, find the root of the
136
existing branch containing base.
137
138
74
In the test suite, creation of new trees is tested using the
139
75
`ScratchBranch` class.
140
76
"""
77
self.base = os.path.realpath(base)
141
78
if init:
142
self.base = os.path.realpath(base)
143
79
self._make_control()
144
elif find_root:
145
self.base = find_branch_root(base)
146
80
else:
147
self.base = os.path.realpath(base)
148
81
if not isdir(self.controlfilename('.')):
149
from errors import NotBranchError
150
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
151
['use "bzr init" to initialize a new working tree',
152
'current bzr can only operate from top-of-tree'])
153
self._check_format()
154
self._lockfile = self.controlfile('branch-lock', 'wb')
82
bailout("not a bzr branch: %s" % quotefn(base),
83
['use "bzr init" to initialize a new working tree',
84
'current bzr can only operate from top-of-tree'])
85
self._check_format()
155
86
156
87
self.text_store = ImmutableStore(self.controlfilename('text-store'))
157
88
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
165
96
__repr__ = __str__
166
97
167
98
168
def __del__(self):
169
if self._lock_mode:
170
from warnings import warn
171
warn("branch %r was not explicitly unlocked" % self)
172
self.unlock()
173
174
175
def lock(self, mode):
176
if self._lock_mode:
177
if mode == 'w' and cur_lm == 'r':
178
raise BzrError("can't upgrade to a write lock")
179
180
assert self._lock_count >= 1
181
self._lock_count += 1
182
else:
183
from bzrlib.lock import lock, LOCK_SH, LOCK_EX
184
if mode == 'r':
185
m = LOCK_SH
186
elif mode == 'w':
187
m = LOCK_EX
188
else:
189
raise ValueError('invalid lock mode %r' % mode)
190
191
lock(self._lockfile, m)
192
self._lock_mode = mode
193
self._lock_count = 1
194
195
196
def unlock(self):
197
if not self._lock_mode:
198
raise BzrError('branch %r is not locked' % (self))
199
200
if self._lock_count > 1:
201
self._lock_count -= 1
202
else:
203
assert self._lock_count == 1
204
from bzrlib.lock import unlock
205
unlock(self._lockfile)
206
self._lock_mode = self._lock_count = None
207
208
209
def abspath(self, name):
210
"""Return absolute filename for something in the branch"""
99
def _rel(self, name):
100
"""Return filename relative to branch top"""
211
101
return os.path.join(self.base, name)
212
213
214
def relpath(self, path):
215
"""Return path relative to this branch of something inside it.
216
217
Raises an error if path is not in this branch."""
218
rp = os.path.realpath(path)
219
# FIXME: windows
220
if not rp.startswith(self.base):
221
from errors import NotBranchError
222
raise NotBranchError("path %r is not within branch %r" % (rp, self.base))
223
rp = rp[len(self.base):]
224
rp = rp.lstrip(os.sep)
225
return rp
226
102
227
103
228
104
def controlfilename(self, file_or_path):
229
105
"""Return location relative to branch."""
233
109
234
110
235
111
def controlfile(self, file_or_path, mode='r'):
236
"""Open a control file for this branch.
237
238
There are two classes of file in the control directory: text
239
and binary. binary files are untranslated byte streams. Text
240
control files are stored with Unix newlines and in UTF-8, even
241
if the platform or locale defaults are different.
242
243
Controlfiles should almost never be opened in write mode but
244
rather should be atomically copied and replaced using atomicfile.
245
"""
246
247
fn = self.controlfilename(file_or_path)
248
249
if mode == 'rb' or mode == 'wb':
250
return file(fn, mode)
251
elif mode == 'r' or mode == 'w':
252
# open in binary mode anyhow so there's no newline translation;
253
# codecs uses line buffering by default; don't want that.
254
import codecs
255
return codecs.open(fn, mode + 'b', 'utf-8',
256
buffering=60000)
257
else:
258
raise BzrError("invalid controlfile mode %r" % mode)
259
112
"""Open a control file for this branch"""
113
return file(self.controlfilename(file_or_path), mode)
260
114
261
115
262
116
def _make_control(self):
268
122
for d in ('text-store', 'inventory-store', 'revision-store'):
269
123
os.mkdir(self.controlfilename(d))
270
124
for f in ('revision-history', 'merged-patches',
271
'pending-merged-patches', 'branch-name',
272
'branch-lock'):
125
'pending-merged-patches', 'branch-name'):
273
126
self.controlfile(f, 'w').write('')
274
127
mutter('created control directory in ' + self.base)
275
128
Inventory().write_xml(self.controlfile('inventory','w'))
282
135
283
136
In the future, we might need different in-memory Branch
284
137
classes to support downlevel branches. But not yet.
285
"""
286
# This ignores newlines so that we can open branches created
287
# on Windows from Linux and so on. I think it might be better
288
# to always make all internal files in unix format.
289
fmt = self.controlfile('branch-format', 'r').read()
290
fmt.replace('\r\n', '')
138
"""
139
# read in binary mode to detect newline wierdness.
140
fmt = self.controlfile('branch-format', 'rb').read()
291
141
if fmt != BZR_BRANCH_FORMAT:
292
raise BzrError('sorry, branch format %r not supported' % fmt,
293
['use a different bzr version',
294
'or remove the .bzr directory and "bzr init" again'])
295
296
297
298
@with_readlock
142
bailout('sorry, branch format %r not supported' % fmt,
143
['use a different bzr version',
144
'or remove the .bzr directory and "bzr init" again'])
145
146
299
147
def read_working_inventory(self):
300
148
"""Read the working inventory."""
301
149
before = time.time()
302
# ElementTree does its own conversion from UTF-8, so open in
303
# binary.
304
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
150
inv = Inventory.read_xml(self.controlfile('inventory', 'r'))
305
151
mutter("loaded inventory of %d items in %f"
306
152
% (len(inv), time.time() - before))
307
153
return inv
308
154
309
155
310
156
def _write_inventory(self, inv):
311
157
"""Update the working inventory.
314
160
will be committed to the next revision.
315
161
"""
316
162
## TODO: factor out to atomicfile? is rename safe on windows?
317
## TODO: Maybe some kind of clean/dirty marker on inventory?
318
163
tmpfname = self.controlfilename('inventory.tmp')
319
tmpf = file(tmpfname, 'wb')
164
tmpf = file(tmpfname, 'w')
320
165
inv.write_xml(tmpf)
321
166
tmpf.close()
322
inv_fname = self.controlfilename('inventory')
323
if sys.platform == 'win32':
324
os.remove(inv_fname)
325
os.rename(tmpfname, inv_fname)
167
os.rename(tmpfname, self.controlfilename('inventory'))
326
168
mutter('wrote working inventory')
327
169
328
170
329
171
inventory = property(read_working_inventory, _write_inventory, None,
330
172
"""Inventory for the working copy.""")
331
173
332
174
333
@with_writelock
334
def add(self, files, verbose=False, ids=None):
175
def add(self, files, verbose=False):
335
176
"""Make files versioned.
336
177
337
Note that the command line normally calls smart_add instead.
338
339
178
This puts the files in the Added state, so that they will be
340
179
recorded by the next commit.
341
180
342
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
343
182
not (yet) exist.
344
183
345
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
346
185
is easy to retrieve them if they're needed.
347
186
348
TODO: Option to specify file id.
187
:todo: Option to specify file id.
349
188
350
TODO: Adding a directory should optionally recurse down and
189
:todo: Adding a directory should optionally recurse down and
351
190
add all non-ignored children. Perhaps do that in a
352
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', [])
353
214
"""
215
354
216
# TODO: Re-adding a file that is removed in the working copy
355
217
# should probably put it back with the previous ID.
356
218
if isinstance(files, types.StringTypes):
357
assert(ids is None or isinstance(ids, types.StringTypes))
358
219
files = [files]
359
if ids is not None:
360
ids = [ids]
361
362
if ids is None:
363
ids = [None] * len(files)
364
else:
365
assert(len(ids) == len(files))
366
220
367
221
inv = self.read_working_inventory()
368
for f,file_id in zip(files, ids):
222
for f in files:
369
223
if is_control_file(f):
370
raise BzrError("cannot add control file %s" % quotefn(f))
224
bailout("cannot add control file %s" % quotefn(f))
371
225
372
226
fp = splitpath(f)
373
227
374
228
if len(fp) == 0:
375
raise BzrError("cannot add top-level %r" % f)
376
377
fullpath = os.path.normpath(self.abspath(f))
378
379
try:
380
kind = file_kind(fullpath)
381
except OSError:
382
# maybe something better?
383
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
384
385
if kind != 'file' and kind != 'directory':
386
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
387
388
if file_id is None:
389
file_id = gen_file_id(f)
390
inv.add_path(f, kind=kind, file_id=file_id)
391
229
bailout("cannot add top-level %r" % f)
230
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))
392
252
if verbose:
393
253
show_status('A', kind, quotefn(f))
394
395
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
396
254
255
mutter("add file %s file_id:{%s} kind=%r parent_id={%s}"
256
% (f, file_id, kind, parent_id))
397
257
self._write_inventory(inv)
398
399
400
def print_file(self, file, revno):
401
"""Print `file` to stdout."""
402
tree = self.revision_tree(self.lookup_revision(revno))
403
# use inventory as it was in that revision
404
file_id = tree.inventory.path2id(file)
405
if not file_id:
406
raise BzrError("%r is not present in revision %d" % (file, revno))
407
tree.print_file(file_id)
408
409
410
@with_writelock
258
259
260
411
261
def remove(self, files, verbose=False):
412
262
"""Mark nominated files for removal from the inventory.
413
263
414
264
This does not remove their text. This does not run on
415
265
416
TODO: Refuse to remove modified files unless --force is given?
417
418
TODO: Do something useful with directories.
419
420
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
421
293
removing may be useful and the user can just use use rm, and
422
294
is the opposite of add. Removing it is consistent with most
423
295
other tools. Maybe an option.
424
296
"""
425
297
## TODO: Normalize names
426
298
## TODO: Remove nested loops; better scalability
299
427
300
if isinstance(files, types.StringTypes):
428
301
files = [files]
429
302
430
303
tree = self.working_tree()
431
304
inv = tree.inventory
432
305
434
307
for f in files:
435
308
fid = inv.path2id(f)
436
309
if not fid:
437
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
310
bailout("cannot remove unversioned file %s" % quotefn(f))
438
311
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
439
312
if verbose:
440
313
# having remove it, it must be either ignored or unknown
448
321
self._write_inventory(inv)
449
322
450
323
451
def set_inventory(self, new_inventory_list):
452
inv = Inventory()
453
for path, file_id, parent, kind in new_inventory_list:
454
name = os.path.basename(path)
455
if name == "":
456
continue
457
inv.add(InventoryEntry(file_id, name, kind, parent))
458
self._write_inventory(inv)
459
460
461
324
def unknowns(self):
462
325
"""Return all unknown files.
463
326
477
340
return self.working_tree().unknowns()
478
341
479
342
480
def append_revision(self, revision_id):
481
mutter("add {%s} to revision-history" % revision_id)
482
rev_history = self.revision_history()
483
484
tmprhname = self.controlfilename('revision-history.tmp')
485
rhname = self.controlfilename('revision-history')
486
487
f = file(tmprhname, 'wt')
488
rev_history.append(revision_id)
489
f.write('\n'.join(rev_history))
490
f.write('\n')
491
f.close()
492
493
if sys.platform == 'win32':
494
os.remove(rhname)
495
os.rename(tmprhname, rhname)
496
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!")
497
510
498
511
499
512
def get_revision(self, revision_id):
506
519
def get_inventory(self, inventory_id):
507
520
"""Get Inventory object by hash.
508
521
509
TODO: Perhaps for this and similar methods, take a revision
522
:todo: Perhaps for this and similar methods, take a revision
510
523
parameter which can be either an integer revno or a
511
524
string hash."""
512
525
i = Inventory.read_xml(self.inventory_store[inventory_id])
521
534
return self.get_inventory(self.get_revision(revision_id).inventory_id)
522
535
523
536
524
@with_readlock
525
537
def revision_history(self):
526
538
"""Return sequence of revision hashes on to this branch.
527
539
528
540
>>> ScratchBranch().revision_history()
529
541
[]
530
542
"""
531
return [l.rstrip('\r\n') for l in self.controlfile('revision-history', 'r').readlines()]
532
533
534
def enum_history(self, direction):
535
"""Return (revno, revision_id) for history of branch.
536
537
direction
538
'forward' is from earliest to latest
539
'reverse' is from latest to earliest
540
"""
541
rh = self.revision_history()
542
if direction == 'forward':
543
i = 1
544
for rid in rh:
545
yield i, rid
546
i += 1
547
elif direction == 'reverse':
548
i = len(rh)
549
while i > 0:
550
yield i, rh[i-1]
551
i -= 1
552
else:
553
raise ValueError('invalid history direction', direction)
543
return [chomp(l) for l in self.controlfile('revision-history').readlines()]
554
544
555
545
556
546
def revno(self):
558
548
559
549
That is equivalent to the number of revisions committed to
560
550
this branch.
551
552
>>> b = ScratchBranch()
553
>>> b.revno()
554
0
555
>>> b.commit('no foo')
556
>>> b.revno()
557
1
561
558
"""
562
559
return len(self.revision_history())
563
560
564
561
565
562
def last_patch(self):
566
563
"""Return last patch hash, or None if no history.
564
565
>>> ScratchBranch().last_patch() == None
566
True
567
567
"""
568
568
ph = self.revision_history()
569
569
if ph:
570
570
return ph[-1]
571
else:
572
return None
573
574
575
def commit(self, *args, **kw):
576
"""Deprecated"""
577
from bzrlib.commit import commit
578
commit(self, *args, **kw)
579
571
580
572
581
573
def lookup_revision(self, revno):
582
574
"""Return revision hash for revision number."""
587
579
# list is 0-based; revisions are 1-based
588
580
return self.revision_history()[revno-1]
589
581
except IndexError:
590
raise BzrError("no such revision %s" % revno)
582
bailout("no such revision %s" % revno)
591
583
592
584
593
585
def revision_tree(self, revision_id):
595
587
596
588
`revision_id` may be None for the null revision, in which case
597
589
an `EmptyTree` is returned."""
598
# TODO: refactor this to use an existing revision object
599
# so we don't need to read it in twice.
590
600
591
if revision_id == None:
601
592
return EmptyTree()
602
593
else:
606
597
607
598
def working_tree(self):
608
599
"""Return a `Tree` for the working copy."""
609
from workingtree import WorkingTree
610
600
return WorkingTree(self.base, self.read_working_inventory())
611
601
612
602
614
604
"""Return `Tree` object for last revision.
615
605
616
606
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
617
"""
618
618
r = self.last_patch()
619
619
if r == None:
623
623
624
624
625
625
626
@with_writelock
627
def rename_one(self, from_rel, to_rel):
628
"""Rename one file.
629
630
This can change the directory or the filename or both.
631
"""
632
tree = self.working_tree()
633
inv = tree.inventory
634
if not tree.has_filename(from_rel):
635
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
636
if tree.has_filename(to_rel):
637
raise BzrError("can't rename: new working file %r already exists" % to_rel)
638
639
file_id = inv.path2id(from_rel)
640
if file_id == None:
641
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
642
643
if inv.path2id(to_rel):
644
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
645
646
to_dir, to_tail = os.path.split(to_rel)
647
to_dir_id = inv.path2id(to_dir)
648
if to_dir_id == None and to_dir != '':
649
raise BzrError("can't determine destination directory id for %r" % to_dir)
650
651
mutter("rename_one:")
652
mutter(" file_id {%s}" % file_id)
653
mutter(" from_rel %r" % from_rel)
654
mutter(" to_rel %r" % to_rel)
655
mutter(" to_dir %r" % to_dir)
656
mutter(" to_dir_id {%s}" % to_dir_id)
657
658
inv.rename(file_id, to_dir_id, to_tail)
659
660
print "%s => %s" % (from_rel, to_rel)
661
662
from_abs = self.abspath(from_rel)
663
to_abs = self.abspath(to_rel)
664
try:
665
os.rename(from_abs, to_abs)
666
except OSError, e:
667
raise BzrError("failed to rename %r to %r: %s"
668
% (from_abs, to_abs, e[1]),
669
["rename rolled back"])
670
671
self._write_inventory(inv)
672
673
674
675
@with_writelock
676
def move(self, from_paths, to_name):
677
"""Rename files.
678
679
to_name must exist as a versioned directory.
680
681
If to_name exists and is a directory, the files are moved into
682
it, keeping their old names. If it is a directory,
683
684
Note that to_name is only the last component of the new name;
685
this doesn't change the directory.
686
"""
687
## TODO: Option to move IDs only
688
assert not isinstance(from_paths, basestring)
689
tree = self.working_tree()
690
inv = tree.inventory
691
to_abs = self.abspath(to_name)
692
if not isdir(to_abs):
693
raise BzrError("destination %r is not a directory" % to_abs)
694
if not tree.has_filename(to_name):
695
raise BzrError("destination %r not in working directory" % to_abs)
696
to_dir_id = inv.path2id(to_name)
697
if to_dir_id == None and to_name != '':
698
raise BzrError("destination %r is not a versioned directory" % to_name)
699
to_dir_ie = inv[to_dir_id]
700
if to_dir_ie.kind not in ('directory', 'root_directory'):
701
raise BzrError("destination %r is not a directory" % to_abs)
702
703
to_idpath = inv.get_idpath(to_dir_id)
704
705
for f in from_paths:
706
if not tree.has_filename(f):
707
raise BzrError("%r does not exist in working tree" % f)
708
f_id = inv.path2id(f)
709
if f_id == None:
710
raise BzrError("%r is not versioned" % f)
711
name_tail = splitpath(f)[-1]
712
dest_path = appendpath(to_name, name_tail)
713
if tree.has_filename(dest_path):
714
raise BzrError("destination %r already exists" % dest_path)
715
if f_id in to_idpath:
716
raise BzrError("can't move %r to a subdirectory of itself" % f)
717
718
# OK, so there's a race here, it's possible that someone will
719
# create a file in this interval and then the rename might be
720
# left half-done. But we should have caught most problems.
721
722
for f in from_paths:
723
name_tail = splitpath(f)[-1]
724
dest_path = appendpath(to_name, name_tail)
725
print "%s => %s" % (f, dest_path)
726
inv.rename(inv.path2id(f), to_dir_id, name_tail)
727
try:
728
os.rename(self.abspath(f), self.abspath(dest_path))
729
except OSError, e:
730
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
731
["rename rolled back"])
732
733
self._write_inventory(inv)
734
735
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
675
676
677
:todo: Get state for single files.
678
679
:todo: Perhaps show a slash at the end of directory names.
680
681
"""
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
736
716
737
717
738
718
class ScratchBranch(Branch):
742
722
>>> isdir(b.base)
743
723
True
744
724
>>> bd = b.base
745
>>> b.destroy()
725
>>> del b
746
726
>>> isdir(bd)
747
727
False
748
728
"""
749
def __init__(self, files=[], dirs=[]):
729
def __init__(self, files = []):
750
730
"""Make a test branch.
751
731
752
732
This creates a temporary directory and runs init-tree in it.
754
734
If any files are listed, they are created in the working copy.
755
735
"""
756
736
Branch.__init__(self, tempfile.mkdtemp(), init=True)
757
for d in dirs:
758
os.mkdir(self.abspath(d))
759
760
737
for f in files:
761
738
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
762
739
763
740
764
741
def __del__(self):
765
self.destroy()
766
767
def destroy(self):
768
742
"""Destroy the test branch, removing the scratch directory."""
769
try:
770
mutter("delete ScratchBranch %s" % self.base)
771
shutil.rmtree(self.base)
772
except OSError, e:
773
# Work around for shutil.rmtree failing on Windows when
774
# readonly files are encountered
775
mutter("hit exception in destroying ScratchBranch: %s" % e)
776
for root, dirs, files in os.walk(self.base, topdown=False):
777
for name in files:
778
os.chmod(os.path.join(root, name), 0700)
779
shutil.rmtree(self.base)
780
self.base = None
743
shutil.rmtree(self.base)
781
744
782
745
783
746
793
756
## mutter('check %r for control file' % ((head, tail), ))
794
757
if tail == bzrlib.BZRDIR:
795
758
return True
796
if filename == head:
797
break
798
759
filename = head
799
760
return False
800
761
801
762
802
763
803
def gen_file_id(name):
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):
804
772
"""Return new file id.
805
773
806
774
This should probably generate proper UUIDs, but for the moment we
807
775
cope with just randomness because running uuidgen every time is
808
776
slow."""
809
import re
810
811
# get last component
812
idx = name.rfind('/')
813
if idx != -1:
814
name = name[idx+1 : ]
815
idx = name.rfind('\\')
816
if idx != -1:
817
name = name[idx+1 : ]
818
819
# make it not a hidden file
820
name = name.lstrip('.')
821
822
# remove any wierd characters; we don't escape them but rather
823
# just pull them out
824
name = re.sub(r'[^\w.]', '', name)
825
777
assert '/' not in name
778
while name[0] == '.':
779
name = name[1:]
826
780
s = hexlify(rand_bytes(8))
827
781
return '-'.join((name, compact_date(time.time()), s))
782
783
Loggerhead is a web-based interface for Breezy
Version: 2.0.1