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