← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

Merge from mpool.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/branch.py
50
50
from bzrlib.transport import Transport, get_transport
51
51
import bzrlib.xml5
52
52
import bzrlib.ui
 
53
from config import TreeConfig
53
54
 
54
55
 
55
56
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
109
110
        """Open a branch which may be of an old format.
110
111
        
111
112
        Only local branches are supported."""
112
 
        return _Branch(get_transport(base), relax_version_check=True)
 
113
        return BzrBranch(get_transport(base), relax_version_check=True)
113
114
        
114
115
    @staticmethod
115
116
    def open(base):
116
117
        """Open an existing branch, rooted at 'base' (url)"""
117
118
        t = get_transport(base)
118
119
        mutter("trying to open %r with transport %r", base, t)
119
 
        return _Branch(t)
 
120
        return BzrBranch(t)
120
121
 
121
122
    @staticmethod
122
123
    def open_containing(url):
131
132
        t = get_transport(url)
132
133
        while True:
133
134
            try:
134
 
                return _Branch(t), t.relpath(url)
 
135
                return BzrBranch(t), t.relpath(url)
135
136
            except NotBranchError:
136
137
                pass
137
138
            new_t = t.clone('..')
144
145
    def initialize(base):
145
146
        """Create a new branch, rooted at 'base' (url)"""
146
147
        t = get_transport(base)
147
 
        return _Branch(t, init=True)
 
148
        return BzrBranch(t, init=True)
148
149
 
149
150
    def setup_caching(self, cache_root):
150
151
        """Subclasses that care about caching should override this, and set
152
153
        """
153
154
        self.cache_root = cache_root
154
155
 
155
 
 
156
 
class _Branch(Branch):
 
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 print_file(self, file, revno):
 
237
        """Print `file` to stdout."""
 
238
        raise NotImplementedError('print_file is abstract')
 
239
 
 
240
    def append_revision(self, *revision_ids):
 
241
        raise NotImplementedError('append_revision is abstract')
 
242
 
 
243
    def set_revision_history(self, rev_history):
 
244
        raise NotImplementedError('set_revision_history is abstract')
 
245
 
 
246
    def has_revision(self, revision_id):
 
247
        """True if this branch has a copy of the revision.
 
248
 
 
249
        This does not necessarily imply the revision is merge
 
250
        or on the mainline."""
 
251
        raise NotImplementedError('has_revision is abstract')
 
252
 
 
253
    def get_revision_xml_file(self, revision_id):
 
254
        """Return XML file object for revision object."""
 
255
        raise NotImplementedError('get_revision_xml_file is abstract')
 
256
 
 
257
    def get_revision_xml(self, revision_id):
 
258
        raise NotImplementedError('get_revision_xml is abstract')
 
259
 
 
260
    def get_revision(self, revision_id):
 
261
        """Return the Revision object for a named revision"""
 
262
        raise NotImplementedError('get_revision is abstract')
 
263
 
 
264
    def get_revision_delta(self, revno):
 
265
        """Return the delta for one revision.
 
266
 
 
267
        The delta is relative to its mainline predecessor, or the
 
268
        empty tree for revision 1.
 
269
        """
 
270
        assert isinstance(revno, int)
 
271
        rh = self.revision_history()
 
272
        if not (1 <= revno <= len(rh)):
 
273
            raise InvalidRevisionNumber(revno)
 
274
 
 
275
        # revno is 1-based; list is 0-based
 
276
 
 
277
        new_tree = self.revision_tree(rh[revno-1])
 
278
        if revno == 1:
 
279
            old_tree = EmptyTree()
 
280
        else:
 
281
            old_tree = self.revision_tree(rh[revno-2])
 
282
 
 
283
        return compare_trees(old_tree, new_tree)
 
284
 
 
285
    def get_revision_sha1(self, revision_id):
 
286
        """Hash the stored value of a revision, and return it."""
 
287
        raise NotImplementedError('get_revision_sha1 is abstract')
 
288
 
 
289
    def get_ancestry(self, revision_id):
 
290
        """Return a list of revision-ids integrated by a revision.
 
291
        
 
292
        This currently returns a list, but the ordering is not guaranteed:
 
293
        treat it as a set.
 
294
        """
 
295
        raise NotImplementedError('get_ancestry is abstract')
 
296
 
 
297
    def get_inventory(self, revision_id):
 
