← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

[merge] John, sftp and others

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