« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 10
- compare with another revision
- download diff
- download tarball
- view history from revision 10
- Committer: mbp at sourcefrog
- Date: 2005-03-09 06:49:00 UTC
- Revision ID: mbp@sourcefrog.net-20050309064900-74935ffb7350b24b
import more files from baz
- files added:
- bzrlib/tests.py
- files removed:
- .bzrignore
- contrib
- contrib/bash
- contrib/zsh
- elementtree
- 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, 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.
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, timezone=None,
333
committer=None,
334
verbose=False):
335
"""Commit working copy as a new revision.
336
337
The basic approach is to add all the file texts into the
338
store, then the inventory, then make a new revision pointing
339
to that inventory and store that.
340
341
This is not quite safe if the working copy changes during the
342
commit; for the moment that is simply not allowed. A better
343
approach is to make a temporary copy of the files before
344
computing their hashes, and then add those hashes in turn to
345
the inventory. This should mean at least that there are no
346
broken hash pointers. There is no way we can get a snapshot
347
of the whole directory at an instant. This would also have to
348
be robust against files disappearing, moving, etc. So the
349
whole thing is a bit hard.
350
351
:param timestamp: if not None, seconds-since-epoch for a
352
postdated/predated commit.
353
"""
354
355
## TODO: Show branch names
356
357
# TODO: Don't commit if there are no changes, unless forced?
358
359
# First walk over the working inventory; and both update that
360
# and also build a new revision inventory. The revision
361
# inventory needs to hold the text-id, sha1 and size of the
362
# actual file versions committed in the revision. (These are
363
# not present in the working inventory.) We also need to
364
# detect missing/deleted files, and remove them from the
365
# working inventory.
366
367
work_inv = self.read_working_inventory()
368
inv = Inventory()
369
basis = self.basis_tree()
370
basis_inv = basis.inventory
371
missing_ids = []
372
for path, entry in work_inv.iter_entries():
373
## TODO: Cope with files that have gone missing.
374
375
## TODO: Check that the file kind has not changed from the previous
376
## revision of this file (if any).
377
378
entry = entry.copy()
379
380
p = self._rel(path)
381
file_id = entry.file_id
382
mutter('commit prep file %s, id %r ' % (p, file_id))
383
384
if not os.path.exists(p):
385
mutter(" file is missing, removing from inventory")
386
if verbose:
387
show_status('D', entry.kind, quotefn(path))
388
missing_ids.append(file_id)
389
continue
390
391
# TODO: Handle files that have been deleted
392
393
# TODO: Maybe a special case for empty files? Seems a
394
# waste to store them many times.
395
396
inv.add(entry)
397
398
if basis_inv.has_id(file_id):
399
old_kind = basis_inv[file_id].kind
400
if old_kind != entry.kind:
401
bailout("entry %r changed kind from %r to %r"
402
% (file_id, old_kind, entry.kind))
403
404
if entry.kind == 'directory':
405
if not isdir(p):
406
bailout("%s is entered as directory but not a directory" % quotefn(p))
407
elif entry.kind == 'file':
408
if not isfile(p):
409
bailout("%s is entered as file but is not a file" % quotefn(p))
410
411
content = file(p, 'rb').read()
412
413
entry.text_sha1 = sha_string(content)
414
entry.text_size = len(content)
415
416
old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
417
if (old_ie
418
and (old_ie.text_size == entry.text_size)
419
and (old_ie.text_sha1 == entry.text_sha1)):
420
## assert content == basis.get_file(file_id).read()
421
entry.text_id = basis_inv[file_id].text_id
422
mutter(' unchanged from previous text_id {%s}' %
423
entry.text_id)
424
425
else:
426
entry.text_id = _gen_file_id(entry.name)
427
self.text_store.add(content, entry.text_id)
428
mutter(' stored with text_id {%s}' % entry.text_id)
429
if verbose:
430
if not old_ie:
431
state = 'A'
432
elif (old_ie.name == entry.name
433
and old_ie.parent_id == entry.parent_id):
434
state = 'R'
435
else:
436
state = 'M'
437
438
show_status(state, entry.kind, quotefn(path))
439
440
for file_id in missing_ids:
441
# have to do this later so we don't mess up the iterator.
442
# since parents may be removed before their children we
443
# have to test.
444
445
# FIXME: There's probably a better way to do this; perhaps
446
# the workingtree should know how to filter itself.
447
if work_inv.has_id(file_id):
448
del work_inv[file_id]
449
450
451
inv_id = rev_id = _gen_revision_id(time.time())
452
453
inv_tmp = tempfile.TemporaryFile()
454
inv.write_xml(inv_tmp)
455
inv_tmp.seek(0)
456
self.inventory_store.add(inv_tmp, inv_id)
457
mutter('new inventory_id is {%s}' % inv_id)
458
459
self._write_inventory(work_inv)
460
461
if timestamp == None:
462
timestamp = time.time()
463
464
if committer == None:
465
committer = username()
466
467
if timezone == None:
468
timezone = local_time_offset()
469
470
mutter("building commit log message")
471
rev = Revision(timestamp=timestamp,
472
timezone=timezone,
473
committer=committer,
474
precursor = self.last_patch(),
475
message = message,
476
inventory_id=inv_id,
477
revision_id=rev_id)
478
479
rev_tmp = tempfile.TemporaryFile()
480
rev.write_xml(rev_tmp)
481
rev_tmp.seek(0)
482
self.revision_store.add(rev_tmp, rev_id)
483
mutter("new revision_id is {%s}" % rev_id)
484
485
## XXX: Everything up to here can simply be orphaned if we abort
486
## the commit; it will leave junk files behind but that doesn't
487
## matter.
488
489
## TODO: Read back the just-generated changeset, and make sure it
490
## applies and recreates the right state.
491
492
## TODO: Also calculate and store the inventory SHA1
493
mutter("committing patch r%d" % (self.revno() + 1))
494
495
mutter("append to revision-history")
496
self.controlfile('revision-history', 'at').write(rev_id + '\n')
497
498
mutter("done!")
497
499
498
500
499
501
def get_revision(self, revision_id):
506
508
def get_inventory(self, inventory_id):
507
509
"""Get Inventory object by hash.
508
510
509
TODO: Perhaps for this and similar methods, take a revision
511
:todo: Perhaps for this and similar methods, take a revision
510
512
parameter which can be either an integer revno or a
511
513
string hash."""
512
514
i = Inventory.read_xml(self.inventory_store[inventory_id])
521
523
return self.get_inventory(self.get_revision(revision_id).inventory_id)
522
524
523
525
524
@with_readlock
525
526
def revision_history(self):
526
527
"""Return sequence of revision hashes on to this branch.
527
528
528
529
>>> ScratchBranch().revision_history()
529
530
[]
530
531
"""
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)
532
return [chomp(l) for l in self.controlfile('revision-history').readlines()]
554
533
555
534
556
535
def revno(self):
558
537
559
538
That is equivalent to the number of revisions committed to
560
539
this branch.
540
541
>>> b = ScratchBranch()
542
>>> b.revno()
543
0
544
>>> b.commit('no foo')
545
>>> b.revno()
546
1
561
547
"""
562
548
return len(self.revision_history())
563
549
564
550
565
551
def last_patch(self):
566
552
"""Return last patch hash, or None if no history.
553
554
>>> ScratchBranch().last_patch() == None
555
True
567
556
"""
568
557
ph = self.revision_history()
569
558
if ph:
570
559
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
560
580
561
581
562
def lookup_revision(self, revno):
582
563
"""Return revision hash for revision number."""
587
568
# list is 0-based; revisions are 1-based
588
569
return self.revision_history()[revno-1]
589
570
except IndexError:
590
raise BzrError("no such revision %s" % revno)
571
bailout("no such revision %s" % revno)
591
572
592
573
593
574
def revision_tree(self, revision_id):
595
576
596
577
`revision_id` may be None for the null revision, in which case
597
578
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.
579
600
580
if revision_id == None:
601
581
return EmptyTree()
602
582
else:
606
586
607
587
def working_tree(self):
608
588
"""Return a `Tree` for the working copy."""
609
from workingtree import WorkingTree
610
589
return WorkingTree(self.base, self.read_working_inventory())
611
590
612
591
614
593
"""Return `Tree` object for last revision.
615
594
616
595
If there are no revisions yet, return an `EmptyTree`.
596
597
>>> b = ScratchBranch(files=['foo'])
598
>>> b.basis_tree().has_filename('foo')
599
False
600
>>> b.working_tree().has_filename('foo')
601
True
602
>>> b.add('foo')
603
>>> b.commit('add foo')
604
>>> b.basis_tree().has_filename('foo')
605
True
617
606
"""
618
607
r = self.last_patch()
619
608
if r == None:
623
612
624
613
625
614
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
615
def write_log(self, utc=False):
616
"""Write out human-readable log of commits to this branch
617
618
:param utc: If true, show dates in universal time, not local time."""
619
## TODO: Option to choose either original, utc or local timezone
620
revno = 1
621
precursor = None
622
for p in self.revision_history():
623
print '-' * 40
624
print 'revno:', revno
625
## TODO: Show hash if --id is given.
626
##print 'revision-hash:', p
627
rev = self.get_revision(p)
628
print 'committer:', rev.committer
629
print 'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0))
630
631
## opportunistic consistency check, same as check_patch_chaining
632
if rev.precursor != precursor:
633
bailout("mismatched precursor!")
634
635
print 'message:'
636
if not rev.message:
637
print ' (no message)'
638
else:
639
for l in rev.message.split('\n'):
640
print ' ' + l
641
642
revno += 1
643
precursor = p
644
645
646
647
def show_status(branch, show_all=False):
648
"""Display single-line status for non-ignored working files.
649
650
The list is show sorted in order by file name.
651
652
>>> b = ScratchBranch(files=['foo', 'foo~'])
653
>>> b.show_status()
654
? foo
655
>>> b.add('foo')
656
>>> b.show_status()
657
A foo
658
>>> b.commit("add foo")
659
>>> b.show_status()
660
661
:todo: Get state for single files.
662
663
:todo: Perhaps show a slash at the end of directory names.
664
665
"""
666
667
# We have to build everything into a list first so that it can
668
# sorted by name, incorporating all the different sources.
669
670
# FIXME: Rather than getting things in random order and then sorting,
671
# just step through in order.
672
673
# Interesting case: the old ID for a file has been removed,
674
# but a new file has been created under that name.
675
676
old = branch.basis_tree()
677
old_inv = old.inventory
678
new = branch.working_tree()
679
new_inv = new.inventory
680
681
for fs, fid, oldname, newname, kind in diff_trees(old, new):
682
if fs == 'R':
683
show_status(fs, kind,
684
oldname + ' => ' + newname)
685
elif fs == 'A' or fs == 'M':
686
show_status(fs, kind, newname)
687
elif fs == 'D':
688
show_status(fs, kind, oldname)
689
elif fs == '.':
690
if show_all:
691
show_status(fs, kind, newname)
692
elif fs == 'I':
693
if show_all:
694
show_status(fs, kind, newname)
695
elif fs == '?':
696
show_status(fs, kind, newname)
697
else:
698
bailout("wierd file state %r" % ((fs, fid),))
699
736
700
737
701
738
702
class ScratchBranch(Branch):
742
706
>>> isdir(b.base)
743
707
True
744
708
>>> bd = b.base
745
>>> b.destroy()
709
>>> del b
746
710
>>> isdir(bd)
747
711
False
748
712
"""
749
def __init__(self, files=[], dirs=[]):
713
def __init__(self, files = []):
750
714
"""Make a test branch.
751
715
752
716
This creates a temporary directory and runs init-tree in it.
754
718
If any files are listed, they are created in the working copy.
755
719
"""
756
720
Branch.__init__(self, tempfile.mkdtemp(), init=True)
757
for d in dirs:
758
os.mkdir(self.abspath(d))
759
760
721
for f in files:
761
722
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
762
723
763
724
764
725
def __del__(self):
765
self.destroy()
766
767
def destroy(self):
768
726
"""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
727
shutil.rmtree(self.base)
781
728
782
729
783
730
793
740
## mutter('check %r for control file' % ((head, tail), ))
794
741
if tail == bzrlib.BZRDIR:
795
742
return True
796
if filename == head:
797
break
798
743
filename = head
799
744
return False
800
745
801
746
802
747
803
def gen_file_id(name):
748
def _gen_revision_id(when):
749
"""Return new revision-id."""
750
s = '%s-%s-' % (user_email(), compact_date(when))
751
s += hexlify(rand_bytes(8))
752
return s
753
754
755
def _gen_file_id(name):
804
756
"""Return new file id.
805
757
806
758
This should probably generate proper UUIDs, but for the moment we
807
759
cope with just randomness because running uuidgen every time is
808
760
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
761
assert '/' not in name
762
while name[0] == '.':
763
name = name[1:]
826
764
s = hexlify(rand_bytes(8))
827
765
return '-'.join((name, compact_date(time.time()), s))
766
767
Loggerhead is a web-based interface for Breezy
Version: 2.0.1