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