298
        """Get Inventory object by hash."""
 
299
        raise NotImplementedError('get_inventory is abstract')
 
300
 
 
301
    def get_inventory_xml(self, revision_id):
 
302
        """Get inventory XML as a file object."""
 
303
        raise NotImplementedError('get_inventory_xml is abstract')
 
304
 
 
305
    def get_inventory_sha1(self, revision_id):
 
306
        """Return the sha1 hash of the inventory entry."""
 
307
        raise NotImplementedError('get_inventory_sha1 is abstract')
 
308
 
 
309
    def get_revision_inventory(self, revision_id):
 
310
        """Return inventory of a past revision."""
 
311
        raise NotImplementedError('get_revision_inventory is abstract')
 
312
 
 
313
    def revision_history(self):
 
314
        """Return sequence of revision hashes on to this branch."""
 
315
        raise NotImplementedError('revision_history is abstract')
 
316
 
 
317
    def revno(self):
 
318
        """Return current revision number for this branch.
 
319
 
 
320
        That is equivalent to the number of revisions committed to
 
321
        this branch.
 
322
        """
 
323
        return len(self.revision_history())
 
324
 
 
325
    def last_revision(self):
 
326
        """Return last patch hash, or None if no history."""
 
327
        ph = self.revision_history()
 
328
        if ph:
 
329
            return ph[-1]
 
330
        else:
 
331
            return None
 
332
 
 
333
    def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
 
334
        """Return a list of new revisions that would perfectly fit.
 
335
        
 
336
        If self and other have not diverged, return a list of the revisions
 
337
        present in other, but missing from self.
 
338
 
 
339
        >>> from bzrlib.commit import commit
 
340
        >>> bzrlib.trace.silent = True
 
341
        >>> br1 = ScratchBranch()
 
342
        >>> br2 = ScratchBranch()
 
343
        >>> br1.missing_revisions(br2)
 
344
        []
 
345
        >>> commit(br2, "lala!", rev_id="REVISION-ID-1")
 
346
        >>> br1.missing_revisions(br2)
 
347
        [u'REVISION-ID-1']
 
348
        >>> br2.missing_revisions(br1)
 
349
        []
 
350
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1")
 
351
        >>> br1.missing_revisions(br2)
 
352
        []
 
353
        >>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
 
354
        >>> br1.missing_revisions(br2)
 
355
        [u'REVISION-ID-2A']
 
356
        >>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
 
357
        >>> br1.missing_revisions(br2)
 
358
        Traceback (most recent call last):
 
359
        DivergedBranches: These branches have diverged.
 
360
        """
 
361
        self_history = self.revision_history()
 
362
        self_len = len(self_history)
 
363
        other_history = other.revision_history()
 
364
        other_len = len(other_history)
 
365
        common_index = min(self_len, other_len) -1
 
366
        if common_index >= 0 and \
 
367
            self_history[common_index] != other_history[common_index]:
 
368
            raise DivergedBranches(self, other)
 
369
 
 
370
        if stop_revision is None:
 
371
            stop_revision = other_len
 
372
        else:
 
373
            assert isinstance(stop_revision, int)
 
374
            if stop_revision > other_len:
 
375
                raise bzrlib.errors.NoSuchRevision(self, stop_revision)
 
376
        return other_history[self_len:stop_revision]
 
377
    
 
378
    def update_revisions(self, other, stop_revision=None):
 
379
        """Pull in new perfect-fit revisions."""
 
380
        raise NotImplementedError('update_revisions is abstract')
 
381
 
 
382
    def pullable_revisions(self, other, stop_revision):
 
383
        raise NotImplementedError('pullable_revisions is abstract')
 
384
        
 
385
    def revision_id_to_revno(self, revision_id):
 
386
        """Given a revision id, return its revno"""
 
387
        if revision_id is None:
 
388
            return 0
 
389
        history = self.revision_history()
 
390
        try:
 
391
            return history.index(revision_id) + 1
 
392
        except ValueError:
 
393
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
 
394
 
 
395
    def get_rev_id(self, revno, history=None):
 
396
        """Find the revision id of the specified revno."""
 
397
        if revno == 0:
 
398
            return None
 
399
        if history is None:
 
400
            history = self.revision_history()
 
401
        elif revno <= 0 or revno > len(history):
 
