← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

Adding sha1 check when weave extracts a text.

Show diffs side-by-side

added added

removed removed

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