« 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
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/elementtree
- bzrlib/util/urlgrabber
- contrib
- contrib/bash
- contrib/emacs
- contrib/zsh
- patches
- tools
- 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
18
import sys
19
import os
19
from sets import Set
20
21
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
22
import traceback, socket, fnmatch, difflib, time
23
from binascii import hexlify
20
24
21
25
import bzrlib
22
from bzrlib.trace import mutter, note
23
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, \
24
splitpath, \
25
sha_file, appendpath, file_kind
26
27
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId
28
import bzrlib.errors
29
from bzrlib.textui import show_status
30
from bzrlib.revision import Revision
31
from bzrlib.xml import unpack_xml
32
from bzrlib.delta import compare_trees
33
from bzrlib.tree import EmptyTree, RevisionTree
34
import bzrlib.ui
35
36
26
from inventory import Inventory
27
from trace import mutter, note
28
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
29
from inventory import InventoryEntry, Inventory
30
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, chomp, \
31
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
32
joinpath, sha_string, file_kind, local_time_offset
33
from store import ImmutableStore
34
from revision import Revision
35
from errors import bailout
36
from textui import show_status
37
from diff import diff_trees
37
38
38
39
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
39
40
## TODO: Maybe include checks for common corruption of newlines, etc?
40
41
41
42
42
# TODO: Some operations like log might retrieve the same revisions
43
# repeatedly to calculate deltas. We could perhaps have a weakref
44
# cache in memory to make this faster.
45
46
# TODO: please move the revision-string syntax stuff out of the branch
47
# object; it's clutter
48
49
50
def find_branch(f, **args):
51
if f and (f.startswith('http://') or f.startswith('https://')):
52
import remotebranch
53
return remotebranch.RemoteBranch(f, **args)
54
else:
55
return Branch(f, **args)
56
57
58
def find_cached_branch(f, cache_root, **args):
59
from remotebranch import RemoteBranch
60
br = find_branch(f, **args)
61
def cacheify(br, store_name):
62
from meta_store import CachedStore
63
cache_path = os.path.join(cache_root, store_name)
64
os.mkdir(cache_path)
65
new_store = CachedStore(getattr(br, store_name), cache_path)
66
setattr(br, store_name, new_store)
67
68
if isinstance(br, RemoteBranch):
69
cacheify(br, 'inventory_store')
70
cacheify(br, 'text_store')
71
cacheify(br, 'revision_store')
72
return br
73
74
75
def _relpath(base, path):
76
"""Return path relative to base, or raise exception.
77
78
The path may be either an absolute path or a path relative to the
79
current working directory.
80
81
Lifted out of Branch.relpath for ease of testing.
82
83
os.path.commonprefix (python2.4) has a bad bug that it works just
84
on string prefixes, assuming that '/u' is a prefix of '/u2'. This
85
avoids that problem."""
86
rp = os.path.abspath(path)
87
88
s = []
89
head = rp
90
while len(head) >= len(base):
91
if head == base:
92
break
93
head, tail = os.path.split(head)
94
if tail:
95
s.insert(0, tail)
96
else:
97
from errors import NotBranchError
98
raise NotBranchError("path %r is not within branch %r" % (rp, base))
99
100
return os.sep.join(s)
101
102
103
def find_branch_root(f=None):
104
"""Find the branch root enclosing f, or pwd.
105
106
f may be a filename or a URL.
107
108
It is not necessary that f exists.
109
110
Basically we keep looking up until we find the control directory or
111
run into the root. If there isn't one, raises NotBranchError.
112
"""
113
if f == None:
114
f = os.getcwd()
115
elif hasattr(os.path, 'realpath'):
116
f = os.path.realpath(f)
117
else:
118
f = os.path.abspath(f)
119
if not os.path.exists(f):
120
raise BzrError('%r does not exist' % f)
121
122
123
orig_f = f
124
125
while True:
126
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
127
return f
128
head, tail = os.path.split(f)
129
if head == f:
130
# reached the root, whatever that may be
131
raise bzrlib.errors.NotBranchError('%s is not in a branch' % orig_f)
132
f = head
133
134
135
136
# XXX: move into bzrlib.errors; subclass BzrError
137
class DivergedBranches(Exception):
138
def __init__(self, branch1, branch2):
139
self.branch1 = branch1
140
self.branch2 = branch2
141
Exception.__init__(self, "These branches have diverged.")
43
142
44
143
45
144
46
######################################################################
145
47
# branch objects
146
48
147
class Branch(object):
49
class Branch:
148
50
"""Branch holding a history of revisions.
149
51
150
base
151
Base directory of the branch.
152
153
_lock_mode
154
None, or 'r' or 'w'
155
156
_lock_count
157
If _lock_mode is true, a positive count of the number of times the
158
lock has been taken.
159
160
_lock
161
Lock object from bzrlib.lock.
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.
162
64
"""
163
base = None
164
_lock_mode = None
165
_lock_count = None
166
_lock = None
167
168
# Map some sort of prefix into a namespace
169
# stuff like "revno:10", "revid:", etc.
170
# This should match a prefix with a function which accepts
171
REVISION_NAMESPACES = {}
172
173
def __init__(self, base, init=False, find_root=True):
65
def __init__(self, base, init=False):
174
66
"""Create new branch object at a particular location.
175
67
176
base -- Base directory for the branch. May be a file:// url.
177
178
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
179
71
unversioned directory. If False, the branch must already
180
72
be versioned.
181
73
182
find_root -- If true and init is false, find the root of the
183
existing branch containing base.
184
185
74
In the test suite, creation of new trees is tested using the
186
75
`ScratchBranch` class.
187
76
"""
188
from bzrlib.store import ImmutableStore
77
self.base = os.path.realpath(base)
189
78
if init:
190
self.base = os.path.realpath(base)
191
79
self._make_control()
192
elif find_root:
193
self.base = find_branch_root(base)
194
80
else:
195
if base.startswith("file://"):
196
base = base[7:]
197
self.base = os.path.realpath(base)
198
81
if not isdir(self.controlfilename('.')):
199
from errors import NotBranchError
200
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
201
['use "bzr init" to initialize a new working tree',
202
'current bzr can only operate from top-of-tree'])
203
self._check_format()
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()
204
86
205
87
self.text_store = ImmutableStore(self.controlfilename('text-store'))
206
88
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
214
96
__repr__ = __str__
215
97
216
98
217
def __del__(self):
218
if self._lock_mode or self._lock:
219
from warnings import warn
220
warn("branch %r was not explicitly unlocked" % self)
221
self._lock.unlock()
222
223
def lock_write(self):
224
if self._lock_mode:
225
if self._lock_mode != 'w':
226
from errors import LockError
227
raise LockError("can't upgrade to a write lock from %r" %
228
self._lock_mode)
229
self._lock_count += 1
230
else:
231
from bzrlib.lock import WriteLock
232
233
self._lock = WriteLock(self.controlfilename('branch-lock'))
234
self._lock_mode = 'w'
235
self._lock_count = 1
236
237
238
def lock_read(self):
239
if self._lock_mode:
240
assert self._lock_mode in ('r', 'w'), \
241
"invalid lock mode %r" % self._lock_mode
242
self._lock_count += 1
243
else:
244
from bzrlib.lock import ReadLock
245
246
self._lock = ReadLock(self.controlfilename('branch-lock'))
247
self._lock_mode = 'r'
248
self._lock_count = 1
249
250
def unlock(self):
251
if not self._lock_mode:
252
from errors import LockError
253
raise LockError('branch %r is not locked' % (self))
254
255
if self._lock_count > 1:
256
self._lock_count -= 1
257
else:
258
self._lock.unlock()
259
self._lock = None
260
self._lock_mode = self._lock_count = None
261
262
def abspath(self, name):
263
"""Return absolute filename for something in the branch"""
99
def _rel(self, name):
100
"""Return filename relative to branch top"""
264
101
return os.path.join(self.base, name)
265
266
def relpath(self, path):
267
"""Return path relative to this branch of something inside it.
268
269
Raises an error if path is not in this branch."""
270
return _relpath(self.base, path)
102
271
103
272
104
def controlfilename(self, file_or_path):
273
105
"""Return location relative to branch."""
274
if isinstance(file_or_path, basestring):
106
if isinstance(file_or_path, types.StringTypes):
275
107
file_or_path = [file_or_path]
276
108
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
277
109
278
110
279
111
def controlfile(self, file_or_path, mode='r'):
280
"""Open a control file for this branch.
281
282
There are two classes of file in the control directory: text
283
and binary. binary files are untranslated byte streams. Text
284
control files are stored with Unix newlines and in UTF-8, even
285
if the platform or locale defaults are different.
286
287
Controlfiles should almost never be opened in write mode but
288
rather should be atomically copied and replaced using atomicfile.
289
"""
290
291
fn = self.controlfilename(file_or_path)
292
293
if mode == 'rb' or mode == 'wb':
294
return file(fn, mode)
295
elif mode == 'r' or mode == 'w':
296
# open in binary mode anyhow so there's no newline translation;
297
# codecs uses line buffering by default; don't want that.
298
import codecs
299
return codecs.open(fn, mode + 'b', 'utf-8',
300
buffering=60000)
301
else:
302
raise BzrError("invalid controlfile mode %r" % mode)
112
"""Open a control file for this branch"""
113
return file(self.controlfilename(file_or_path), mode)
114
303
115
304
116
def _make_control(self):
305
from bzrlib.inventory import Inventory
306
from bzrlib.xml import pack_xml
307
308
117
os.mkdir(self.controlfilename([]))
309
118
self.controlfile('README', 'w').write(
310
119
"This is a Bazaar-NG control directory.\n"
311
"Do not change any files in this directory.\n")
120
"Do not change any files in this directory.")
312
121
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
313
122
for d in ('text-store', 'inventory-store', 'revision-store'):
314
123
os.mkdir(self.controlfilename(d))
315
124
for f in ('revision-history', 'merged-patches',
316
'pending-merged-patches', 'branch-name',
317
'branch-lock',
318
'pending-merges'):
125
'pending-merged-patches', 'branch-name'):
319
126
self.controlfile(f, 'w').write('')
320
127
mutter('created control directory in ' + self.base)
128
Inventory().write_xml(self.controlfile('inventory','w'))
321
129
322
# if we want per-tree root ids then this is the place to set
323
# them; they're not needed for now and so ommitted for
324
# simplicity.
325
pack_xml(Inventory(), self.controlfile('inventory','w'))
326
130
327
131
def _check_format(self):
328
132
"""Check this branch format is supported.
331
135
332
136
In the future, we might need different in-memory Branch
333
137
classes to support downlevel branches. But not yet.
334
"""
335
# This ignores newlines so that we can open branches created
336
# on Windows from Linux and so on. I think it might be better
337
# to always make all internal files in unix format.
338
fmt = self.controlfile('branch-format', 'r').read()
339
fmt.replace('\r\n', '')
138
"""
139
# read in binary mode to detect newline wierdness.
140
fmt = self.controlfile('branch-format', 'rb').read()
340
141
if fmt != BZR_BRANCH_FORMAT:
341
raise BzrError('sorry, branch format %r not supported' % fmt,
342
['use a different bzr version',
343
'or remove the .bzr directory and "bzr init" again'])
344
345
def get_root_id(self):
346
"""Return the id of this branches root"""
347
inv = self.read_working_inventory()
348
return inv.root.file_id
349
350
def set_root_id(self, file_id):
351
inv = self.read_working_inventory()
352
orig_root_id = inv.root.file_id
353
del inv._byid[inv.root.file_id]
354
inv.root.file_id = file_id
355
inv._byid[inv.root.file_id] = inv.root
356
for fid in inv:
357
entry = inv[fid]
358
if entry.parent_id in (None, orig_root_id):
359
entry.parent_id = inv.root.file_id
360
self._write_inventory(inv)
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
361
146
362
147
def read_working_inventory(self):
363
148
"""Read the working inventory."""
364
from bzrlib.inventory import Inventory
365
from bzrlib.xml import unpack_xml
366
from time import time
367
before = time()
368
self.lock_read()
369
try:
370
# ElementTree does its own conversion from UTF-8, so open in
371
# binary.
372
inv = unpack_xml(Inventory,
373
self.controlfile('inventory', 'rb'))
374
mutter("loaded inventory of %d items in %f"
375
% (len(inv), time() - before))
376
return inv
377
finally:
378
self.unlock()
379
149
before = time.time()
150
inv = Inventory.read_xml(self.controlfile('inventory', 'r'))
151
mutter("loaded inventory of %d items in %f"
152
% (len(inv), time.time() - before))
153
return inv
154
380
155
381
156
def _write_inventory(self, inv):
382
157
"""Update the working inventory.
384
159
That is to say, the inventory describing changes underway, that
385
160
will be committed to the next revision.
386
161
"""
387
from bzrlib.atomicfile import AtomicFile
388
from bzrlib.xml import pack_xml
389
390
self.lock_write()
391
try:
392
f = AtomicFile(self.controlfilename('inventory'), 'wb')
393
try:
394
pack_xml(inv, f)
395
f.commit()
396
finally:
397
f.close()
398
finally:
399
self.unlock()
400
401
mutter('wrote working inventory')
402
162
inv.write_xml(self.controlfile('inventory', 'w'))
163
mutter('wrote inventory to %s' % quotefn(self.controlfilename('inventory')))
164
403
165
404
166
inventory = property(read_working_inventory, _write_inventory, None,
405
167
"""Inventory for the working copy.""")
406
168
407
169
408
def add(self, files, ids=None):
170
def add(self, files, verbose=False):
409
171
"""Make files versioned.
410
172
411
Note that the command line normally calls smart_add instead,
412
which can automatically recurse.
413
414
173
This puts the files in the Added state, so that they will be
415
174
recorded by the next commit.
416
175
417
files
418
List of paths to add, relative to the base of the tree.
419
420
ids
421
If set, use these instead of automatically generated ids.
422
Must be the same length as the list of files, but may
423
contain None for ids that are to be autogenerated.
424
425
TODO: Perhaps have an option to add the ids even if the files do
426
not (yet) exist.
427
428
TODO: Perhaps yield the ids and paths as they're added.
176
:todo: Perhaps have an option to add the ids even if the files do
177
not (yet) exist.
178
179
:todo: Perhaps return the ids of the files? But then again it
180
is easy to retrieve them if they're needed.
181
182
:todo: Option to specify file id.
183
184
:todo: Adding a directory should optionally recurse down and
185
add all non-ignored children. Perhaps do that in a
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', [])
429
209
"""
210
430
211
# TODO: Re-adding a file that is removed in the working copy
431
212
# should probably put it back with the previous ID.
432
if isinstance(files, basestring):
433
assert(ids is None or isinstance(ids, basestring))
213
if isinstance(files, types.StringTypes):
434
214
files = [files]
435
if ids is not None:
436
ids = [ids]
437
438
if ids is None:
439
ids = [None] * len(files)
440
else:
441
assert(len(ids) == len(files))
442
443
self.lock_write()
444
try:
445
inv = self.read_working_inventory()
446
for f,file_id in zip(files, ids):
447
if is_control_file(f):
448
raise BzrError("cannot add control file %s" % quotefn(f))
449
450
fp = splitpath(f)
451
452
if len(fp) == 0:
453
raise BzrError("cannot add top-level %r" % f)
454
455
fullpath = os.path.normpath(self.abspath(f))
456
457
try:
458
kind = file_kind(fullpath)
459
except OSError:
460
# maybe something better?
461
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
462
463
if kind != 'file' and kind != 'directory':
464
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
465
466
if file_id is None:
467
file_id = gen_file_id(f)
468
inv.add_path(f, kind=kind, file_id=file_id)
469
470
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
471
472
self._write_inventory(inv)
473
finally:
474
self.unlock()
475
476
477
def print_file(self, file, revno):
478
"""Print `file` to stdout."""
479
self.lock_read()
480
try:
481
tree = self.revision_tree(self.lookup_revision(revno))
482
# use inventory as it was in that revision
483
file_id = tree.inventory.path2id(file)
484
if not file_id:
485
raise BzrError("%r is not present in revision %s" % (file, revno))
486
tree.print_file(file_id)
487
finally:
488
self.unlock()
215
216
inv = self.read_working_inventory()
217
for f in files:
218
if is_control_file(f):
219
bailout("cannot add control file %s" % quotefn(f))
220
221
fp = splitpath(f)
222
223
if len(fp) == 0:
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))
247
if verbose:
248
show_status('A', kind, quotefn(f))
249
250
mutter("add file %s file_id:{%s} kind=%r parent_id={%s}"
251
% (f, file_id, kind, parent_id))
252
self._write_inventory(inv)
253
489
254
490
255
491
256
def remove(self, files, verbose=False):
493
258
494
259
This does not remove their text. This does not run on
495
260
496
TODO: Refuse to remove modified files unless --force is given?
497
498
TODO: Do something useful with directories.
499
500
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
501
288
removing may be useful and the user can just use use rm, and
502
289
is the opposite of add. Removing it is consistent with most
503
290
other tools. Maybe an option.
504
291
"""
505
292
## TODO: Normalize names
506
293
## TODO: Remove nested loops; better scalability
507
if isinstance(files, basestring):
294
295
if isinstance(files, types.StringTypes):
508
296
files = [files]
509
510
self.lock_write()
511
512
try:
513
tree = self.working_tree()
514
inv = tree.inventory
515
516
# do this before any modifications
517
for f in files:
518
fid = inv.path2id(f)
519
if not fid:
520
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
521
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
522
if verbose:
523
# having remove it, it must be either ignored or unknown
524
if tree.is_ignored(f):
525
new_status = 'I'
526
else:
527
new_status = '?'
528
show_status(new_status, inv[fid].kind, quotefn(f))
529
del inv[fid]
530
531
self._write_inventory(inv)
532
finally:
533
self.unlock()
534
535
536
# FIXME: this doesn't need to be a branch method
537
def set_inventory(self, new_inventory_list):
538
from bzrlib.inventory import Inventory, InventoryEntry
539
inv = Inventory(self.get_root_id())
540
for path, file_id, parent, kind in new_inventory_list:
541
name = os.path.basename(path)
542
if name == "":
543
continue
544
inv.add(InventoryEntry(file_id, name, kind, parent))
297
298
inv = self.read_working_inventory()
299
300
# do this before any modifications
301
for f in files:
302
fid = inv.path2id(f)
303
if not fid:
304
bailout("cannot remove unversioned file %s" % quotefn(f))
305
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
306
if verbose:
307
show_status('D', inv[fid].kind, quotefn(f))
308
del inv[fid]
309
545
310
self._write_inventory(inv)
546
311
547
312
564
329
return self.working_tree().unknowns()
565
330
566
331
567
def append_revision(self, *revision_ids):
568
from bzrlib.atomicfile import AtomicFile
569
570
for revision_id in revision_ids:
571
mutter("add {%s} to revision-history" % revision_id)
572
573
rev_history = self.revision_history()
574
rev_history.extend(revision_ids)
575
576
f = AtomicFile(self.controlfilename('revision-history'))
577
try:
578
for rev_id in rev_history:
579
print >>f, rev_id
580
f.commit()
581
finally:
582
f.close()
583
584
def get_revision_xml(self, revision_id):
585
"""Return XML file object for revision object."""
586
if not revision_id or not isinstance(revision_id, basestring):
587
raise InvalidRevisionId(revision_id)
588
589
self.lock_read()
590
try:
591
try:
592
return self.revision_store[revision_id]
593
except IndexError:
594
raise bzrlib.errors.NoSuchRevision(self, revision_id)
595
finally:
596
self.unlock()
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!")
499
597
500
598
501
def get_revision(self, revision_id):
599
502
"""Return the Revision object for a named revision"""
600
xml_file = self.get_revision_xml(revision_id)
601
602
try:
603
r = unpack_xml(Revision, xml_file)
604
except SyntaxError, e:
605
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
606
[revision_id,
607
str(e)])
608
503
r = Revision.read_xml(self.revision_store[revision_id])
609
504
assert r.revision_id == revision_id
610
505
return r
611
506
612
def get_revision_delta(self, revno):
613
"""Return the delta for one revision.
614
615
The delta is relative to its mainline predecessor, or the
616
empty tree for revision 1.
617
"""
618
assert isinstance(revno, int)
619
rh = self.revision_history()
620
if not (1 <= revno <= len(rh)):
621
raise InvalidRevisionNumber(revno)
622
623
# revno is 1-based; list is 0-based
624
625
new_tree = self.revision_tree(rh[revno-1])
626
if revno == 1:
627
old_tree = EmptyTree()
628
else:
629
old_tree = self.revision_tree(rh[revno-2])
630
631
return compare_trees(old_tree, new_tree)
632
633
634
635
def get_revision_sha1(self, revision_id):
636
"""Hash the stored value of a revision, and return it."""
637
# In the future, revision entries will be signed. At that
638
# point, it is probably best *not* to include the signature
639
# in the revision hash. Because that lets you re-sign
640
# the revision, (add signatures/remove signatures) and still
641
# have all hash pointers stay consistent.
642
# But for now, just hash the contents.
643
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
644
645
507
646
508
def get_inventory(self, inventory_id):
647
509
"""Get Inventory object by hash.
648
510
649
TODO: Perhaps for this and similar methods, take a revision
511
:todo: Perhaps for this and similar methods, take a revision
650
512
parameter which can be either an integer revno or a
651
513
string hash."""
652
from bzrlib.inventory import Inventory
653
from bzrlib.xml import unpack_xml
654
655
return unpack_xml(Inventory, self.get_inventory_xml(inventory_id))
656
657
658
def get_inventory_xml(self, inventory_id):
659
"""Get inventory XML as a file object."""
660
return self.inventory_store[inventory_id]
661
662
663
def get_inventory_sha1(self, inventory_id):
664
"""Return the sha1 hash of the inventory entry
665
"""
666
return sha_file(self.get_inventory_xml(inventory_id))
514
i = Inventory.read_xml(self.inventory_store[inventory_id])
515
return i
667
516
668
517
669
518
def get_revision_inventory(self, revision_id):
670
519
"""Return inventory of a past revision."""
671
# bzr 0.0.6 imposes the constraint that the inventory_id
672
# must be the same as its revision, so this is trivial.
673
520
if revision_id == None:
674
from bzrlib.inventory import Inventory
675
return Inventory(self.get_root_id())
521
return Inventory()
676
522
else:
677
return self.get_inventory(revision_id)
523
return self.get_inventory(self.get_revision(revision_id).inventory_id)
678
524
679
525
680
526
def revision_history(self):
683
529
>>> ScratchBranch().revision_history()
684
530
[]
685
531
"""
686
self.lock_read()
687
try:
688
return [l.rstrip('\r\n') for l in
689
self.controlfile('revision-history', 'r').readlines()]
690
finally:
691
self.unlock()
692
693
694
def common_ancestor(self, other, self_revno=None, other_revno=None):
695
"""
696
>>> import commit
697
>>> sb = ScratchBranch(files=['foo', 'foo~'])
698
>>> sb.common_ancestor(sb) == (None, None)
699
True
700
>>> commit.commit(sb, "Committing first revision", verbose=False)
701
>>> sb.common_ancestor(sb)[0]
702
1
703
>>> clone = sb.clone()
704
>>> commit.commit(sb, "Committing second revision", verbose=False)
705
>>> sb.common_ancestor(sb)[0]
706
2
707
>>> sb.common_ancestor(clone)[0]
708
1
709
>>> commit.commit(clone, "Committing divergent second revision",
710
... verbose=False)
711
>>> sb.common_ancestor(clone)[0]
712
1
713
>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
714
True
715
>>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
716
True
717
>>> clone2 = sb.clone()
718
>>> sb.common_ancestor(clone2)[0]
719
2
720
>>> sb.common_ancestor(clone2, self_revno=1)[0]
721
1
722
>>> sb.common_ancestor(clone2, other_revno=1)[0]
723
1
724
"""
725
my_history = self.revision_history()
726
other_history = other.revision_history()
727
if self_revno is None:
728
self_revno = len(my_history)
729
if other_revno is None:
730
other_revno = len(other_history)
731
indices = range(min((self_revno, other_revno)))
732
indices.reverse()
733
for r in indices:
734
if my_history[r] == other_history[r]:
735
return r+1, my_history[r]
736
return None, None
532
return [chomp(l) for l in self.controlfile('revision-history').readlines()]
737
533
738
534
739
535
def revno(self):
741
537
742
538
That is equivalent to the number of revisions committed to
743
539
this branch.
540
541
>>> b = ScratchBranch()
542
>>> b.revno()
543
0
544
>>> b.commit('no foo')
545
>>> b.revno()
546
1
744
547
"""
745
548
return len(self.revision_history())
746
549
747
550
748
551
def last_patch(self):
749
552
"""Return last patch hash, or None if no history.
553
554
>>> ScratchBranch().last_patch() == None
555
True
750
556
"""
751
557
ph = self.revision_history()
752
558
if ph:
753
559
return ph[-1]
754
else:
755
return None
756
757
758
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
759
"""
760
If self and other have not diverged, return a list of the revisions
761
present in other, but missing from self.
762
763
>>> from bzrlib.commit import commit
764
>>> bzrlib.trace.silent = True
765
>>> br1 = ScratchBranch()
766
>>> br2 = ScratchBranch()
767
>>> br1.missing_revisions(br2)
768
[]
769
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
770
>>> br1.missing_revisions(br2)
771
[u'REVISION-ID-1']
772
>>> br2.missing_revisions(br1)
773
[]
774
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
775
>>> br1.missing_revisions(br2)
776
[]
777
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
778
>>> br1.missing_revisions(br2)
779
[u'REVISION-ID-2A']
780
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
781
>>> br1.missing_revisions(br2)
782
Traceback (most recent call last):
783
DivergedBranches: These branches have diverged.
784
"""
785
self_history = self.revision_history()
786
self_len = len(self_history)
787
other_history = other.revision_history()
788
other_len = len(other_history)
789
common_index = min(self_len, other_len) -1
790
if common_index >= 0 and \
791
self_history[common_index] != other_history[common_index]:
792
raise DivergedBranches(self, other)
793
794
if stop_revision is None:
795
stop_revision = other_len
796
elif stop_revision > other_len:
797
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
798
799
return other_history[self_len:stop_revision]
800
801
802
def update_revisions(self, other, stop_revision=None):
803
"""Pull in all new revisions from other branch.
804
"""
805
from bzrlib.fetch import greedy_fetch
806
807
pb = bzrlib.ui.ui_factory.progress_bar()
808
pb.update('comparing histories')
809
810
revision_ids = self.missing_revisions(other, stop_revision)
811
812
if len(revision_ids) > 0:
813
count = greedy_fetch(self, other, revision_ids[-1], pb)[0]
814
else:
815
count = 0
816
self.append_revision(*revision_ids)
817
## note("Added %d revisions." % count)
818
pb.clear()
819
820
def install_revisions(self, other, revision_ids, pb):
821
if hasattr(other.revision_store, "prefetch"):
822
other.revision_store.prefetch(revision_ids)
823
if hasattr(other.inventory_store, "prefetch"):
824
inventory_ids = [other.get_revision(r).inventory_id
825
for r in revision_ids]
826
other.inventory_store.prefetch(inventory_ids)
827
828
if pb is None:
829
pb = bzrlib.ui.ui_factory.progress_bar()
830
831
revisions = []
832
needed_texts = set()
833
i = 0
834
835
failures = set()
836
for i, rev_id in enumerate(revision_ids):
837
pb.update('fetching revision', i+1, len(revision_ids))
838
try:
839
rev = other.get_revision(rev_id)
840
except bzrlib.errors.NoSuchRevision:
841
failures.add(rev_id)
842
continue
843
844
revisions.append(rev)
845
inv = other.get_inventory(str(rev.inventory_id))
846
for key, entry in inv.iter_entries():
847
if entry.text_id is None:
848
continue
849
if entry.text_id not in self.text_store:
850
needed_texts.add(entry.text_id)
851
852
pb.clear()
853
854
count, cp_fail = self.text_store.copy_multi(other.text_store,
855
needed_texts)
856
#print "Added %d texts." % count
857
inventory_ids = [ f.inventory_id for f in revisions ]
858
count, cp_fail = self.inventory_store.copy_multi(other.inventory_store,
859
inventory_ids)
860
#print "Added %d inventories." % count
861
revision_ids = [ f.revision_id for f in revisions]
862
863
count, cp_fail = self.revision_store.copy_multi(other.revision_store,
864
revision_ids,
865
permit_failure=True)
866
assert len(cp_fail) == 0
867
return count, failures
868
869
870
def commit(self, *args, **kw):
871
from bzrlib.commit import commit
872
commit(self, *args, **kw)
873
874
875
def lookup_revision(self, revision):
876
"""Return the revision identifier for a given revision information."""
877
revno, info = self._get_revision_info(revision)
878
return info
879
880
881
def revision_id_to_revno(self, revision_id):
882
"""Given a revision id, return its revno"""
883
history = self.revision_history()
884
try:
885
return history.index(revision_id) + 1
886
except ValueError:
887
raise bzrlib.errors.NoSuchRevision(self, revision_id)
888
889
890
def get_revision_info(self, revision):
891
"""Return (revno, revision id) for revision identifier.
892
893
revision can be an integer, in which case it is assumed to be revno (though
894
this will translate negative values into positive ones)
895
revision can also be a string, in which case it is parsed for something like
896
'date:' or 'revid:' etc.
897
"""
898
revno, rev_id = self._get_revision_info(revision)
899
if revno is None:
900
raise bzrlib.errors.NoSuchRevision(self, revision)
901
return revno, rev_id
902
903
def get_rev_id(self, revno, history=None):
904
"""Find the revision id of the specified revno."""
560
561
562
def lookup_revision(self, revno):
563
"""Return revision hash for revision number."""
905
564
if revno == 0:
906
565
return None
907
if history is None:
908
history = self.revision_history()
909
elif revno <= 0 or revno > len(history):
910
raise bzrlib.errors.NoSuchRevision(self, revno)
911
return history[revno - 1]
912
913
def _get_revision_info(self, revision):
914
"""Return (revno, revision id) for revision specifier.
915
916
revision can be an integer, in which case it is assumed to be revno
917
(though this will translate negative values into positive ones)
918
revision can also be a string, in which case it is parsed for something
919
like 'date:' or 'revid:' etc.
920
921
A revid is always returned. If it is None, the specifier referred to
922
the null revision. If the revid does not occur in the revision
923
history, revno will be None.
924
"""
925
926
if revision is None:
927
return 0, None
928
revno = None
929
try:# Convert to int if possible
930
revision = int(revision)
931
except ValueError:
932
pass
933
revs = self.revision_history()
934
if isinstance(revision, int):
935
if revision < 0:
936
revno = len(revs) + revision + 1
937
else:
938
revno = revision
939
rev_id = self.get_rev_id(revno, revs)
940
elif isinstance(revision, basestring):
941
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
942
if revision.startswith(prefix):
943
result = func(self, revs, revision)
944
if len(result) > 1:
945
revno, rev_id = result
946
else:
947
revno = result[0]
948
rev_id = self.get_rev_id(revno, revs)
949
break
950
else:
951
raise BzrError('No namespace registered for string: %r' %
952
revision)
953
else:
954
raise TypeError('Unhandled revision type %s' % revision)
955
956
if revno is None:
957
if rev_id is None:
958
raise bzrlib.errors.NoSuchRevision(self, revision)
959
return revno, rev_id
960
961
def _namespace_revno(self, revs, revision):
962
"""Lookup a revision by revision number"""
963
assert revision.startswith('revno:')
964
try:
965
return (int(revision[6:]),)
966
except ValueError:
967
return None
968
REVISION_NAMESPACES['revno:'] = _namespace_revno
969
970
def _namespace_revid(self, revs, revision):
971
assert revision.startswith('revid:')
972
rev_id = revision[len('revid:'):]
973
try:
974
return revs.index(rev_id) + 1, rev_id
975
except ValueError:
976
return None, rev_id
977
REVISION_NAMESPACES['revid:'] = _namespace_revid
978
979
def _namespace_last(self, revs, revision):
980
assert revision.startswith('last:')
981
try:
982
offset = int(revision[5:])
983
except ValueError:
984
return (None,)
985
else:
986
if offset <= 0:
987
raise BzrError('You must supply a positive value for --revision last:XXX')
988
return (len(revs) - offset + 1,)
989
REVISION_NAMESPACES['last:'] = _namespace_last
990
991
def _namespace_tag(self, revs, revision):
992
assert revision.startswith('tag:')
993
raise BzrError('tag: namespace registered, but not implemented.')
994
REVISION_NAMESPACES['tag:'] = _namespace_tag
995
996
def _namespace_date(self, revs, revision):
997
assert revision.startswith('date:')
998
import datetime
999
# Spec for date revisions:
1000
# date:value
1001
# value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
1002
# it can also start with a '+/-/='. '+' says match the first
1003
# entry after the given date. '-' is match the first entry before the date
1004
# '=' is match the first entry after, but still on the given date.
1005
#
1006
# +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
1007
# -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
1008
# =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
1009
# May 13th, 2005 at 0:00
1010
#
1011
# So the proper way of saying 'give me all entries for today' is:
1012
# -r {date:+today}:{date:-tomorrow}
1013
# The default is '=' when not supplied
1014
val = revision[5:]
1015
match_style = '='
1016
if val[:1] in ('+', '-', '='):
1017
match_style = val[:1]
1018
val = val[1:]
1019
1020
today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
1021
if val.lower() == 'yesterday':
1022
dt = today - datetime.timedelta(days=1)
1023
elif val.lower() == 'today':
1024
dt = today
1025
elif val.lower() == 'tomorrow':
1026
dt = today + datetime.timedelta(days=1)
1027
else:
1028
import re
1029
# This should be done outside the function to avoid recompiling it.
1030
_date_re = re.compile(
1031
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
1032
r'(,|T)?\s*'
1033
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
1034
)
1035
m = _date_re.match(val)
1036
if not m or (not m.group('date') and not m.group('time')):
1037
raise BzrError('Invalid revision date %r' % revision)
1038
1039
if m.group('date'):
1040
year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
1041
else:
1042
year, month, day = today.year, today.month, today.day
1043
if m.group('time'):
1044
hour = int(m.group('hour'))
1045
minute = int(m.group('minute'))
1046
if m.group('second'):
1047
second = int(m.group('second'))
1048
else:
1049
second = 0
1050
else:
1051
hour, minute, second = 0,0,0
1052
1053
dt = datetime.datetime(year=year, month=month, day=day,
1054
hour=hour, minute=minute, second=second)
1055
first = dt
1056
last = None
1057
reversed = False
1058
if match_style == '-':
1059
reversed = True
1060
elif match_style == '=':
1061
last = dt + datetime.timedelta(days=1)
1062
1063
if reversed:
1064
for i in range(len(revs)-1, -1, -1):
1065
r = self.get_revision(revs[i])
1066
# TODO: Handle timezone.
1067
dt = datetime.datetime.fromtimestamp(r.timestamp)
1068
if first >= dt and (last is None or dt >= last):
1069
return (i+1,)
1070
else:
1071
for i in range(len(revs)):
1072
r = self.get_revision(revs[i])
1073
# TODO: Handle timezone.
1074
dt = datetime.datetime.fromtimestamp(r.timestamp)
1075
if first <= dt and (last is None or dt <= last):
1076
return (i+1,)
1077
REVISION_NAMESPACES['date:'] = _namespace_date
566
567
try:
568
# list is 0-based; revisions are 1-based
569
return self.revision_history()[revno-1]
570
except IndexError:
571
bailout("no such revision %s" % revno)
572
1078
573
1079
574
def revision_tree(self, revision_id):
1080
575
"""Return Tree for a revision on this branch.
1081
576
1082
577
`revision_id` may be None for the null revision, in which case
1083
578
an `EmptyTree` is returned."""
1084
# TODO: refactor this to use an existing revision object
1085
# so we don't need to read it in twice.
579
1086
580
if revision_id == None:
1087
581
return EmptyTree()
1088
582
else:
1092
586
1093
587
def working_tree(self):
1094
588
"""Return a `Tree` for the working copy."""
1095
from workingtree import WorkingTree
1096
589
return WorkingTree(self.base, self.read_working_inventory())
1097
590
1098
591
1100
593
"""Return `Tree` object for last revision.
1101
594
1102
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
1103
606
"""
1104
607
r = self.last_patch()
1105
608
if r == None:
1109
612
1110
613
1111
614
1112
def rename_one(self, from_rel, to_rel):
1113
"""Rename one file.
1114
1115
This can change the directory or the filename or both.
1116
"""
1117
self.lock_write()
1118
try:
1119
tree = self.working_tree()
1120
inv = tree.inventory
1121
if not tree.has_filename(from_rel):
1122
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
1123
if tree.has_filename(to_rel):
1124
raise BzrError("can't rename: new working file %r already exists" % to_rel)
1125
1126
file_id = inv.path2id(from_rel)
1127
if file_id == None:
1128
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
1129
1130
if inv.path2id(to_rel):
1131
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
1132
1133
to_dir, to_tail = os.path.split(to_rel)
1134
to_dir_id = inv.path2id(to_dir)
1135
if to_dir_id == None and to_dir != '':
1136
raise BzrError("can't determine destination directory id for %r" % to_dir)
1137
1138
mutter("rename_one:")
1139
mutter(" file_id {%s}" % file_id)
1140
mutter(" from_rel %r" % from_rel)
1141
mutter(" to_rel %r" % to_rel)
1142
mutter(" to_dir %r" % to_dir)
1143
mutter(" to_dir_id {%s}" % to_dir_id)
1144
1145
inv.rename(file_id, to_dir_id, to_tail)
1146
1147
from_abs = self.abspath(from_rel)
1148
to_abs = self.abspath(to_rel)
1149
try:
1150
os.rename(from_abs, to_abs)
1151
except OSError, e:
1152
raise BzrError("failed to rename %r to %r: %s"
1153
% (from_abs, to_abs, e[1]),
1154
["rename rolled back"])
1155
1156
self._write_inventory(inv)
1157
finally:
1158
self.unlock()
1159
1160
1161
def move(self, from_paths, to_name):
1162
"""Rename files.
1163
1164
to_name must exist as a versioned directory.
1165
1166
If to_name exists and is a directory, the files are moved into
1167
it, keeping their old names. If it is a directory,
1168
1169
Note that to_name is only the last component of the new name;
1170
this doesn't change the directory.
1171
1172
This returns a list of (from_path, to_path) pairs for each
1173
entry that is moved.
1174
"""
1175
result = []
1176
self.lock_write()
1177
try:
1178
## TODO: Option to move IDs only
1179
assert not isinstance(from_paths, basestring)
1180
tree = self.working_tree()
1181
inv = tree.inventory
1182
to_abs = self.abspath(to_name)
1183
if not isdir(to_abs):
1184
raise BzrError("destination %r is not a directory" % to_abs)
1185
if not tree.has_filename(to_name):
1186
raise BzrError("destination %r not in working directory" % to_abs)
1187
to_dir_id = inv.path2id(to_name)
1188
if to_dir_id == None and to_name != '':
1189
raise BzrError("destination %r is not a versioned directory" % to_name)
1190
to_dir_ie = inv[to_dir_id]
1191
if to_dir_ie.kind not in ('directory', 'root_directory'):
1192
raise BzrError("destination %r is not a directory" % to_abs)
1193
1194
to_idpath = inv.get_idpath(to_dir_id)
1195
1196
for f in from_paths:
1197
if not tree.has_filename(f):
1198
raise BzrError("%r does not exist in working tree" % f)
1199
f_id = inv.path2id(f)
1200
if f_id == None:
1201
raise BzrError("%r is not versioned" % f)
1202
name_tail = splitpath(f)[-1]
1203
dest_path = appendpath(to_name, name_tail)
1204
if tree.has_filename(dest_path):
1205
raise BzrError("destination %r already exists" % dest_path)
1206
if f_id in to_idpath:
1207
raise BzrError("can't move %r to a subdirectory of itself" % f)
1208
1209
# OK, so there's a race here, it's possible that someone will
1210
# create a file in this interval and then the rename might be
1211
# left half-done. But we should have caught most problems.
1212
1213
for f in from_paths:
1214
name_tail = splitpath(f)[-1]
1215
dest_path = appendpath(to_name, name_tail)
1216
result.append((f, dest_path))
1217
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1218
try:
1219
os.rename(self.abspath(f), self.abspath(dest_path))
1220
except OSError, e:
1221
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1222
["rename rolled back"])
1223
1224
self._write_inventory(inv)
1225
finally:
1226
self.unlock()
1227
1228
return result
1229
1230
1231
def revert(self, filenames, old_tree=None, backups=True):
1232
"""Restore selected files to the versions from a previous tree.
1233
1234
backups
1235
If true (default) backups are made of files before
1236
they're renamed.
1237
"""
1238
from bzrlib.errors import NotVersionedError, BzrError
1239
from bzrlib.atomicfile import AtomicFile
1240
from bzrlib.osutils import backup_file
1241
1242
inv = self.read_working_inventory()
1243
if old_tree is None:
1244
old_tree = self.basis_tree()
1245
old_inv = old_tree.inventory
1246
1247
nids = []
1248
for fn in filenames:
1249
file_id = inv.path2id(fn)
1250
if not file_id:
1251
raise NotVersionedError("not a versioned file", fn)
1252
if not old_inv.has_id(file_id):
1253
raise BzrError("file not present in old tree", fn, file_id)
1254
nids.append((fn, file_id))
1255
1256
# TODO: Rename back if it was previously at a different location
1257
1258
# TODO: If given a directory, restore the entire contents from
1259
# the previous version.
1260
1261
# TODO: Make a backup to a temporary file.
1262
1263
# TODO: If the file previously didn't exist, delete it?
1264
for fn, file_id in nids:
1265
backup_file(fn)
1266
1267
f = AtomicFile(fn, 'wb')
1268
try:
1269
f.write(old_tree.get_file(file_id).read())
1270
f.commit()
1271
finally:
1272
f.close()
1273
1274
1275
def pending_merges(self):
1276
"""Return a list of pending merges.
1277
1278
These are revisions that have been merged into the working
1279
directory but not yet committed.
1280
"""
1281
cfn = self.controlfilename('pending-merges')
1282
if not os.path.exists(cfn):
1283
return []
1284
p = []
1285
for l in self.controlfile('pending-merges', 'r').readlines():
1286
p.append(l.rstrip('\n'))
1287
return p
1288
1289
1290
def add_pending_merge(self, revision_id):
1291
from bzrlib.revision import validate_revision_id
1292
1293
validate_revision_id(revision_id)
1294
1295
p = self.pending_merges()
1296
if revision_id in p:
1297
return
1298
p.append(revision_id)
1299
self.set_pending_merges(p)
1300
1301
1302
def set_pending_merges(self, rev_list):
1303
from bzrlib.atomicfile import AtomicFile
1304
self.lock_write()
1305
try:
1306
f = AtomicFile(self.controlfilename('pending-merges'))
1307
try:
1308
for l in rev_list:
1309
print >>f, l
1310
f.commit()
1311
finally:
1312
f.close()
1313
finally:
1314
self.unlock()
1315
1316
1317
def get_parent(self):
1318
"""Return the parent location of the branch.
1319
1320
This is the default location for push/pull/missing. The usual
1321
pattern is that the user can override it by specifying a
1322
location.
1323
"""
1324
import errno
1325
_locs = ['parent', 'pull', 'x-pull']
1326
for l in _locs:
1327
try:
1328
return self.controlfile(l, 'r').read().strip('\n')
1329
except IOError, e:
1330
if e.errno != errno.ENOENT:
1331
raise
1332
return None
1333
1334
1335
def set_parent(self, url):
1336
# TODO: Maybe delete old location files?
1337
from bzrlib.atomicfile import AtomicFile
1338
self.lock_write()
1339
try:
1340
f = AtomicFile(self.controlfilename('parent'))
1341
try:
1342
f.write(url + '\n')
1343
f.commit()
1344
finally:
1345
f.close()
1346
finally:
1347
self.unlock()
1348
1349
def check_revno(self, revno):
1350
"""\
1351
Check whether a revno corresponds to any revision.
1352
Zero (the NULL revision) is considered valid.
1353
"""
1354
if revno != 0:
1355
self.check_real_revno(revno)
1356
1357
def check_real_revno(self, revno):
1358
"""\
1359
Check whether a revno corresponds to a real revision.
1360
Zero (the NULL revision) is considered invalid
1361
"""
1362
if revno < 1 or revno > self.revno():
1363
raise InvalidRevisionNumber(revno)
1364
1365
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
1366
700
1367
701
1368
702
class ScratchBranch(Branch):
1372
706
>>> isdir(b.base)
1373
707
True
1374
708
>>> bd = b.base
1375
>>> b.destroy()
709
>>> del b
1376
710
>>> isdir(bd)
1377
711
False
1378
712
"""
1379
def __init__(self, files=[], dirs=[], base=None):
713
def __init__(self, files = []):
1380
714
"""Make a test branch.
1381
715
1382
716
This creates a temporary directory and runs init-tree in it.
1383
717
1384
718
If any files are listed, they are created in the working copy.
1385
719
"""
1386
from tempfile import mkdtemp
1387
init = False
1388
if base is None:
1389
base = mkdtemp()
1390
init = True
1391
Branch.__init__(self, base, init=init)
1392
for d in dirs:
1393
os.mkdir(self.abspath(d))
1394
720
Branch.__init__(self, tempfile.mkdtemp(), init=True)
1395
721
for f in files:
1396
722
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
1397
723
1398
724
1399
def clone(self):
1400
"""
1401
>>> orig = ScratchBranch(files=["file1", "file2"])
1402
>>> clone = orig.clone()
1403
>>> os.path.samefile(orig.base, clone.base)
1404
False
1405
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1406
True
1407
"""
1408
from shutil import copytree
1409
from tempfile import mkdtemp
1410
base = mkdtemp()
1411
os.rmdir(base)
1412
copytree(self.base, base, symlinks=True)
1413
return ScratchBranch(base=base)
1414
1415
1416
1417
725
def __del__(self):
1418
self.destroy()
1419
1420
def destroy(self):
1421
726
"""Destroy the test branch, removing the scratch directory."""
1422
from shutil import rmtree
1423
try:
1424
if self.base:
1425
mutter("delete ScratchBranch %s" % self.base)
1426
rmtree(self.base)
1427
except OSError, e:
1428
# Work around for shutil.rmtree failing on Windows when
1429
# readonly files are encountered
1430
mutter("hit exception in destroying ScratchBranch: %s" % e)
1431
for root, dirs, files in os.walk(self.base, topdown=False):
1432
for name in files:
1433
os.chmod(os.path.join(root, name), 0700)
1434
rmtree(self.base)
1435
self.base = None
727
shutil.rmtree(self.base)
1436
728
1437
729
1438
730
1448
740
## mutter('check %r for control file' % ((head, tail), ))
1449
741
if tail == bzrlib.BZRDIR:
1450
742
return True
1451
if filename == head:
1452
break
1453
743
filename = head
1454
744
return False
1455
745
1456
746
1457
747
1458
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):
1459
756
"""Return new file id.
1460
757
1461
758
This should probably generate proper UUIDs, but for the moment we
1462
759
cope with just randomness because running uuidgen every time is
1463
760
slow."""
1464
import re
1465
from binascii import hexlify
1466
from time import time
1467
1468
# get last component
1469
idx = name.rfind('/')
1470
if idx != -1:
1471
name = name[idx+1 : ]
1472
idx = name.rfind('\\')
1473
if idx != -1:
1474
name = name[idx+1 : ]
1475
1476
# make it not a hidden file
1477
name = name.lstrip('.')
1478
1479
# remove any wierd characters; we don't escape them but rather
1480
# just pull them out
1481
name = re.sub(r'[^\w.]', '', name)
1482
761
assert '/' not in name
762
while name[0] == '.':
763
name = name[1:]
1483
764
s = hexlify(rand_bytes(8))
1484
return '-'.join((name, compact_date(time()), s))
1485
1486
1487
def gen_root_id():
1488
"""Return a new tree-root file id."""
1489
return gen_file_id('TREE_ROOT')
1490
1491
1492
def pull_loc(branch):
1493
# TODO: Should perhaps just make attribute be 'base' in
1494
# RemoteBranch and Branch?
1495
if hasattr(branch, "baseurl"):
1496
return branch.baseurl
1497
else:
1498
return branch.base
1499
1500
1501
def copy_branch(branch_from, to_location, revision=None):
1502
"""Copy branch_from into the existing directory to_location.
1503
1504
revision
1505
If not None, only revisions up to this point will be copied.
1506
The head of the new branch will be that revision.
1507
1508
to_location
1509
The name of a local directory that exists but is empty.
1510
"""
1511
from bzrlib.merge import merge
1512
from bzrlib.branch import Branch
1513
1514
assert isinstance(branch_from, Branch)
1515
assert isinstance(to_location, basestring)
1516
1517
br_to = Branch(to_location, init=True)
1518
br_to.set_root_id(branch_from.get_root_id())
1519
if revision is None:
1520
revno = branch_from.revno()
1521
else:
1522
revno, rev_id = branch_from.get_revision_info(revision)
1523
br_to.update_revisions(branch_from, stop_revision=revno)
1524
merge((to_location, -1), (to_location, 0), this_dir=to_location,
1525
check_clean=False, ignore_zero=True)
1526
1527
from_location = pull_loc(branch_from)
1528
br_to.set_parent(pull_loc(branch_from))
765
return '-'.join((name, compact_date(time.time()), s))
766
767
Loggerhead is a web-based interface for Breezy
Version: 2.0.1