402
            raise bzrlib.errors.NoSuchRevision(self, revno)
 
403
        return history[revno - 1]
 
404
 
 
405
    def revision_tree(self, revision_id):
 
406
        """Return Tree for a revision on this branch.
 
407
 
 
408
        `revision_id` may be None for the null revision, in which case
 
409
        an `EmptyTree` is returned."""
 
410
        raise NotImplementedError('revision_tree is abstract')
 
411
 
 
412
    def working_tree(self):
 
413
        """Return a `Tree` for the working copy if this is a local branch."""
 
414
        raise NotImplementedError('working_tree is abstract')
 
415
 
 
416
    def pull(self, source, overwrite=False):
 
417
        raise NotImplementedError('pull is abstract')
 
418
 
 
419
    def basis_tree(self):
 
420
        """Return `Tree` object for last revision.
 
421
 
 
422
        If there are no revisions yet, return an `EmptyTree`.
 
423
        """
 
424
        return self.revision_tree(self.last_revision())
 
425
 
 
426
    def rename_one(self, from_rel, to_rel):
 
427
        """Rename one file.
 
428
 
 
429
        This can change the directory or the filename or both.
 
430
        """
 
431
        raise NotImplementedError('rename_one is abstract')
 
432
 
 
433
    def move(self, from_paths, to_name):
 
434
        """Rename files.
 
435
 
 
436
        to_name must exist as a versioned directory.
 
437
 
 
438
        If to_name exists and is a directory, the files are moved into
 
439
        it, keeping their old names.  If it is a directory, 
 
440
 
 
441
        Note that to_name is only the last component of the new name;
 
442
        this doesn't change the directory.
 
443
 
 
444
        This returns a list of (from_path, to_path) pairs for each
 
445
        entry that is moved.
 
446
        """
 
447
        raise NotImplementedError('move is abstract')
 
448
 
 
449
    def revert(self, filenames, old_tree=None, backups=True):
 
450
        """Restore selected files to the versions from a previous tree.
 
451
 
 
452
        backups
 
453
            If true (default) backups are made of files before
 
454
            they're renamed.
 
455
        """
 
456
        raise NotImplementedError('revert is abstract')
 
457
 
 
458
    def pending_merges(self):
 
459
        """Return a list of pending merges.
 
460
 
 
461
        These are revisions that have been merged into the working
 
462
        directory but not yet committed.
 
463
        """
 
464
        raise NotImplementedError('pending_merges is abstract')
 
465
 
 
466
    def add_pending_merge(self, *revision_ids):
 
467
        # TODO: Perhaps should check at this point that the
 
468
        # history of the revision is actually present?
 
469
        raise NotImplementedError('add_pending_merge is abstract')
 
470
 
 
471
    def set_pending_merges(self, rev_list):
 
472
        raise NotImplementedError('set_pending_merges is abstract')
 
473
 
 
474
    def get_parent(self):
 
475
        """Return the parent location of the branch.
 
476
 
 
477
        This is the default location for push/pull/missing.  The usual
 
478
        pattern is that the user can override it by specifying a
 
479
        location.
 
480
        """
 
481
        raise NotImplementedError('get_parent is abstract')
 
482
 
 
483
    def get_push_location(self):
 
484
        """Return the None or the location to push this branch to."""
 
485
        raise NotImplementedError('get_push_location is abstract')
 
486
 
 
487
    def set_push_location(self, location):
 
488
        """Set a new push location for this branch."""
 
489
        raise NotImplementedError('set_push_location is abstract')
 
490
 
 
491
    def set_parent(self, url):
 
492
        raise NotImplementedError('set_parent is abstract')
 
493
 
 
494
    def check_revno(self, revno):
 
495
        """\
 
496
        Check whether a revno corresponds to any revision.
 
497
        Zero (the NULL revision) is considered valid.
 
498
        """
 
499
        if revno != 0:
 
500
            self.check_real_revno(revno)
 
501
            
 
502
    def check_real_revno(self, revno):
 
503
        """\
 
504
        Check whether a revno corresponds to a real revision.
 
505
        Zero (the NULL revision) is considered invalid
 
506
        """
 
507
        if revno < 1 or revno > self.revno():
 
508
            raise InvalidRevisionNumber(revno)
 
509
        
 
510
    def sign_revision(self, revision_id, gpg_strategy):
 
