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