511
        raise NotImplementedError('sign_revision is abstract')
 
512
 
 
513
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
 
514
        raise NotImplementedError('store_revision_signature is abstract')
 
515
 
 
516
class BzrBranch(Branch):
157
517
    """A branch stored in the actual filesystem.
158
518
 
159
519
    Note that it's "local" in the context of the filesystem; it doesn't
185
545
    REVISION_NAMESPACES = {}
186
546
 
187
547
    def push_stores(self, branch_to):
188
 
        """Copy the content of this branches store to branch_to."""
 
548
        """See Branch.push_stores."""
189
549
        if (self._branch_format != branch_to._branch_format
190
550
            or self._branch_format != 4):
191
551
            from bzrlib.fetch import greedy_fetch
308
668
        transaction.finish()
309
669
 
310
670
    def get_transaction(self):
311
 
        """Return the current active transaction.
312
 
 
313
 
        If no transaction is active, this returns a passthrough object
314
 
        for which all data is immediately flushed and no caching happens.
315
 
        """
 
671
        """See Branch.get_transaction."""
316
672
        if self._transaction is None:
317
673
            return transactions.PassThroughTransaction()
318
674
        else:
370
726
            self._lock_mode = self._lock_count = None
371
727
 
372
728
    def abspath(self, name):
373
 
        """Return absolute filename for something in the branch
374
 
        
375
 
        XXX: Robert Collins 20051017 what is this used for? why is it a branch
376
 
        method and not a tree method.
377
 
        """
 
729
        """See Branch.abspath."""
378
730
        return self._transport.abspath(name)
379
731
 
380
732
    def _rel_controlfilename(self, file_or_path):
385
737
        return bzrlib.transport.urlescape(bzrlib.BZRDIR + '/' + file_or_path)
386
738
 
387
739
    def controlfilename(self, file_or_path):
388
 
        """Return location relative to branch."""
 
740
        """See Branch.controlfilename."""
389
741
        return self._transport.abspath(self._rel_controlfilename(file_or_path))
390
742
 
391
743
    def controlfile(self, file_or_path, mode='r'):
392
 
        """Open a control file for this branch.
393
 
 
394
 
        There are two classes of file in the control directory: text
395
 
        and binary.  binary files are untranslated byte streams.  Text
396
 
        control files are stored with Unix newlines and in UTF-8, even
397
 
        if the platform or locale defaults are different.
398
 
 
399
 
        Controlfiles should almost never be opened in write mode but
400
 
        rather should be atomically copied and replaced using atomicfile.
401
 
        """
 
744
        """See Branch.controlfile."""
402
745
        import codecs
403
746
 
404
747
        relpath = self._rel_controlfilename(file_or_path)
420
763
            raise BzrError("invalid controlfile mode %r" % mode)
421
764
 
422
765
    def put_controlfile(self, path, f, encode=True):
423
 
        """Write an entry as a controlfile.
424
 
 
425
 
        :param path: The path to put the file, relative to the .bzr control
426
 
                     directory
427
 
        :param f: A file-like or string object whose contents should be copied.
428
 
        :param encode:  If true, encode the contents as utf-8
429
 
        """
 
766
        """See Branch.put_controlfile."""
430
767
        self.put_controlfiles([(path, f)], encode=encode)
431
768
 
432
769
    def put_controlfiles(self, files, encode=True):
433
 
        """Write several entries as controlfiles.
434
 
 
435
 
        :param files: A list of [(path, file)] pairs, where the path is the directory
436
 
                      underneath the bzr control directory
437
 
        :param encode:  If true, encode the contents as utf-8
438
 
        """
 
770
        """See Branch.put_controlfiles."""
439
771
        import codecs
440
772
        ctrl_files = []
441
773
        for path, f in files:
511
843
                            'or remove the .bzr directory'
512
844
                            ' and "bzr init" again'])
513
845
 
 
846
    @needs_read_lock
514
847
    def get_root_id(self):
515
 
        """Return the id of this branches root"""
 
848
        """See Branch.get_root_id."""
516
849
        inv = self.get_inventory(self.last_revision())
517
850
        return inv.root.file_id
518
851
 
519
852
    @needs_read_lock
520
853
    def print_file(self, file, revno):
521
 
        """Print `file` to stdout."""
 
854
        """See Branch.print_file."""
522
855
        tree = self.revision_tree(self.get_rev_id(revno))
523
856
        # use inventory as it was in that revision
524
857
        file_id = tree.inventory.path2id(file)
528
861
 
529
862
    @needs_write_lock
530
863
    def append_revision(self, *revision_ids):
 
864
        """See Branch.append_revision."""
531
865
        for revision_id in revision_ids:
532
866
            mutter("add {%s} to revision-history" % revision_id)
533
867
        rev_history = self.revision_history()
536
870
 
537
871
    @needs_write_lock
538
872
    def set_revision_history(self, rev_history):
 
873
        """See Branch.set_revision_history."""
539
874
        self.put_controlfile('revision-history', '\n'.join(rev_history))
540
875
 
541
876
    def has_revision(self, revision_id):
542
 
        """True if this branch has a copy of the revision.
543
 
 
544
 
        This does not necessarily imply the revision is merge
545
 
        or on the mainline."""
 
877
        """See Branch.has_revision."""
546
878
        return (revision_id is None
547
879
                or self.revision_store.has_id(revision_id))
548
880
 
549
881
    @needs_read_lock
550
882
    def get_revision_xml_file(self, revision_id):
551
 
        """Return XML file object for revision object."""
 
883
        """See Branch.get_revision_xml_file."""
552
884
        if not revision_id or not isinstance(revision_id, basestring):
553
885
            raise InvalidRevisionId(revision_id=revision_id, branch=self)
554
886
        try:
560
892
    get_revision_xml = get_revision_xml_file
561
893
 
562
894
    def get_revision_xml(self, revision_id):
 
895
        """See Branch.get_revision_xml."""
563
896
        return self.get_revision_xml_file(revision_id).read()
564
897
 
565
898
 
566
899
    def get_revision(self, revision_id):
567
 
        """Return the Revision object for a named revision"""
 
900
        """See Branch.get_revision."""
568
901
        xml_file = self.get_revision_xml_file(revision_id)
569
902
 
570
903
        try:
577
910
        assert r.revision_id == revision_id
578
911
        return r
579
912
 
580
 
    def get_revision_delta(self, revno):
581
 
        """Return the delta for one revision.
582
 
 
583
 
        The delta is relative to its mainline predecessor, or the
584
 
        empty tree for revision 1.
585
 
        """
586
 
        assert isinstance(revno, int)
587
 
        rh = self.revision_history()
588
 
        if not (1 <= revno <= len(rh)):
589
 
            raise InvalidRevisionNumber(revno)
590
 
 
591
 
        # revno is 1-based; list is 0-based
592
 
 
593
 
        new_tree = self.revision_tree(rh[revno-1])
594
 
        if revno == 1:
595
 
            old_tree = EmptyTree()
596
 
        else:
597
 
            old_tree = self.revision_tree(rh[revno-2])
598
 
 
599
 
        return compare_trees(old_tree, new_tree)
600
 
 
601
913
    def get_revision_sha1(self, revision_id):
602
 
        """Hash the stored value of a revision, and return it."""
 
914
        """See Branch.get_revision_sha1."""
603
915
        # In the future, revision entries will be signed. At that
604
916
        # point, it is probably best *not* to include the signature
605
917
        # in the revision hash. Because that lets you re-sign
609
921
        return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
610
922
 
611
923
    def get_ancestry(self, revision_id):
612
 
        """Return a list of revision-ids integrated by a revision.
613
 
        
614
 
        This currently returns a list, but the ordering is not guaranteed:
615
 
        treat it as a set.
616
 
        """
 
924
        """See Branch.get_ancestry."""
617
925
        if revision_id is None:
618
926
            return [None]
619
 
        w = self.get_inventory_weave()
 
927
        w = self._get_inventory_weave()
620
928
        return [None] + map(w.idx_to_name,
621
929
                            w.inclusions([w.lookup(revision_id)]))
622
930
 
623
 
    def get_inventory_weave(self):
 
931
    def _get_inventory_weave(self):
624
932
        return self.control_weaves.get_weave('inventory',
625
933
                                             self.get_transaction())
626
934
 
627
935
    def get_inventory(self, revision_id):
628
 
        """Get Inventory object by hash."""
 
936
        """See Branch.get_inventory."""
629
937
        xml = self.get_inventory_xml(revision_id)
630
938
        return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
631
939
 
632
940
    def get_inventory_xml(self, revision_id):
633
 
        """Get inventory XML as a file object."""
 
941
        """See Branch.get_inventory_xml."""
634
942
        try:
635
943
            assert isinstance(revision_id, basestring), type(revision_id)
636
 
            iw = self.get_inventory_weave()
 
944
            iw = self._get_inventory_weave()
637
945
            return iw.get_text(iw.lookup(revision_id))
638
946
        except IndexError:
639
947
            raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
640
948
 
641
949
    def get_inventory_sha1(self, revision_id):
642
 
        """Return the sha1 hash of the inventory entry
643
 
        """
 
950
        """See Branch.get_inventory_sha1."""
644
951
        return self.get_revision(revision_id).inventory_sha1
645
952
 
646
953
    def get_revision_inventory(self, revision_id):
647
 
        """Return inventory of a past revision."""
 
954
        """See Branch.get_revision_inventory."""
648
955
        # TODO: Unify this with get_inventory()
649
956
        # bzr 0.0.6 and later imposes the constraint that the inventory_id
650
957
        # must be the same as its revision, so this is trivial.
660
967
 
661
968
    @needs_read_lock
662
969
    def revision_history(self):
663
 
        """Return sequence of revision hashes on to this branch."""
 
970
        """See Branch.revision_history."""
664
971
        transaction = self.get_transaction()
665
972
        history = transaction.map.find_revision_history()
666
973
        if history is not None:
674
981
        # transaction.register_clean(history, precious=True)
675
982
        return list(history)
676
983
 
677
 
    def revno(self):
678
 
        """Return current revision number for this branch.
679
 
 
680
 
        That is equivalent to the number of revisions committed to
681
 
        this branch.
682
 
        """
683
 
        return len(self.revision_history())
684
 
 
685
 
    def last_revision(self):
686
 
        """Return last patch hash, or None if no history.
687
 
        """
688
 
        ph = self.revision_history()
689
 
        if ph:
690
 
            return ph[-1]
691
 
        else:
692
 
            return None
693
 
 
694
 
    def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
695
 
        """Return a list of new revisions that would perfectly fit.
696
 
        
697
 
        If self and other have not diverged, return a list of the revisions
698
 
        present in other, but missing from self.
699
 
 
700
 
        >>> from bzrlib.commit import commit
701
 
        >>> bzrlib.trace.silent = True
702
 
        >>> br1 = ScratchBranch()
703
 
        >>> br2 = ScratchBranch()
704
 
        >>> br1.missing_revisions(br2)
705
 
        []
706
 
        >>> commit(br2, "lala!", rev_id="REVISION-ID-1")
707
 
        >>> br1.missing_revisions(br2)
708
 
        [u'REVISION-ID-1']
709
 
        >>> br2.missing_revisions(br1)
710
 
        []
711
 
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1")
712
 
        >>> br1.missing_revisions(br2)
713
 
        []
714
 
        >>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
715
 
        >>> br1.missing_revisions(br2)
716
 
        [u'REVISION-ID-2A']
717
 
        >>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
718
 
        >>> br1.missing_revisions(br2)
719
 
        Traceback (most recent call last):
720
 
        DivergedBranches: These branches have diverged.
721
 
        """
722
 
        self_history = self.revision_history()
723
 
        self_len = len(self_history)
724
 
        other_history = other.revision_history()
725
 
        other_len = len(other_history)
726
 
        common_index = min(self_len, other_len) -1
727
 
        if common_index >= 0 and \
728
 
            self_history[common_index] != other_history[common_index]:
729
 
            raise DivergedBranches(self, other)
730
 
 
731
 
        if stop_revision is None:
732
 
            stop_revision = other_len
733
 
        else:
734
 
            assert isinstance(stop_revision, int)
735
 
            if stop_revision > other_len:
736
 
                raise bzrlib.errors.NoSuchRevision(self, stop_revision)
737
 
        return other_history[self_len:stop_revision]
738
 
 
739
984
    def update_revisions(self, other, stop_revision=None):
740
 
        """Pull in new perfect-fit revisions."""
 
985
        """See Branch.update_revisions."""
741
986
        from bzrlib.fetch import greedy_fetch
742
987
        if stop_revision is None:
743
988
            stop_revision = other.last_revision()
752
997
            self.append_revision(*pullable_revs)
753
998
 
754
999
    def pullable_revisions(self, other, stop_revision):
 
1000
        """See Branch.pullable_revisions."""
755
1001
        other_revno = other.revision_id_to_revno(stop_revision)
756
1002
        try:
757
1003
            return self.missing_revisions(other, other_revno)
788
1034
        return history[revno - 1]
789
1035
 
790
1036
    def revision_tree(self, revision_id):
791
 
        """Return Tree for a revision on this branch.
792
 
 
793
 
        `revision_id` may be None for the null revision, in which case
794
 
        an `EmptyTree` is returned."""
 
1037
        """See Branch.revision_tree."""
795
1038
        # TODO: refactor this to use an existing revision object
796
1039
        # so we don't need to read it in twice.
797
1040
        if revision_id == None or revision_id == NULL_REVISION:
801
1044
            return RevisionTree(self.weave_store, inv, revision_id)
802
1045
 
803
1046
    def working_tree(self):
804
 
        """Return a `Tree` for the working copy if this is a local branch."""
 
1047
        """See Branch.working_tree."""
805
1048
        from bzrlib.workingtree import WorkingTree
806
1049
        if self._transport.base.find('://') != -1:
807
1050
            raise NoWorkingTree(self.base)
809
1052
 
810
1053
    @needs_write_lock
811
1054
    def pull(self, source, overwrite=False):
 
1055
        """See Branch.pull."""
812
1056
        source.lock_read()
813
1057
        try:
814
1058
            try:
820
1064
        finally:
821
1065
            source.unlock()
822
1066
 
823
 
    def basis_tree(self):
824
 
        """Return `Tree` object for last revision.
825
 
 
826
 
        If there are no revisions yet, return an `EmptyTree`.
827
 
        """
828
 
        return self.revision_tree(self.last_revision())
829
 
 
830
1067
    def get_parent(self):
831
 
        """Return the parent location of the branch.
832
 
 
833
 
        This is the default location for push/pull/missing.  The usual
834
 
        pattern is that the user can override it by specifying a
835
 
        location.
836
 
        """
 
1068
        """See Branch.get_parent."""
837
1069
        import errno
838
1070
        _locs = ['parent', 'pull', 'x-pull']
839
1071
        for l in _locs:
845
1077
        return None
846
1078
 
847
1079
    def get_push_location(self):
848
 
        """Return the None or the location to push this branch to."""
 
1080
        """See Branch.get_push_location."""
849
1081
        config = bzrlib.config.BranchConfig(self)
850
1082
        push_loc = config.get_user_option('push_location')
851
1083
        return push_loc
852
1084
 
853
1085
    def set_push_location(self, location):
854
 
        """Set a new push location for this branch."""
 
1086
        """See Branch.set_push_location."""
855
1087
        config = bzrlib.config.LocationConfig(self.base)
856
1088
        config.set_user_option('push_location', location)
857
1089
 
858
1090
    @needs_write_lock
859
1091
    def set_parent(self, url):
 
1092
        """See Branch.set_parent."""
860
1093
        # TODO: Maybe delete old location files?
861
1094
        from bzrlib.atomicfile import AtomicFile
862
1095
        f = AtomicFile(self.controlfilename('parent'))
866
1099
        finally:
867
1100
            f.close()
868
1101
 
 
1102
    def tree_config(self):
 
1103
        return TreeConfig(self)
 
1104
 
869
1105
    def check_revno(self, revno):
870
1106
        """\
871
1107
        Check whether a revno corresponds to any revision.
883
1119
            raise InvalidRevisionNumber(revno)
884
1120
        
885
1121
    def sign_revision(self, revision_id, gpg_strategy):
 
1122
        """See Branch.sign_revision."""
886
1123
        plaintext = Testament.from_revision(self, revision_id).as_short_text()
887
1124
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
888
1125
 
889
1126
    @needs_write_lock
890
1127
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
 
1128
        """See Branch.store_revision_signature."""
891
1129
        self.revision_store.add(StringIO(gpg_strategy.sign(plaintext)), 
892
1130
                                revision_id, "sig")
893
1131
 
894
1132
 
895
 
class ScratchBranch(_Branch):
 
1133
class ScratchBranch(BzrBranch):
896
1134
    """Special test class: a branch that cleans up after itself.
897
1135
 
898
1136
    >>> b = ScratchBranch()