~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Wouter van Heyst
  • Date: 2006-06-07 16:05:27 UTC
  • mto: This revision was merged to the branch mainline in revision 1752.
  • Revision ID: larstiq@larstiq.dyndns.org-20060607160527-2b3649154d0e2e84
more code cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
 
18
from copy import deepcopy
18
19
from cStringIO import StringIO
19
 
 
20
 
from bzrlib.lazy_import import lazy_import
21
 
lazy_import(globals(), """
 
20
import errno
 
21
import os
 
22
import shutil
 
23
import sys
 
24
from unittest import TestSuite
22
25
from warnings import warn
23
26
 
24
27
import bzrlib
25
 
from bzrlib import (
26
 
        bzrdir,
27
 
        cache_utf8,
28
 
        config as _mod_config,
29
 
        errors,
30
 
        lockdir,
31
 
        lockable_files,
32
 
        osutils,
33
 
        revision as _mod_revision,
34
 
        transport,
35
 
        tree,
36
 
        tsort,
37
 
        ui,
38
 
        urlutils,
39
 
        )
40
 
from bzrlib.config import BranchConfig, TreeConfig
 
28
import bzrlib.bzrdir as bzrdir
 
29
from bzrlib.config import TreeConfig
 
30
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
31
from bzrlib.delta import compare_trees
 
32
import bzrlib.errors as errors
 
33
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
 
34
                           NoSuchRevision, HistoryMissing, NotBranchError,
 
35
                           DivergedBranches, LockError,
 
36
                           UninitializableFormat,
 
37
                           UnlistableStore,
 
38
                           UnlistableBranch, NoSuchFile, NotVersionedError,
 
39
                           NoWorkingTree)
 
40
import bzrlib.inventory as inventory
 
41
from bzrlib.inventory import Inventory
41
42
from bzrlib.lockable_files import LockableFiles, TransportLock
42
 
from bzrlib.tag import (
43
 
    BasicTags,
44
 
    DisabledTags,
45
 
    )
46
 
""")
47
 
 
48
 
from bzrlib.decorators import needs_read_lock, needs_write_lock
49
 
from bzrlib.errors import (BzrError, BzrCheckError, DivergedBranches,
50
 
                           HistoryMissing, InvalidRevisionId,
51
 
                           InvalidRevisionNumber, LockError, NoSuchFile,
52
 
                           NoSuchRevision, NoWorkingTree, NotVersionedError,
53
 
                           NotBranchError, UninitializableFormat,
54
 
                           UnlistableStore, UnlistableBranch,
55
 
                           )
56
 
from bzrlib.hooks import Hooks
57
 
from bzrlib.symbol_versioning import (deprecated_function,
58
 
                                      deprecated_method,
59
 
                                      DEPRECATED_PARAMETER,
60
 
                                      deprecated_passed,
61
 
                                      zero_eight, zero_nine, zero_sixteen,
62
 
                                      )
 
43
from bzrlib.lockdir import LockDir
 
44
from bzrlib.osutils import (isdir, quotefn,
 
45
                            rename, splitpath, sha_file,
 
46
                            file_kind, abspath, normpath, pathjoin,
 
47
                            safe_unicode,
 
48
                            rmtree,
 
49
                            )
 
50
from bzrlib.repository import Repository
 
51
from bzrlib.revision import (
 
52
                             is_ancestor,
 
53
                             NULL_REVISION,
 
54
                             Revision,
 
55
                             )
 
56
from bzrlib.store import copy_all
 
57
from bzrlib.symbol_versioning import *
 
58
from bzrlib.textui import show_status
63
59
from bzrlib.trace import mutter, note
 
60
import bzrlib.transactions as transactions
 
61
from bzrlib.transport import Transport, get_transport
 
62
from bzrlib.tree import EmptyTree, RevisionTree
 
63
import bzrlib.ui
 
64
import bzrlib.urlutils as urlutils
 
65
import bzrlib.xml5
64
66
 
65
67
 
66
68
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
67
69
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
68
 
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
 
70
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
69
71
 
70
72
 
71
73
# TODO: Maybe include checks for common corruption of newlines, etc?
85
87
 
86
88
    base
87
89
        Base directory/url of the branch.
88
 
 
89
 
    hooks: An instance of BranchHooks.
90
90
    """
91
91
    # this is really an instance variable - FIXME move it there
92
92
    # - RBC 20060112
93
93
    base = None
94
94
 
95
 
    # override this to set the strategy for storing tags
96
 
    def _make_tags(self):
97
 
        return DisabledTags(self)
98
 
 
99
95
    def __init__(self, *ignored, **ignored_too):
100
 
        self.tags = self._make_tags()
101
 
        self._revision_history_cache = None
102
 
        self._revision_id_to_revno_cache = None
 
96
        raise NotImplementedError('The Branch class is abstract')
103
97
 
104
98
    def break_lock(self):
105
99
        """Break a lock if one is present from another instance.
123
117
        
124
118
    @staticmethod
125
119
    def open(base, _unsupported=False):
126
 
        """Open the branch rooted at base.
 
120
        """Open the repository rooted at base.
127
121
 
128
 
        For instance, if the branch is at URL/.bzr/branch,
129
 
        Branch.open(URL) -> a Branch instance.
 
122
        For instance, if the repository is at URL/.bzr/repository,
 
123
        Repository.open(URL) -> a Repository instance.
130
124
        """
131
125
        control = bzrdir.BzrDir.open(base, _unsupported)
132
126
        return control.open_branch(_unsupported)
156
150
        """
157
151
        return bzrdir.BzrDir.create_standalone_workingtree(base).branch
158
152
 
159
 
    @deprecated_function(zero_eight)
160
153
    def setup_caching(self, cache_root):
161
154
        """Subclasses that care about caching should override this, and set
162
155
        up cached stores located under cache_root.
163
 
        
164
 
        NOTE: This is unused.
165
156
        """
166
 
        pass
167
 
 
168
 
    def get_config(self):
169
 
        return BranchConfig(self)
 
157
        # seems to be unused, 2006-01-13 mbp
 
158
        warn('%s is deprecated' % self.setup_caching)
 
159
        self.cache_root = cache_root
170
160
 
171
161
    def _get_nick(self):
172
 
        return self.get_config().get_nickname()
 
162
        cfg = self.tree_config()
 
163
        return cfg.get_option(u"nickname", default=self.base.split('/')[-2])
173
164
 
174
165
    def _set_nick(self, nick):
175
 
        self.get_config().set_user_option('nickname', nick)
 
166
        cfg = self.tree_config()
 
167
        cfg.set_option(nick, "nickname")
 
168
        assert cfg.get_option("nickname") == nick
176
169
 
177
170
    nick = property(_get_nick, _set_nick)
178
171
 
179
172
    def is_locked(self):
180
 
        raise NotImplementedError(self.is_locked)
 
173
        raise NotImplementedError('is_locked is abstract')
181
174
 
182
175
    def lock_write(self):
183
 
        raise NotImplementedError(self.lock_write)
 
176
        raise NotImplementedError('lock_write is abstract')
184
177
 
185
178
    def lock_read(self):
186
 
        raise NotImplementedError(self.lock_read)
 
179
        raise NotImplementedError('lock_read is abstract')
187
180
 
188
181
    def unlock(self):
189
 
        raise NotImplementedError(self.unlock)
 
182
        raise NotImplementedError('unlock is abstract')
190
183
 
191
184
    def peek_lock_mode(self):
192
185
        """Return lock mode for the Branch: 'r', 'w' or None"""
193
186
        raise NotImplementedError(self.peek_lock_mode)
194
187
 
195
188
    def get_physical_lock_status(self):
196
 
        raise NotImplementedError(self.get_physical_lock_status)
197
 
 
198
 
    @needs_read_lock
199
 
    def get_revision_id_to_revno_map(self):
200
 
        """Return the revision_id => dotted revno map.
201
 
 
202
 
        This will be regenerated on demand, but will be cached.
203
 
 
204
 
        :return: A dictionary mapping revision_id => dotted revno.
205
 
            This dictionary should not be modified by the caller.
206
 
        """
207
 
        if self._revision_id_to_revno_cache is not None:
208
 
            mapping = self._revision_id_to_revno_cache
209
 
        else:
210
 
            mapping = self._gen_revno_map()
211
 
            self._cache_revision_id_to_revno(mapping)
212
 
        # TODO: jam 20070417 Since this is being cached, should we be returning
213
 
        #       a copy?
214
 
        # I would rather not, and instead just declare that users should not
215
 
        # modify the return value.
216
 
        return mapping
217
 
 
218
 
    def _gen_revno_map(self):
219
 
        """Create a new mapping from revision ids to dotted revnos.
220
 
 
221
 
        Dotted revnos are generated based on the current tip in the revision
222
 
        history.
223
 
        This is the worker function for get_revision_id_to_revno_map, which
224
 
        just caches the return value.
225
 
 
226
 
        :return: A dictionary mapping revision_id => dotted revno.
227
 
        """
228
 
        last_revision = self.last_revision()
229
 
        revision_graph = self.repository.get_revision_graph(last_revision)
230
 
        merge_sorted_revisions = tsort.merge_sort(
231
 
            revision_graph,
232
 
            last_revision,
233
 
            None,
234
 
            generate_revno=True)
235
 
        revision_id_to_revno = dict((rev_id, revno)
236
 
                                    for seq_num, rev_id, depth, revno, end_of_merge
237
 
                                     in merge_sorted_revisions)
238
 
        return revision_id_to_revno
239
 
 
240
 
    def leave_lock_in_place(self):
241
 
        """Tell this branch object not to release the physical lock when this
242
 
        object is unlocked.
243
 
        
244
 
        If lock_write doesn't return a token, then this method is not supported.
245
 
        """
246
 
        self.control_files.leave_in_place()
247
 
 
248
 
    def dont_leave_lock_in_place(self):
249
 
        """Tell this branch object to release the physical lock when this
250
 
        object is unlocked, even if it didn't originally acquire it.
251
 
 
252
 
        If lock_write doesn't return a token, then this method is not supported.
253
 
        """
254
 
        self.control_files.dont_leave_in_place()
 
189
        raise NotImplementedError('get_physical_lock_status is abstract')
255
190
 
256
191
    def abspath(self, name):
257
192
        """Return absolute filename for something in the branch
259
194
        XXX: Robert Collins 20051017 what is this used for? why is it a branch
260
195
        method and not a tree method.
261
196
        """
262
 
        raise NotImplementedError(self.abspath)
 
197
        raise NotImplementedError('abspath is abstract')
263
198
 
264
199
    def bind(self, other):
265
200
        """Bind the local branch the other branch.
284
219
        if self.base == from_branch.base:
285
220
            return (0, [])
286
221
        if pb is None:
287
 
            nested_pb = ui.ui_factory.nested_progress_bar()
 
222
            nested_pb = bzrlib.ui.ui_factory.nested_progress_bar()
288
223
            pb = nested_pb
289
224
        else:
290
225
            nested_pb = None
293
228
        try:
294
229
            if last_revision is None:
295
230
                pb.update('get source history')
296
 
                last_revision = from_branch.last_revision()
297
 
                if last_revision is None:
298
 
                    last_revision = _mod_revision.NULL_REVISION
 
231
                from_history = from_branch.revision_history()
 
232
                if from_history:
 
233
                    last_revision = from_history[-1]
 
234
                else:
 
235
                    # no history in the source branch
 
236
                    last_revision = NULL_REVISION
299
237
            return self.repository.fetch(from_branch.repository,
300
238
                                         revision_id=last_revision,
301
239
                                         pb=nested_pb)
311
249
        branch.
312
250
        """
313
251
        return None
314
 
    
315
 
    def get_old_bound_location(self):
316
 
        """Return the URL of the branch we used to be bound to
317
 
        """
318
 
        raise errors.UpgradeRequired(self.base)
319
 
 
320
 
    def get_commit_builder(self, parents, config=None, timestamp=None, 
321
 
                           timezone=None, committer=None, revprops=None, 
322
 
                           revision_id=None):
323
 
        """Obtain a CommitBuilder for this branch.
324
 
        
325
 
        :param parents: Revision ids of the parents of the new revision.
326
 
        :param config: Optional configuration to use.
327
 
        :param timestamp: Optional timestamp recorded for commit.
328
 
        :param timezone: Optional timezone for timestamp.
329
 
        :param committer: Optional committer to set for commit.
330
 
        :param revprops: Optional dictionary of revision properties.
331
 
        :param revision_id: Optional revision id.
332
 
        """
333
 
 
334
 
        if config is None:
335
 
            config = self.get_config()
336
 
        
337
 
        return self.repository.get_commit_builder(self, parents, config,
338
 
            timestamp, timezone, committer, revprops, revision_id)
339
252
 
340
253
    def get_master_branch(self):
341
254
        """Return the branch we are bound to.
344
257
        """
345
258
        return None
346
259
 
347
 
    def get_revision_delta(self, revno):
348
 
        """Return the delta for one revision.
349
 
 
350
 
        The delta is relative to its mainline predecessor, or the
351
 
        empty tree for revision 1.
352
 
        """
353
 
        assert isinstance(revno, int)
354
 
        rh = self.revision_history()
355
 
        if not (1 <= revno <= len(rh)):
356
 
            raise InvalidRevisionNumber(revno)
357
 
        return self.repository.get_revision_delta(rh[revno-1])
358
 
 
359
 
    @deprecated_method(zero_sixteen)
360
260
    def get_root_id(self):
361
 
        """Return the id of this branches root
362
 
 
363
 
        Deprecated: branches don't have root ids-- trees do.
364
 
        Use basis_tree().get_root_id() instead.
365
 
        """
366
 
        raise NotImplementedError(self.get_root_id)
 
261
        """Return the id of this branches root"""
 
262
        raise NotImplementedError('get_root_id is abstract')
367
263
 
368
264
    def print_file(self, file, revision_id):
369
265
        """Print `file` to stdout."""
370
 
        raise NotImplementedError(self.print_file)
 
266
        raise NotImplementedError('print_file is abstract')
371
267
 
372
268
    def append_revision(self, *revision_ids):
373
 
        raise NotImplementedError(self.append_revision)
 
269
        raise NotImplementedError('append_revision is abstract')
374
270
 
375
271
    def set_revision_history(self, rev_history):
376
 
        raise NotImplementedError(self.set_revision_history)
377
 
 
378
 
    def _cache_revision_history(self, rev_history):
379
 
        """Set the cached revision history to rev_history.
380
 
 
381
 
        The revision_history method will use this cache to avoid regenerating
382
 
        the revision history.
383
 
 
384
 
        This API is semi-public; it only for use by subclasses, all other code
385
 
        should consider it to be private.
386
 
        """
387
 
        self._revision_history_cache = rev_history
388
 
 
389
 
    def _cache_revision_id_to_revno(self, revision_id_to_revno):
390
 
        """Set the cached revision_id => revno map to revision_id_to_revno.
391
 
 
392
 
        This API is semi-public; it only for use by subclasses, all other code
393
 
        should consider it to be private.
394
 
        """
395
 
        self._revision_id_to_revno_cache = revision_id_to_revno
396
 
 
397
 
    def _clear_cached_state(self):
398
 
        """Clear any cached data on this branch, e.g. cached revision history.
399
 
 
400
 
        This means the next call to revision_history will need to call
401
 
        _gen_revision_history.
402
 
 
403
 
        This API is semi-public; it only for use by subclasses, all other code
404
 
        should consider it to be private.
405
 
        """
406
 
        self._revision_history_cache = None
407
 
        self._revision_id_to_revno_cache = None
408
 
 
409
 
    def _gen_revision_history(self):
410
 
        """Return sequence of revision hashes on to this branch.
411
 
        
412
 
        Unlike revision_history, this method always regenerates or rereads the
413
 
        revision history, i.e. it does not cache the result, so repeated calls
414
 
        may be expensive.
415
 
 
416
 
        Concrete subclasses should override this instead of revision_history so
417
 
        that subclasses do not need to deal with caching logic.
418
 
        
419
 
        This API is semi-public; it only for use by subclasses, all other code
420
 
        should consider it to be private.
421
 
        """
422
 
        raise NotImplementedError(self._gen_revision_history)
423
 
 
424
 
    @needs_read_lock
 
272
        raise NotImplementedError('set_revision_history is abstract')
 
273
 
425
274
    def revision_history(self):
426
 
        """Return sequence of revision hashes on to this branch.
427
 
        
428
 
        This method will cache the revision history for as long as it is safe to
429
 
        do so.
430
 
        """
431
 
        if self._revision_history_cache is not None:
432
 
            history = self._revision_history_cache
433
 
        else:
434
 
            history = self._gen_revision_history()
435
 
            self._cache_revision_history(history)
436
 
        return list(history)
 
275
        """Return sequence of revision hashes on to this branch."""
 
276
        raise NotImplementedError('revision_history is abstract')
437
277
 
438
278
    def revno(self):
439
279
        """Return current revision number for this branch.
447
287
        """Older format branches cannot bind or unbind."""
448
288
        raise errors.UpgradeRequired(self.base)
449
289
 
450
 
    def set_append_revisions_only(self, enabled):
451
 
        """Older format branches are never restricted to append-only"""
452
 
        raise errors.UpgradeRequired(self.base)
453
 
 
454
290
    def last_revision(self):
455
 
        """Return last revision id, or None"""
 
291
        """Return last patch hash, or None if no history."""
456
292
        ph = self.revision_history()
457
293
        if ph:
458
294
            return ph[-1]
459
295
        else:
460
296
            return None
461
297
 
462
 
    def last_revision_info(self):
463
 
        """Return information about the last revision.
464
 
 
465
 
        :return: A tuple (revno, last_revision_id).
466
 
        """
467
 
        rh = self.revision_history()
468
 
        revno = len(rh)
469
 
        if revno:
470
 
            return (revno, rh[-1])
471
 
        else:
472
 
            return (0, _mod_revision.NULL_REVISION)
473
 
 
474
298
    def missing_revisions(self, other, stop_revision=None):
475
299
        """Return a list of new revisions that would perfectly fit.
476
300
        
477
301
        If self and other have not diverged, return a list of the revisions
478
302
        present in other, but missing from self.
 
303
 
 
304
        >>> from bzrlib.workingtree import WorkingTree
 
305
        >>> bzrlib.trace.silent = True
 
306
        >>> d1 = bzrdir.ScratchDir()
 
307
        >>> br1 = d1.open_branch()
 
308
        >>> wt1 = d1.open_workingtree()
 
309
        >>> d2 = bzrdir.ScratchDir()
 
310
        >>> br2 = d2.open_branch()
 
311
        >>> wt2 = d2.open_workingtree()
 
312
        >>> br1.missing_revisions(br2)
 
313
        []
 
314
        >>> wt2.commit("lala!", rev_id="REVISION-ID-1")
 
315
        >>> br1.missing_revisions(br2)
 
316
        [u'REVISION-ID-1']
 
317
        >>> br2.missing_revisions(br1)
 
318
        []
 
319
        >>> wt1.commit("lala!", rev_id="REVISION-ID-1")
 
320
        >>> br1.missing_revisions(br2)
 
321
        []
 
322
        >>> wt2.commit("lala!", rev_id="REVISION-ID-2A")
 
323
        >>> br1.missing_revisions(br2)
 
324
        [u'REVISION-ID-2A']
 
325
        >>> wt1.commit("lala!", rev_id="REVISION-ID-2B")
 
326
        >>> br1.missing_revisions(br2)
 
327
        Traceback (most recent call last):
 
328
        DivergedBranches: These branches have diverged.  Try merge.
479
329
        """
480
330
        self_history = self.revision_history()
481
331
        self_len = len(self_history)
491
341
        else:
492
342
            assert isinstance(stop_revision, int)
493
343
            if stop_revision > other_len:
494
 
                raise errors.NoSuchRevision(self, stop_revision)
 
344
                raise bzrlib.errors.NoSuchRevision(self, stop_revision)
495
345
        return other_history[self_len:stop_revision]
496
346
 
497
347
    def update_revisions(self, other, stop_revision=None):
501
351
        :param stop_revision: Updated until the given revision
502
352
        :return: None
503
353
        """
504
 
        raise NotImplementedError(self.update_revisions)
 
354
        raise NotImplementedError('update_revisions is abstract')
505
355
 
506
356
    def revision_id_to_revno(self, revision_id):
507
357
        """Given a revision id, return its revno"""
508
358
        if revision_id is None:
509
359
            return 0
510
 
        revision_id = osutils.safe_revision_id(revision_id)
511
360
        history = self.revision_history()
512
361
        try:
513
362
            return history.index(revision_id) + 1
514
363
        except ValueError:
515
 
            raise errors.NoSuchRevision(self, revision_id)
 
364
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
516
365
 
517
366
    def get_rev_id(self, revno, history=None):
518
367
        """Find the revision id of the specified revno."""
520
369
            return None
521
370
        if history is None:
522
371
            history = self.revision_history()
523
 
        if revno <= 0 or revno > len(history):
524
 
            raise errors.NoSuchRevision(self, revno)
 
372
        elif revno <= 0 or revno > len(history):
 
373
            raise bzrlib.errors.NoSuchRevision(self, revno)
525
374
        return history[revno - 1]
526
375
 
527
376
    def pull(self, source, overwrite=False, stop_revision=None):
528
 
        """Mirror source into this branch.
529
 
 
530
 
        This branch is considered to be 'local', having low latency.
531
 
 
532
 
        :returns: PullResult instance
533
 
        """
534
 
        raise NotImplementedError(self.pull)
535
 
 
536
 
    def push(self, target, overwrite=False, stop_revision=None):
537
 
        """Mirror this branch into target.
538
 
 
539
 
        This branch is considered to be 'local', having low latency.
540
 
        """
541
 
        raise NotImplementedError(self.push)
 
377
        raise NotImplementedError('pull is abstract')
542
378
 
543
379
    def basis_tree(self):
544
 
        """Return `Tree` object for last revision."""
 
380
        """Return `Tree` object for last revision.
 
381
 
 
382
        If there are no revisions yet, return an `EmptyTree`.
 
383
        """
545
384
        return self.repository.revision_tree(self.last_revision())
546
385
 
547
386
    def rename_one(self, from_rel, to_rel):
549
388
 
550
389
        This can change the directory or the filename or both.
551
390
        """
552
 
        raise NotImplementedError(self.rename_one)
 
391
        raise NotImplementedError('rename_one is abstract')
553
392
 
554
393
    def move(self, from_paths, to_name):
555
394
        """Rename files.
565
404
        This returns a list of (from_path, to_path) pairs for each
566
405
        entry that is moved.
567
406
        """
568
 
        raise NotImplementedError(self.move)
 
407
        raise NotImplementedError('move is abstract')
569
408
 
570
409
    def get_parent(self):
571
410
        """Return the parent location of the branch.
574
413
        pattern is that the user can override it by specifying a
575
414
        location.
576
415
        """
577
 
        raise NotImplementedError(self.get_parent)
578
 
 
579
 
    def _set_config_location(self, name, url, config=None,
580
 
                             make_relative=False):
581
 
        if config is None:
582
 
            config = self.get_config()
583
 
        if url is None:
584
 
            url = ''
585
 
        elif make_relative:
586
 
            url = urlutils.relative_url(self.base, url)
587
 
        config.set_user_option(name, url)
588
 
 
589
 
    def _get_config_location(self, name, config=None):
590
 
        if config is None:
591
 
            config = self.get_config()
592
 
        location = config.get_user_option(name)
593
 
        if location == '':
594
 
            location = None
595
 
        return location
596
 
 
597
 
    def get_submit_branch(self):
598
 
        """Return the submit location of the branch.
599
 
 
600
 
        This is the default location for bundle.  The usual
601
 
        pattern is that the user can override it by specifying a
602
 
        location.
603
 
        """
604
 
        return self.get_config().get_user_option('submit_branch')
605
 
 
606
 
    def set_submit_branch(self, location):
607
 
        """Return the submit location of the branch.
608
 
 
609
 
        This is the default location for bundle.  The usual
610
 
        pattern is that the user can override it by specifying a
611
 
        location.
612
 
        """
613
 
        self.get_config().set_user_option('submit_branch', location)
614
 
 
615
 
    def get_public_branch(self):
616
 
        """Return the public location of the branch.
617
 
 
618
 
        This is is used by merge directives.
619
 
        """
620
 
        return self._get_config_location('public_branch')
621
 
 
622
 
    def set_public_branch(self, location):
623
 
        """Return the submit location of the branch.
624
 
 
625
 
        This is the default location for bundle.  The usual
626
 
        pattern is that the user can override it by specifying a
627
 
        location.
628
 
        """
629
 
        self._set_config_location('public_branch', location)
 
416
        raise NotImplementedError('get_parent is abstract')
630
417
 
631
418
    def get_push_location(self):
632
419
        """Return the None or the location to push this branch to."""
633
 
        push_loc = self.get_config().get_user_option('push_location')
634
 
        return push_loc
 
420
        raise NotImplementedError('get_push_location is abstract')
635
421
 
636
422
    def set_push_location(self, location):
637
423
        """Set a new push location for this branch."""
638
 
        raise NotImplementedError(self.set_push_location)
 
424
        raise NotImplementedError('set_push_location is abstract')
639
425
 
640
426
    def set_parent(self, url):
641
 
        raise NotImplementedError(self.set_parent)
 
427
        raise NotImplementedError('set_parent is abstract')
642
428
 
643
429
    @needs_write_lock
644
430
    def update(self):
665
451
            raise InvalidRevisionNumber(revno)
666
452
 
667
453
    @needs_read_lock
668
 
    def clone(self, to_bzrdir, revision_id=None):
 
454
    def clone(self, *args, **kwargs):
669
455
        """Clone this branch into to_bzrdir preserving all semantic values.
670
456
        
671
457
        revision_id: if not None, the revision history in the new branch will
672
458
                     be truncated to end with revision_id.
673
459
        """
 
460
        # for API compatability, until 0.8 releases we provide the old api:
 
461
        # def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
 
462
        # after 0.8 releases, the *args and **kwargs should be changed:
 
463
        # def clone(self, to_bzrdir, revision_id=None):
 
464
        if (kwargs.get('to_location', None) or
 
465
            kwargs.get('revision', None) or
 
466
            kwargs.get('basis_branch', None) or
 
467
            (len(args) and isinstance(args[0], basestring))):
 
468
            # backwards compatability api:
 
469
            warn("Branch.clone() has been deprecated for BzrDir.clone() from"
 
470
                 " bzrlib 0.8.", DeprecationWarning, stacklevel=3)
 
471
            # get basis_branch
 
472
            if len(args) > 2:
 
473
                basis_branch = args[2]
 
474
            else:
 
475
                basis_branch = kwargs.get('basis_branch', None)
 
476
            if basis_branch:
 
477
                basis = basis_branch.bzrdir
 
478
            else:
 
479
                basis = None
 
480
            # get revision
 
481
            if len(args) > 1:
 
482
                revision_id = args[1]
 
483
            else:
 
484
                revision_id = kwargs.get('revision', None)
 
485
            # get location
 
486
            if len(args):
 
487
                url = args[0]
 
488
            else:
 
489
                # no default to raise if not provided.
 
490
                url = kwargs.get('to_location')
 
491
            return self.bzrdir.clone(url,
 
492
                                     revision_id=revision_id,
 
493
                                     basis=basis).open_branch()
 
494
        # new cleaner api.
 
495
        # generate args by hand 
 
496
        if len(args) > 1:
 
497
            revision_id = args[1]
 
498
        else:
 
499
            revision_id = kwargs.get('revision_id', None)
 
500
        if len(args):
 
501
            to_bzrdir = args[0]
 
502
        else:
 
503
            # no default to raise if not provided.
 
504
            to_bzrdir = kwargs.get('to_bzrdir')
674
505
        result = self._format.initialize(to_bzrdir)
675
506
        self.copy_content_into(result, revision_id=revision_id)
676
507
        return  result
687
518
        result.set_parent(self.bzrdir.root_transport.base)
688
519
        return result
689
520
 
690
 
    def _synchronize_history(self, destination, revision_id):
691
 
        """Synchronize last revision and revision history between branches.
692
 
 
693
 
        This version is most efficient when the destination is also a
694
 
        BzrBranch5, but works for BzrBranch6 as long as the revision
695
 
        history is the true lefthand parent history, and all of the revisions
696
 
        are in the destination's repository.  If not, set_revision_history
697
 
        will fail.
698
 
 
699
 
        :param destination: The branch to copy the history into
700
 
        :param revision_id: The revision-id to truncate history at.  May
701
 
          be None to copy complete history.
 
521
    @needs_read_lock
 
522
    def copy_content_into(self, destination, revision_id=None):
 
523
        """Copy the content of self into destination.
 
524
 
 
525
        revision_id: if not None, the revision history in the new branch will
 
526
                     be truncated to end with revision_id.
702
527
        """
703
528
        new_history = self.revision_history()
704
529
        if revision_id is not None:
705
 
            revision_id = osutils.safe_revision_id(revision_id)
706
530
            try:
707
531
                new_history = new_history[:new_history.index(revision_id) + 1]
708
532
            except ValueError:
709
533
                rev = self.repository.get_revision(revision_id)
710
534
                new_history = rev.get_history(self.repository)[1:]
711
535
        destination.set_revision_history(new_history)
712
 
 
713
 
    @needs_read_lock
714
 
    def copy_content_into(self, destination, revision_id=None):
715
 
        """Copy the content of self into destination.
716
 
 
717
 
        revision_id: if not None, the revision history in the new branch will
718
 
                     be truncated to end with revision_id.
719
 
        """
720
 
        self._synchronize_history(destination, revision_id)
721
 
        try:
722
 
            parent = self.get_parent()
723
 
        except errors.InaccessibleParent, e:
724
 
            mutter('parent was not accessible to copy: %s', e)
725
 
        else:
726
 
            if parent:
727
 
                destination.set_parent(parent)
728
 
        self.tags.merge_to(destination.tags)
729
 
 
730
 
    @needs_read_lock
731
 
    def check(self):
732
 
        """Check consistency of the branch.
733
 
 
734
 
        In particular this checks that revisions given in the revision-history
735
 
        do actually match up in the revision graph, and that they're all 
736
 
        present in the repository.
737
 
        
738
 
        Callers will typically also want to check the repository.
739
 
 
740
 
        :return: A BranchCheckResult.
741
 
        """
742
 
        mainline_parent_id = None
743
 
        for revision_id in self.revision_history():
744
 
            try:
745
 
                revision = self.repository.get_revision(revision_id)
746
 
            except errors.NoSuchRevision, e:
747
 
                raise errors.BzrCheckError("mainline revision {%s} not in repository"
748
 
                            % revision_id)
749
 
            # In general the first entry on the revision history has no parents.
750
 
            # But it's not illegal for it to have parents listed; this can happen
751
 
            # in imports from Arch when the parents weren't reachable.
752
 
            if mainline_parent_id is not None:
753
 
                if mainline_parent_id not in revision.parent_ids:
754
 
                    raise errors.BzrCheckError("previous revision {%s} not listed among "
755
 
                                        "parents of {%s}"
756
 
                                        % (mainline_parent_id, revision_id))
757
 
            mainline_parent_id = revision_id
758
 
        return BranchCheckResult(self)
759
 
 
760
 
    def _get_checkout_format(self):
761
 
        """Return the most suitable metadir for a checkout of this branch.
762
 
        Weaves are used if this branch's repository uses weaves.
763
 
        """
764
 
        if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
765
 
            from bzrlib.repofmt import weaverepo
766
 
            format = bzrdir.BzrDirMetaFormat1()
767
 
            format.repository_format = weaverepo.RepositoryFormat7()
768
 
        else:
769
 
            format = self.repository.bzrdir.checkout_metadir()
770
 
            format.set_branch_format(self._format)
771
 
        return format
772
 
 
773
 
    def create_checkout(self, to_location, revision_id=None,
774
 
                        lightweight=False):
775
 
        """Create a checkout of a branch.
776
 
        
777
 
        :param to_location: The url to produce the checkout at
778
 
        :param revision_id: The revision to check out
779
 
        :param lightweight: If True, produce a lightweight checkout, otherwise,
780
 
        produce a bound branch (heavyweight checkout)
781
 
        :return: The tree of the created checkout
782
 
        """
783
 
        t = transport.get_transport(to_location)
784
 
        t.ensure_base()
785
 
        if lightweight:
786
 
            format = self._get_checkout_format()
787
 
            checkout = format.initialize_on_transport(t)
788
 
            BranchReferenceFormat().initialize(checkout, self)
789
 
        else:
790
 
            format = self._get_checkout_format()
791
 
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
792
 
                to_location, force_new_tree=False, format=format)
793
 
            checkout = checkout_branch.bzrdir
794
 
            checkout_branch.bind(self)
795
 
            # pull up to the specified revision_id to set the initial 
796
 
            # branch tip correctly, and seed it with history.
797
 
            checkout_branch.pull(self, stop_revision=revision_id)
798
 
        tree = checkout.create_workingtree(revision_id)
799
 
        basis_tree = tree.basis_tree()
800
 
        basis_tree.lock_read()
801
 
        try:
802
 
            for path, file_id in basis_tree.iter_references():
803
 
                reference_parent = self.reference_parent(file_id, path)
804
 
                reference_parent.create_checkout(tree.abspath(path),
805
 
                    basis_tree.get_reference_revision(file_id, path),
806
 
                    lightweight)
807
 
        finally:
808
 
            basis_tree.unlock()
809
 
        return tree
810
 
 
811
 
    def reference_parent(self, file_id, path):
812
 
        """Return the parent branch for a tree-reference file_id
813
 
        :param file_id: The file_id of the tree reference
814
 
        :param path: The path of the file_id in the tree
815
 
        :return: A branch associated with the file_id
816
 
        """
817
 
        # FIXME should provide multiple branches, based on config
818
 
        return Branch.open(self.bzrdir.root_transport.clone(path).base)
819
 
 
820
 
    def supports_tags(self):
821
 
        return self._format.supports_tags()
 
536
        parent = self.get_parent()
 
537
        if parent:
 
538
            destination.set_parent(parent)
822
539
 
823
540
 
824
541
class BranchFormat(object):
845
562
    _formats = {}
846
563
    """The known formats."""
847
564
 
848
 
    def __eq__(self, other):
849
 
        return self.__class__ is other.__class__
850
 
 
851
 
    def __ne__(self, other):
852
 
        return not (self == other)
853
 
 
854
565
    @classmethod
855
566
    def find_format(klass, a_bzrdir):
856
567
        """Return the format for the branch object in a_bzrdir."""
861
572
        except NoSuchFile:
862
573
            raise NotBranchError(path=transport.base)
863
574
        except KeyError:
864
 
            raise errors.UnknownFormatError(format=format_string)
 
575
            raise errors.UnknownFormatError(format_string)
865
576
 
866
577
    @classmethod
867
578
    def get_default_format(klass):
868
579
        """Return the current default format."""
869
580
        return klass._default_format
870
581
 
871
 
    def get_reference(self, a_bzrdir):
872
 
        """Get the target reference of the branch in a_bzrdir.
873
 
 
874
 
        format probing must have been completed before calling
875
 
        this method - it is assumed that the format of the branch
876
 
        in a_bzrdir is correct.
877
 
 
878
 
        :param a_bzrdir: The bzrdir to get the branch data from.
879
 
        :return: None if the branch is not a reference branch.
880
 
        """
881
 
        return None
882
 
 
883
582
    def get_format_string(self):
884
583
        """Return the ASCII format string that identifies this format."""
885
584
        raise NotImplementedError(self.get_format_string)
886
585
 
887
586
    def get_format_description(self):
888
587
        """Return the short format description for this format."""
889
 
        raise NotImplementedError(self.get_format_description)
890
 
 
891
 
    def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
892
 
                           set_format=True):
893
 
        """Initialize a branch in a bzrdir, with specified files
894
 
 
895
 
        :param a_bzrdir: The bzrdir to initialize the branch in
896
 
        :param utf8_files: The files to create as a list of
897
 
            (filename, content) tuples
898
 
        :param set_format: If True, set the format with
899
 
            self.get_format_string.  (BzrBranch4 has its format set
900
 
            elsewhere)
901
 
        :return: a branch in this format
902
 
        """
903
 
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
904
 
        branch_transport = a_bzrdir.get_branch_transport(self)
905
 
        lock_map = {
906
 
            'metadir': ('lock', lockdir.LockDir),
907
 
            'branch4': ('branch-lock', lockable_files.TransportLock),
908
 
        }
909
 
        lock_name, lock_class = lock_map[lock_type]
910
 
        control_files = lockable_files.LockableFiles(branch_transport,
911
 
            lock_name, lock_class)
912
 
        control_files.create_lock()
913
 
        control_files.lock_write()
914
 
        if set_format:
915
 
            control_files.put_utf8('format', self.get_format_string())
916
 
        try:
917
 
            for file, content in utf8_files:
918
 
                control_files.put_utf8(file, content)
919
 
        finally:
920
 
            control_files.unlock()
921
 
        return self.open(a_bzrdir, _found=True)
 
588
        raise NotImplementedError(self.get_format_string)
922
589
 
923
590
    def initialize(self, a_bzrdir):
924
591
        """Create a branch of this format in a_bzrdir."""
925
 
        raise NotImplementedError(self.initialize)
 
592
        raise NotImplementedError(self.initialized)
926
593
 
927
594
    def is_supported(self):
928
595
        """Is this format supported?
957
624
    def __str__(self):
958
625
        return self.get_format_string().rstrip()
959
626
 
960
 
    def supports_tags(self):
961
 
        """True if this format supports tags stored in the branch"""
962
 
        return False  # by default
963
 
 
964
 
    # XXX: Probably doesn't really belong here -- mbp 20070212
965
 
    def _initialize_control_files(self, a_bzrdir, utf8_files, lock_filename,
966
 
            lock_class):
967
 
        branch_transport = a_bzrdir.get_branch_transport(self)
968
 
        control_files = lockable_files.LockableFiles(branch_transport,
969
 
            lock_filename, lock_class)
970
 
        control_files.create_lock()
971
 
        control_files.lock_write()
972
 
        try:
973
 
            for filename, content in utf8_files:
974
 
                control_files.put_utf8(filename, content)
975
 
        finally:
976
 
            control_files.unlock()
977
 
 
978
 
 
979
 
class BranchHooks(Hooks):
980
 
    """A dictionary mapping hook name to a list of callables for branch hooks.
981
 
    
982
 
    e.g. ['set_rh'] Is the list of items to be called when the
983
 
    set_revision_history function is invoked.
984
 
    """
985
 
 
986
 
    def __init__(self):
987
 
        """Create the default hooks.
988
 
 
989
 
        These are all empty initially, because by default nothing should get
990
 
        notified.
991
 
        """
992
 
        Hooks.__init__(self)
993
 
        # Introduced in 0.15:
994
 
        # invoked whenever the revision history has been set
995
 
        # with set_revision_history. The api signature is
996
 
        # (branch, revision_history), and the branch will
997
 
        # be write-locked.
998
 
        self['set_rh'] = []
999
 
        # invoked after a push operation completes.
1000
 
        # the api signature is
1001
 
        # (push_result)
1002
 
        # containing the members
1003
 
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
1004
 
        # where local is the local target branch or None, master is the target 
1005
 
        # master branch, and the rest should be self explanatory. The source
1006
 
        # is read locked and the target branches write locked. Source will
1007
 
        # be the local low-latency branch.
1008
 
        self['post_push'] = []
1009
 
        # invoked after a pull operation completes.
1010
 
        # the api signature is
1011
 
        # (pull_result)
1012
 
        # containing the members
1013
 
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
1014
 
        # where local is the local branch or None, master is the target 
1015
 
        # master branch, and the rest should be self explanatory. The source
1016
 
        # is read locked and the target branches write locked. The local
1017
 
        # branch is the low-latency branch.
1018
 
        self['post_pull'] = []
1019
 
        # invoked after a commit operation completes.
1020
 
        # the api signature is 
1021
 
        # (local, master, old_revno, old_revid, new_revno, new_revid)
1022
 
        # old_revid is NULL_REVISION for the first commit to a branch.
1023
 
        self['post_commit'] = []
1024
 
        # invoked after a uncommit operation completes.
1025
 
        # the api signature is
1026
 
        # (local, master, old_revno, old_revid, new_revno, new_revid) where
1027
 
        # local is the local branch or None, master is the target branch,
1028
 
        # and an empty branch recieves new_revno of 0, new_revid of None.
1029
 
        self['post_uncommit'] = []
1030
 
 
1031
 
 
1032
 
# install the default hooks into the Branch class.
1033
 
Branch.hooks = BranchHooks()
1034
 
 
1035
627
 
1036
628
class BzrBranchFormat4(BranchFormat):
1037
629
    """Bzr branch format 4.
1047
639
 
1048
640
    def initialize(self, a_bzrdir):
1049
641
        """Create a branch of this format in a_bzrdir."""
 
642
        mutter('creating branch in %s', a_bzrdir.transport.base)
 
643
        branch_transport = a_bzrdir.get_branch_transport(self)
1050
644
        utf8_files = [('revision-history', ''),
1051
645
                      ('branch-name', ''),
1052
646
                      ]
1053
 
        return self._initialize_helper(a_bzrdir, utf8_files,
1054
 
                                       lock_type='branch4', set_format=False)
 
647
        control_files = LockableFiles(branch_transport, 'branch-lock',
 
648
                                      TransportLock)
 
649
        control_files.create_lock()
 
650
        control_files.lock_write()
 
651
        try:
 
652
            for file, content in utf8_files:
 
653
                control_files.put_utf8(file, content)
 
654
        finally:
 
655
            control_files.unlock()
 
656
        return self.open(a_bzrdir, _found=True)
1055
657
 
1056
658
    def __init__(self):
1057
659
        super(BzrBranchFormat4, self).__init__()
1098
700
        
1099
701
    def initialize(self, a_bzrdir):
1100
702
        """Create a branch of this format in a_bzrdir."""
 
703
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
 
704
        branch_transport = a_bzrdir.get_branch_transport(self)
1101
705
        utf8_files = [('revision-history', ''),
1102
706
                      ('branch-name', ''),
1103
707
                      ]
1104
 
        return self._initialize_helper(a_bzrdir, utf8_files)
 
708
        control_files = LockableFiles(branch_transport, 'lock', LockDir)
 
709
        control_files.create_lock()
 
710
        control_files.lock_write()
 
711
        control_files.put_utf8('format', self.get_format_string())
 
712
        try:
 
713
            for file, content in utf8_files:
 
714
                control_files.put_utf8(file, content)
 
715
        finally:
 
716
            control_files.unlock()
 
717
        return self.open(a_bzrdir, _found=True, )
1105
718
 
1106
719
    def __init__(self):
1107
720
        super(BzrBranchFormat5, self).__init__()
1116
729
        if not _found:
1117
730
            format = BranchFormat.find_format(a_bzrdir)
1118
731
            assert format.__class__ == self.__class__
1119
 
        try:
1120
 
            transport = a_bzrdir.get_branch_transport(None)
1121
 
            control_files = lockable_files.LockableFiles(transport, 'lock',
1122
 
                                                         lockdir.LockDir)
1123
 
            return BzrBranch5(_format=self,
1124
 
                              _control_files=control_files,
1125
 
                              a_bzrdir=a_bzrdir,
1126
 
                              _repository=a_bzrdir.find_repository())
1127
 
        except NoSuchFile:
1128
 
            raise NotBranchError(path=transport.base)
1129
 
 
1130
 
 
1131
 
class BzrBranchFormat6(BzrBranchFormat5):
1132
 
    """Branch format with last-revision
1133
 
 
1134
 
    Unlike previous formats, this has no explicit revision history. Instead,
1135
 
    this just stores the last-revision, and the left-hand history leading
1136
 
    up to there is the history.
1137
 
 
1138
 
    This format was introduced in bzr 0.15
1139
 
    """
1140
 
 
1141
 
    def get_format_string(self):
1142
 
        """See BranchFormat.get_format_string()."""
1143
 
        return "Bazaar Branch Format 6 (bzr 0.15)\n"
1144
 
 
1145
 
    def get_format_description(self):
1146
 
        """See BranchFormat.get_format_description()."""
1147
 
        return "Branch format 6"
1148
 
 
1149
 
    def initialize(self, a_bzrdir):
1150
 
        """Create a branch of this format in a_bzrdir."""
1151
 
        utf8_files = [('last-revision', '0 null:\n'),
1152
 
                      ('branch-name', ''),
1153
 
                      ('branch.conf', ''),
1154
 
                      ('tags', ''),
1155
 
                      ]
1156
 
        return self._initialize_helper(a_bzrdir, utf8_files)
1157
 
 
1158
 
    def open(self, a_bzrdir, _found=False):
1159
 
        """Return the branch object for a_bzrdir
1160
 
 
1161
 
        _found is a private parameter, do not use it. It is used to indicate
1162
 
               if format probing has already be done.
1163
 
        """
1164
 
        if not _found:
1165
 
            format = BranchFormat.find_format(a_bzrdir)
1166
 
            assert format.__class__ == self.__class__
1167
732
        transport = a_bzrdir.get_branch_transport(None)
1168
 
        control_files = lockable_files.LockableFiles(transport, 'lock',
1169
 
                                                     lockdir.LockDir)
1170
 
        return BzrBranch6(_format=self,
 
733
        control_files = LockableFiles(transport, 'lock', LockDir)
 
734
        return BzrBranch5(_format=self,
1171
735
                          _control_files=control_files,
1172
736
                          a_bzrdir=a_bzrdir,
1173
737
                          _repository=a_bzrdir.find_repository())
1174
738
 
1175
 
    def supports_tags(self):
1176
 
        return True
 
739
    def __str__(self):
 
740
        return "Bazaar-NG Metadir branch format 5"
1177
741
 
1178
742
 
1179
743
class BranchReferenceFormat(BranchFormat):
1195
759
        """See BranchFormat.get_format_description()."""
1196
760
        return "Checkout reference format 1"
1197
761
        
1198
 
    def get_reference(self, a_bzrdir):
1199
 
        """See BranchFormat.get_reference()."""
1200
 
        transport = a_bzrdir.get_branch_transport(None)
1201
 
        return transport.get('location').read()
1202
 
 
1203
762
    def initialize(self, a_bzrdir, target_branch=None):
1204
763
        """Create a branch of this format in a_bzrdir."""
1205
764
        if target_branch is None:
1208
767
            raise errors.UninitializableFormat(self)
1209
768
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
1210
769
        branch_transport = a_bzrdir.get_branch_transport(self)
1211
 
        branch_transport.put_bytes('location',
1212
 
            target_branch.bzrdir.root_transport.base)
1213
 
        branch_transport.put_bytes('format', self.get_format_string())
 
770
        # FIXME rbc 20060209 one j-a-ms encoding branch lands this str() cast is not needed.
 
771
        branch_transport.put('location', StringIO(str(target_branch.bzrdir.root_transport.base)))
 
772
        branch_transport.put('format', StringIO(self.get_format_string()))
1214
773
        return self.open(a_bzrdir, _found=True)
1215
774
 
1216
775
    def __init__(self):
1227
786
            # emit some sort of warning/error to the caller ?!
1228
787
        return clone
1229
788
 
1230
 
    def open(self, a_bzrdir, _found=False, location=None):
 
789
    def open(self, a_bzrdir, _found=False):
1231
790
        """Return the branch that the branch reference in a_bzrdir points at.
1232
791
 
1233
792
        _found is a private parameter, do not use it. It is used to indicate
1236
795
        if not _found:
1237
796
            format = BranchFormat.find_format(a_bzrdir)
1238
797
            assert format.__class__ == self.__class__
1239
 
        if location is None:
1240
 
            location = self.get_reference(a_bzrdir)
1241
 
        real_bzrdir = bzrdir.BzrDir.open(location)
 
798
        transport = a_bzrdir.get_branch_transport(None)
 
799
        real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
1242
800
        result = real_bzrdir.open_branch()
1243
801
        # this changes the behaviour of result.clone to create a new reference
1244
802
        # rather than a copy of the content of the branch.
1257
815
__default_format = BzrBranchFormat5()
1258
816
BranchFormat.register_format(__default_format)
1259
817
BranchFormat.register_format(BranchReferenceFormat())
1260
 
BranchFormat.register_format(BzrBranchFormat6())
1261
818
BranchFormat.set_default_format(__default_format)
1262
819
_legacy_formats = [BzrBranchFormat4(),
1263
820
                   ]
1270
827
    it's writable, and can be accessed via the normal filesystem API.
1271
828
    """
1272
829
    
1273
 
    def __init__(self, _format=None,
 
830
    def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
 
831
                 relax_version_check=DEPRECATED_PARAMETER, _format=None,
1274
832
                 _control_files=None, a_bzrdir=None, _repository=None):
1275
 
        """Create new branch object at a particular location."""
1276
 
        Branch.__init__(self)
 
833
        """Create new branch object at a particular location.
 
834
 
 
835
        transport -- A Transport object, defining how to access files.
 
836
        
 
837
        init -- If True, create new control files in a previously
 
838
             unversioned directory.  If False, the branch must already
 
839
             be versioned.
 
840
 
 
841
        relax_version_check -- If true, the usual check for the branch
 
842
            version is not applied.  This is intended only for
 
843
            upgrade/recovery type use; it's not guaranteed that
 
844
            all operations will work on old format branches.
 
845
        """
1277
846
        if a_bzrdir is None:
1278
 
            raise ValueError('a_bzrdir must be supplied')
 
847
            self.bzrdir = bzrdir.BzrDir.open(transport.base)
1279
848
        else:
1280
849
            self.bzrdir = a_bzrdir
1281
 
        # self._transport used to point to the directory containing the
1282
 
        # control directory, but was not used - now it's just the transport
1283
 
        # for the branch control files.  mbp 20070212
1284
 
        self._base = self.bzrdir.transport.clone('..').base
 
850
        self._transport = self.bzrdir.transport.clone('..')
 
851
        self._base = self._transport.base
1285
852
        self._format = _format
1286
853
        if _control_files is None:
1287
 
            raise ValueError('BzrBranch _control_files is None')
 
854
            raise BzrBadParameterMissing('_control_files')
1288
855
        self.control_files = _control_files
1289
 
        self._transport = _control_files._transport
 
856
        if deprecated_passed(init):
 
857
            warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
 
858
                 "deprecated as of bzr 0.8. Please use Branch.create().",
 
859
                 DeprecationWarning,
 
860
                 stacklevel=2)
 
861
            if init:
 
862
                # this is slower than before deprecation, oh well never mind.
 
863
                # -> its deprecated.
 
864
                self._initialize(transport.base)
 
865
        self._check_format(_format)
 
866
        if deprecated_passed(relax_version_check):
 
867
            warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
 
868
                 "relax_version_check parameter is deprecated as of bzr 0.8. "
 
869
                 "Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
 
870
                 "open() method.",
 
871
                 DeprecationWarning,
 
872
                 stacklevel=2)
 
873
            if (not relax_version_check
 
874
                and not self._format.is_supported()):
 
875
                raise errors.UnsupportedFormatError(
 
876
                        'sorry, branch format %r not supported' % fmt,
 
877
                        ['use a different bzr version',
 
878
                         'or remove the .bzr directory'
 
879
                         ' and "bzr init" again'])
 
880
        if deprecated_passed(transport):
 
881
            warn("BzrBranch.__init__(transport=XXX...): The transport "
 
882
                 "parameter is deprecated as of bzr 0.8. "
 
883
                 "Please use Branch.open, or bzrdir.open_branch().",
 
884
                 DeprecationWarning,
 
885
                 stacklevel=2)
1290
886
        self.repository = _repository
1291
887
 
1292
888
    def __str__(self):
1294
890
 
1295
891
    __repr__ = __str__
1296
892
 
 
893
    def __del__(self):
 
894
        # TODO: It might be best to do this somewhere else,
 
895
        # but it is nice for a Branch object to automatically
 
896
        # cache it's information.
 
897
        # Alternatively, we could have the Transport objects cache requests
 
898
        # See the earlier discussion about how major objects (like Branch)
 
899
        # should never expect their __del__ function to run.
 
900
        # XXX: cache_root seems to be unused, 2006-01-13 mbp
 
901
        if hasattr(self, 'cache_root') and self.cache_root is not None:
 
902
            try:
 
903
                rmtree(self.cache_root)
 
904
            except:
 
905
                pass
 
906
            self.cache_root = None
 
907
 
1297
908
    def _get_base(self):
1298
 
        """Returns the directory containing the control directory."""
1299
909
        return self._base
1300
910
 
1301
911
    base = property(_get_base, doc="The URL for the root of this branch.")
1302
912
 
 
913
    def _finish_transaction(self):
 
914
        """Exit the current transaction."""
 
915
        return self.control_files._finish_transaction()
 
916
 
 
917
    def get_transaction(self):
 
918
        """Return the current active transaction.
 
919
 
 
920
        If no transaction is active, this returns a passthrough object
 
921
        for which all data is immediately flushed and no caching happens.
 
922
        """
 
923
        # this is an explicit function so that we can do tricky stuff
 
924
        # when the storage in rev_storage is elsewhere.
 
925
        # we probably need to hook the two 'lock a location' and 
 
926
        # 'have a transaction' together more delicately, so that
 
927
        # we can have two locks (branch and storage) and one transaction
 
928
        # ... and finishing the transaction unlocks both, but unlocking
 
929
        # does not. - RBC 20051121
 
930
        return self.control_files.get_transaction()
 
931
 
 
932
    def _set_transaction(self, transaction):
 
933
        """Set a new active transaction."""
 
934
        return self.control_files._set_transaction(transaction)
 
935
 
1303
936
    def abspath(self, name):
1304
937
        """See Branch.abspath."""
1305
938
        return self.control_files._transport.abspath(name)
1306
939
 
1307
 
 
1308
 
    @deprecated_method(zero_sixteen)
 
940
    def _check_format(self, format):
 
941
        """Identify the branch format if needed.
 
942
 
 
943
        The format is stored as a reference to the format object in
 
944
        self._format for code that needs to check it later.
 
945
 
 
946
        The format parameter is either None or the branch format class
 
947
        used to open this branch.
 
948
 
 
949
        FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
 
950
        """
 
951
        if format is None:
 
952
            format = BzrBranchFormat.find_format(self.bzrdir)
 
953
        self._format = format
 
954
        mutter("got branch format %s", self._format)
 
955
 
1309
956
    @needs_read_lock
1310
957
    def get_root_id(self):
1311
958
        """See Branch.get_root_id."""
1315
962
    def is_locked(self):
1316
963
        return self.control_files.is_locked()
1317
964
 
1318
 
    def lock_write(self, token=None):
1319
 
        repo_token = self.repository.lock_write()
1320
 
        try:
1321
 
            token = self.control_files.lock_write(token=token)
1322
 
        except:
1323
 
            self.repository.unlock()
1324
 
            raise
1325
 
        return token
 
965
    def lock_write(self):
 
966
        # TODO: test for failed two phase locks. This is known broken.
 
967
        self.control_files.lock_write()
 
968
        self.repository.lock_write()
1326
969
 
1327
970
    def lock_read(self):
 
971
        # TODO: test for failed two phase locks. This is known broken.
 
972
        self.control_files.lock_read()
1328
973
        self.repository.lock_read()
1329
 
        try:
1330
 
            self.control_files.lock_read()
1331
 
        except:
1332
 
            self.repository.unlock()
1333
 
            raise
1334
974
 
1335
975
    def unlock(self):
1336
976
        # TODO: test for failed two phase locks. This is known broken.
1337
977
        try:
 
978
            self.repository.unlock()
 
979
        finally:
1338
980
            self.control_files.unlock()
1339
 
        finally:
1340
 
            self.repository.unlock()
1341
 
        if not self.control_files.is_locked():
1342
 
            # we just released the lock
1343
 
            self._clear_cached_state()
1344
981
        
1345
982
    def peek_lock_mode(self):
1346
983
        if self.control_files._lock_count == 0:
1359
996
    @needs_write_lock
1360
997
    def append_revision(self, *revision_ids):
1361
998
        """See Branch.append_revision."""
1362
 
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1363
999
        for revision_id in revision_ids:
1364
 
            _mod_revision.check_not_reserved_id(revision_id)
1365
1000
            mutter("add {%s} to revision-history" % revision_id)
1366
1001
        rev_history = self.revision_history()
1367
1002
        rev_history.extend(revision_ids)
1368
1003
        self.set_revision_history(rev_history)
1369
1004
 
1370
 
    def _write_revision_history(self, history):
1371
 
        """Factored out of set_revision_history.
1372
 
 
1373
 
        This performs the actual writing to disk.
1374
 
        It is intended to be called by BzrBranch5.set_revision_history."""
1375
 
        self.control_files.put_bytes(
1376
 
            'revision-history', '\n'.join(history))
1377
 
 
1378
1005
    @needs_write_lock
1379
1006
    def set_revision_history(self, rev_history):
1380
1007
        """See Branch.set_revision_history."""
1381
 
        rev_history = [osutils.safe_revision_id(r) for r in rev_history]
1382
 
        self._clear_cached_state()
1383
 
        self._write_revision_history(rev_history)
1384
 
        self._cache_revision_history(rev_history)
1385
 
        for hook in Branch.hooks['set_rh']:
1386
 
            hook(self, rev_history)
1387
 
 
1388
 
    @needs_write_lock
1389
 
    def set_last_revision_info(self, revno, revision_id):
1390
 
        revision_id = osutils.safe_revision_id(revision_id)
1391
 
        history = self._lefthand_history(revision_id)
1392
 
        assert len(history) == revno, '%d != %d' % (len(history), revno)
1393
 
        self.set_revision_history(history)
1394
 
 
1395
 
    def _gen_revision_history(self):
1396
 
        history = self.control_files.get('revision-history').read().split('\n')
1397
 
        if history[-1:] == ['']:
1398
 
            # There shouldn't be a trailing newline, but just in case.
1399
 
            history.pop()
1400
 
        return history
1401
 
 
1402
 
    def _lefthand_history(self, revision_id, last_rev=None,
1403
 
                          other_branch=None):
1404
 
        # stop_revision must be a descendant of last_revision
1405
 
        stop_graph = self.repository.get_revision_graph(revision_id)
1406
 
        if last_rev is not None and last_rev not in stop_graph:
1407
 
            # our previous tip is not merged into stop_revision
1408
 
            raise errors.DivergedBranches(self, other_branch)
1409
 
        # make a new revision history from the graph
1410
 
        current_rev_id = revision_id
1411
 
        new_history = []
1412
 
        while current_rev_id not in (None, _mod_revision.NULL_REVISION):
1413
 
            new_history.append(current_rev_id)
1414
 
            current_rev_id_parents = stop_graph[current_rev_id]
1415
 
            try:
1416
 
                current_rev_id = current_rev_id_parents[0]
1417
 
            except IndexError:
1418
 
                current_rev_id = None
1419
 
        new_history.reverse()
1420
 
        return new_history
1421
 
 
1422
 
    @needs_write_lock
1423
 
    def generate_revision_history(self, revision_id, last_rev=None,
1424
 
        other_branch=None):
1425
 
        """Create a new revision history that will finish with revision_id.
1426
 
 
1427
 
        :param revision_id: the new tip to use.
1428
 
        :param last_rev: The previous last_revision. If not None, then this
1429
 
            must be a ancestory of revision_id, or DivergedBranches is raised.
1430
 
        :param other_branch: The other branch that DivergedBranches should
1431
 
            raise with respect to.
 
1008
        self.control_files.put_utf8(
 
1009
            'revision-history', '\n'.join(rev_history))
 
1010
        transaction = self.get_transaction()
 
1011
        history = transaction.map.find_revision_history()
 
1012
        if history is not None:
 
1013
            # update the revision history in the identity map.
 
1014
            history[:] = list(rev_history)
 
1015
            # this call is disabled because revision_history is 
 
1016
            # not really an object yet, and the transaction is for objects.
 
1017
            # transaction.register_dirty(history)
 
1018
        else:
 
1019
            transaction.map.add_revision_history(rev_history)
 
1020
            # this call is disabled because revision_history is 
 
1021
            # not really an object yet, and the transaction is for objects.
 
1022
            # transaction.register_clean(history)
 
1023
 
 
1024
    def get_revision_delta(self, revno):
 
1025
        """Return the delta for one revision.
 
1026
 
 
1027
        The delta is relative to its mainline predecessor, or the
 
1028
        empty tree for revision 1.
1432
1029
        """
1433
 
        revision_id = osutils.safe_revision_id(revision_id)
1434
 
        self.set_revision_history(self._lefthand_history(revision_id,
1435
 
            last_rev, other_branch))
 
1030
        assert isinstance(revno, int)
 
1031
        rh = self.revision_history()
 
1032
        if not (1 <= revno <= len(rh)):
 
1033
            raise InvalidRevisionNumber(revno)
 
1034
 
 
1035
        # revno is 1-based; list is 0-based
 
1036
 
 
1037
        new_tree = self.repository.revision_tree(rh[revno-1])
 
1038
        if revno == 1:
 
1039
            old_tree = EmptyTree()
 
1040
        else:
 
1041
            old_tree = self.repository.revision_tree(rh[revno-2])
 
1042
        return compare_trees(old_tree, new_tree)
 
1043
 
 
1044
    @needs_read_lock
 
1045
    def revision_history(self):
 
1046
        """See Branch.revision_history."""
 
1047
        transaction = self.get_transaction()
 
1048
        history = transaction.map.find_revision_history()
 
1049
        if history is not None:
 
1050
            mutter("cache hit for revision-history in %s", self)
 
1051
            return list(history)
 
1052
        history = [l.rstrip('\r\n') for l in
 
1053
                self.control_files.get_utf8('revision-history').readlines()]
 
1054
        transaction.map.add_revision_history(history)
 
1055
        # this call is disabled because revision_history is 
 
1056
        # not really an object yet, and the transaction is for objects.
 
1057
        # transaction.register_clean(history, precious=True)
 
1058
        return list(history)
1436
1059
 
1437
1060
    @needs_write_lock
1438
1061
    def update_revisions(self, other, stop_revision=None):
1444
1067
                if stop_revision is None:
1445
1068
                    # if there are no commits, we're done.
1446
1069
                    return
1447
 
            else:
1448
 
                stop_revision = osutils.safe_revision_id(stop_revision)
1449
1070
            # whats the current last revision, before we fetch [and change it
1450
1071
            # possibly]
1451
1072
            last_rev = self.last_revision()
1452
1073
            # we fetch here regardless of whether we need to so that we pickup
1453
1074
            # filled in ghosts.
1454
1075
            self.fetch(other, stop_revision)
1455
 
            my_ancestry = self.repository.get_ancestry(last_rev,
1456
 
                                                       topo_sorted=False)
 
1076
            my_ancestry = self.repository.get_ancestry(last_rev)
1457
1077
            if stop_revision in my_ancestry:
1458
1078
                # last_revision is a descendant of stop_revision
1459
1079
                return
1460
 
            self.generate_revision_history(stop_revision, last_rev=last_rev,
1461
 
                other_branch=other)
 
1080
            # stop_revision must be a descendant of last_revision
 
1081
            stop_graph = self.repository.get_revision_graph(stop_revision)
 
1082
            if last_rev is not None and last_rev not in stop_graph:
 
1083
                # our previous tip is not merged into stop_revision
 
1084
                raise errors.DivergedBranches(self, other)
 
1085
            # make a new revision history from the graph
 
1086
            current_rev_id = stop_revision
 
1087
            new_history = []
 
1088
            while current_rev_id not in (None, NULL_REVISION):
 
1089
                new_history.append(current_rev_id)
 
1090
                current_rev_id_parents = stop_graph[current_rev_id]
 
1091
                try:
 
1092
                    current_rev_id = current_rev_id_parents[0]
 
1093
                except IndexError:
 
1094
                    current_rev_id = None
 
1095
            new_history.reverse()
 
1096
            self.set_revision_history(new_history)
1462
1097
        finally:
1463
1098
            other.unlock()
1464
1099
 
1469
1104
    @deprecated_method(zero_eight)
1470
1105
    def working_tree(self):
1471
1106
        """Create a Working tree object for this branch."""
1472
 
 
 
1107
        from bzrlib.workingtree import WorkingTree
1473
1108
        from bzrlib.transport.local import LocalTransport
1474
1109
        if (self.base.find('://') != -1 or 
1475
1110
            not isinstance(self._transport, LocalTransport)):
1477
1112
        return self.bzrdir.open_workingtree()
1478
1113
 
1479
1114
    @needs_write_lock
1480
 
    def pull(self, source, overwrite=False, stop_revision=None,
1481
 
             _hook_master=None, run_hooks=True):
1482
 
        """See Branch.pull.
1483
 
 
1484
 
        :param _hook_master: Private parameter - set the branch to 
1485
 
            be supplied as the master to push hooks.
1486
 
        :param run_hooks: Private parameter - if false, this branch
1487
 
            is being called because it's the master of the primary branch,
1488
 
            so it should not run its hooks.
1489
 
        """
1490
 
        result = PullResult()
1491
 
        result.source_branch = source
1492
 
        result.target_branch = self
 
1115
    def pull(self, source, overwrite=False, stop_revision=None):
 
1116
        """See Branch.pull."""
1493
1117
        source.lock_read()
1494
1118
        try:
1495
 
            result.old_revno, result.old_revid = self.last_revision_info()
 
1119
            old_count = len(self.revision_history())
1496
1120
            try:
1497
 
                self.update_revisions(source, stop_revision)
 
1121
                self.update_revisions(source,stop_revision)
1498
1122
            except DivergedBranches:
1499
1123
                if not overwrite:
1500
1124
                    raise
1501
1125
            if overwrite:
1502
 
                if stop_revision is None:
1503
 
                    stop_revision = source.last_revision()
1504
 
                self.generate_revision_history(stop_revision)
1505
 
            result.tag_conflicts = source.tags.merge_to(self.tags)
1506
 
            result.new_revno, result.new_revid = self.last_revision_info()
1507
 
            if _hook_master:
1508
 
                result.master_branch = _hook_master
1509
 
                result.local_branch = self
1510
 
            else:
1511
 
                result.master_branch = self
1512
 
                result.local_branch = None
1513
 
            if run_hooks:
1514
 
                for hook in Branch.hooks['post_pull']:
1515
 
                    hook(result)
 
1126
                self.set_revision_history(source.revision_history())
 
1127
            new_count = len(self.revision_history())
 
1128
            return new_count - old_count
1516
1129
        finally:
1517
1130
            source.unlock()
1518
 
        return result
1519
1131
 
1520
 
    def _get_parent_location(self):
 
1132
    def get_parent(self):
 
1133
        """See Branch.get_parent."""
 
1134
        import errno
1521
1135
        _locs = ['parent', 'pull', 'x-pull']
 
1136
        assert self.base[-1] == '/'
1522
1137
        for l in _locs:
1523
1138
            try:
1524
 
                return self.control_files.get(l).read().strip('\n')
 
1139
                return urlutils.join(self.base[:-1], 
 
1140
                            self.control_files.get(l).read().strip('\n'))
1525
1141
            except NoSuchFile:
1526
1142
                pass
1527
1143
        return None
1528
1144
 
1529
 
    @needs_read_lock
1530
 
    def push(self, target, overwrite=False, stop_revision=None,
1531
 
             _override_hook_source_branch=None):
1532
 
        """See Branch.push.
1533
 
 
1534
 
        This is the basic concrete implementation of push()
1535
 
 
1536
 
        :param _override_hook_source_branch: If specified, run
1537
 
        the hooks passing this Branch as the source, rather than self.  
1538
 
        This is for use of RemoteBranch, where push is delegated to the
1539
 
        underlying vfs-based Branch. 
1540
 
        """
1541
 
        # TODO: Public option to disable running hooks - should be trivial but
1542
 
        # needs tests.
1543
 
        target.lock_write()
1544
 
        try:
1545
 
            result = self._push_with_bound_branches(target, overwrite,
1546
 
                    stop_revision,
1547
 
                    _override_hook_source_branch=_override_hook_source_branch)
1548
 
            return result
1549
 
        finally:
1550
 
            target.unlock()
1551
 
 
1552
 
    def _push_with_bound_branches(self, target, overwrite,
1553
 
            stop_revision,
1554
 
            _override_hook_source_branch=None):
1555
 
        """Push from self into target, and into target's master if any.
1556
 
        
1557
 
        This is on the base BzrBranch class even though it doesn't support 
1558
 
        bound branches because the *target* might be bound.
1559
 
        """
1560
 
        def _run_hooks():
1561
 
            if _override_hook_source_branch:
1562
 
                result.source_branch = _override_hook_source_branch
1563
 
            for hook in Branch.hooks['post_push']:
1564
 
                hook(result)
1565
 
 
1566
 
        bound_location = target.get_bound_location()
1567
 
        if bound_location and target.base != bound_location:
1568
 
            # there is a master branch.
1569
 
            #
1570
 
            # XXX: Why the second check?  Is it even supported for a branch to
1571
 
            # be bound to itself? -- mbp 20070507
1572
 
            master_branch = target.get_master_branch()
1573
 
            master_branch.lock_write()
1574
 
            try:
1575
 
                # push into the master from this branch.
1576
 
                self._basic_push(master_branch, overwrite, stop_revision)
1577
 
                # and push into the target branch from this. Note that we push from
1578
 
                # this branch again, because its considered the highest bandwidth
1579
 
                # repository.
1580
 
                result = self._basic_push(target, overwrite, stop_revision)
1581
 
                result.master_branch = master_branch
1582
 
                result.local_branch = target
1583
 
                _run_hooks()
1584
 
                return result
1585
 
            finally:
1586
 
                master_branch.unlock()
1587
 
        else:
1588
 
            # no master branch
1589
 
            result = self._basic_push(target, overwrite, stop_revision)
1590
 
            # TODO: Why set master_branch and local_branch if there's no
1591
 
            # binding?  Maybe cleaner to just leave them unset? -- mbp
1592
 
            # 20070504
1593
 
            result.master_branch = target
1594
 
            result.local_branch = None
1595
 
            _run_hooks()
1596
 
            return result
1597
 
 
1598
 
    def _basic_push(self, target, overwrite, stop_revision):
1599
 
        """Basic implementation of push without bound branches or hooks.
1600
 
 
1601
 
        Must be called with self read locked and target write locked.
1602
 
        """
1603
 
        result = PushResult()
1604
 
        result.source_branch = self
1605
 
        result.target_branch = target
1606
 
        result.old_revno, result.old_revid = target.last_revision_info()
1607
 
        try:
1608
 
            target.update_revisions(self, stop_revision)
1609
 
        except DivergedBranches:
1610
 
            if not overwrite:
1611
 
                raise
1612
 
        if overwrite:
1613
 
            target.set_revision_history(self.revision_history())
1614
 
        result.tag_conflicts = self.tags.merge_to(target.tags)
1615
 
        result.new_revno, result.new_revid = target.last_revision_info()
1616
 
        return result
1617
 
 
1618
 
    def get_parent(self):
1619
 
        """See Branch.get_parent."""
1620
 
 
1621
 
        assert self.base[-1] == '/'
1622
 
        parent = self._get_parent_location()
1623
 
        if parent is None:
1624
 
            return parent
1625
 
        # This is an old-format absolute path to a local branch
1626
 
        # turn it into a url
1627
 
        if parent.startswith('/'):
1628
 
            parent = urlutils.local_path_to_url(parent.decode('utf8'))
1629
 
        try:
1630
 
            return urlutils.join(self.base[:-1], parent)
1631
 
        except errors.InvalidURLJoin, e:
1632
 
            raise errors.InaccessibleParent(parent, self.base)
 
1145
    def get_push_location(self):
 
1146
        """See Branch.get_push_location."""
 
1147
        config = bzrlib.config.BranchConfig(self)
 
1148
        push_loc = config.get_user_option('push_location')
 
1149
        return push_loc
1633
1150
 
1634
1151
    def set_push_location(self, location):
1635
1152
        """See Branch.set_push_location."""
1636
 
        self.get_config().set_user_option(
1637
 
            'push_location', location,
1638
 
            store=_mod_config.STORE_LOCATION_NORECURSE)
 
1153
        config = bzrlib.config.LocationConfig(self.base)
 
1154
        config.set_user_option('push_location', location)
1639
1155
 
1640
1156
    @needs_write_lock
1641
1157
    def set_parent(self, url):
1645
1161
        # FIXUP this and get_parent in a future branch format bump:
1646
1162
        # read and rewrite the file, and have the new format code read
1647
1163
        # using .get not .get_utf8. RBC 20060125
1648
 
        if url is not None:
 
1164
        if url is None:
 
1165
            self.control_files._transport.delete('parent')
 
1166
        else:
1649
1167
            if isinstance(url, unicode):
1650
1168
                try: 
1651
1169
                    url = url.encode('ascii')
1652
1170
                except UnicodeEncodeError:
1653
 
                    raise errors.InvalidURL(url,
 
1171
                    raise bzrlib.errors.InvalidURL(url,
1654
1172
                        "Urls must be 7-bit ascii, "
1655
1173
                        "use bzrlib.urlutils.escape")
 
1174
                    
1656
1175
            url = urlutils.relative_url(self.base, url)
1657
 
        self._set_parent_location(url)
1658
 
 
1659
 
    def _set_parent_location(self, url):
1660
 
        if url is None:
1661
 
            self.control_files._transport.delete('parent')
1662
 
        else:
1663
 
            assert isinstance(url, str)
1664
 
            self.control_files.put_bytes('parent', url + '\n')
1665
 
 
1666
 
    @deprecated_function(zero_nine)
 
1176
            self.control_files.put('parent', url + '\n')
 
1177
 
1667
1178
    def tree_config(self):
1668
 
        """DEPRECATED; call get_config instead.  
1669
 
        TreeConfig has become part of BranchConfig."""
1670
1179
        return TreeConfig(self)
1671
1180
 
1672
1181
 
1687
1196
                                         _repository=_repository)
1688
1197
        
1689
1198
    @needs_write_lock
1690
 
    def pull(self, source, overwrite=False, stop_revision=None,
1691
 
             run_hooks=True):
1692
 
        """Pull from source into self, updating my master if any.
1693
 
        
1694
 
        :param run_hooks: Private parameter - if false, this branch
1695
 
            is being called because it's the master of the primary branch,
1696
 
            so it should not run its hooks.
1697
 
        """
 
1199
    def pull(self, source, overwrite=False, stop_revision=None):
 
1200
        """Updates branch.pull to be bound branch aware."""
1698
1201
        bound_location = self.get_bound_location()
1699
 
        master_branch = None
1700
 
        if bound_location and source.base != bound_location:
 
1202
        if source.base != bound_location:
1701
1203
            # not pulling from master, so we need to update master.
1702
1204
            master_branch = self.get_master_branch()
1703
 
            master_branch.lock_write()
1704
 
        try:
1705
 
            if master_branch:
1706
 
                # pull from source into master.
1707
 
                master_branch.pull(source, overwrite, stop_revision,
1708
 
                    run_hooks=False)
1709
 
            return super(BzrBranch5, self).pull(source, overwrite,
1710
 
                stop_revision, _hook_master=master_branch,
1711
 
                run_hooks=run_hooks)
1712
 
        finally:
1713
 
            if master_branch:
1714
 
                master_branch.unlock()
 
1205
            if master_branch:
 
1206
                master_branch.pull(source)
 
1207
                source = master_branch
 
1208
        return super(BzrBranch5, self).pull(source, overwrite, stop_revision)
1715
1209
 
1716
1210
    def get_bound_location(self):
1717
1211
        try:
1727
1221
 
1728
1222
        This could memoise the branch, but if thats done
1729
1223
        it must be revalidated on each new lock.
1730
 
        So for now we just don't memoise it.
 
1224
        So for now we just dont memoise it.
1731
1225
        # RBC 20060304 review this decision.
1732
1226
        """
1733
1227
        bound_loc = self.get_bound_location()
1756
1250
 
1757
1251
    @needs_write_lock
1758
1252
    def bind(self, other):
1759
 
        """Bind this branch to the branch other.
 
1253
        """Bind the local branch the other branch.
1760
1254
 
1761
 
        This does not push or pull data between the branches, though it does
1762
 
        check for divergence to raise an error when the branches are not
1763
 
        either the same, or one a prefix of the other. That behaviour may not
1764
 
        be useful, so that check may be removed in future.
1765
 
        
1766
1255
        :param other: The branch to bind to
1767
1256
        :type other: Branch
1768
1257
        """
1773
1262
        #       but binding itself may not be.
1774
1263
        #       Since we *have* to check at commit time, we don't
1775
1264
        #       *need* to check here
1776
 
 
1777
 
        # we want to raise diverged if:
1778
 
        # last_rev is not in the other_last_rev history, AND
1779
 
        # other_last_rev is not in our history, and do it without pulling
1780
 
        # history around
1781
 
        last_rev = self.last_revision()
1782
 
        if last_rev is not None:
1783
 
            other.lock_read()
1784
 
            try:
1785
 
                other_last_rev = other.last_revision()
1786
 
                if other_last_rev is not None:
1787
 
                    # neither branch is new, we have to do some work to
1788
 
                    # ascertain diversion.
1789
 
                    remote_graph = other.repository.get_revision_graph(
1790
 
                        other_last_rev)
1791
 
                    local_graph = self.repository.get_revision_graph(last_rev)
1792
 
                    if (last_rev not in remote_graph and
1793
 
                        other_last_rev not in local_graph):
1794
 
                        raise errors.DivergedBranches(self, other)
1795
 
            finally:
1796
 
                other.unlock()
 
1265
        self.pull(other)
 
1266
 
 
1267
        # we are now equal to or a suffix of other.
 
1268
 
 
1269
        # Since we have 'pulled' from the remote location,
 
1270
        # now we should try to pull in the opposite direction
 
1271
        # in case the local tree has more revisions than the
 
1272
        # remote one.
 
1273
        # There may be a different check you could do here
 
1274
        # rather than actually trying to install revisions remotely.
 
1275
        # TODO: capture an exception which indicates the remote branch
 
1276
        #       is not writeable. 
 
1277
        #       If it is up-to-date, this probably should not be a failure
 
1278
        
 
1279
        # lock other for write so the revision-history syncing cannot race
 
1280
        other.lock_write()
 
1281
        try:
 
1282
            other.pull(self)
 
1283
            # if this does not error, other now has the same last rev we do
 
1284
            # it can only error if the pull from other was concurrent with
 
1285
            # a commit to other from someone else.
 
1286
 
 
1287
            # until we ditch revision-history, we need to sync them up:
 
1288
            self.set_revision_history(other.revision_history())
 
1289
            # now other and self are up to date with each other and have the
 
1290
            # same revision-history.
 
1291
        finally:
 
1292
            other.unlock()
 
1293
 
1797
1294
        self.set_bound_location(other.base)
1798
1295
 
1799
1296
    @needs_write_lock
1812
1309
        if master is not None:
1813
1310
            old_tip = self.last_revision()
1814
1311
            self.pull(master, overwrite=True)
1815
 
            if old_tip in self.repository.get_ancestry(self.last_revision(),
1816
 
                                                       topo_sorted=False):
 
1312
            if old_tip in self.repository.get_ancestry(self.last_revision()):
1817
1313
                return None
1818
1314
            return old_tip
1819
1315
        return None
1820
1316
 
1821
1317
 
1822
 
class BzrBranchExperimental(BzrBranch5):
1823
 
    """Bzr experimental branch format
1824
 
 
1825
 
    This format has:
1826
 
     - a revision-history file.
1827
 
     - a format string
1828
 
     - a lock dir guarding the branch itself
1829
 
     - all of this stored in a branch/ subdirectory
1830
 
     - works with shared repositories.
1831
 
     - a tag dictionary in the branch
1832
 
 
1833
 
    This format is new in bzr 0.15, but shouldn't be used for real data, 
1834
 
    only for testing.
1835
 
 
1836
 
    This class acts as it's own BranchFormat.
 
1318
class BranchTestProviderAdapter(object):
 
1319
    """A tool to generate a suite testing multiple branch formats at once.
 
1320
 
 
1321
    This is done by copying the test once for each transport and injecting
 
1322
    the transport_server, transport_readonly_server, and branch_format
 
1323
    classes into each copy. Each copy is also given a new id() to make it
 
1324
    easy to identify.
1837
1325
    """
1838
1326
 
1839
 
    _matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1840
 
 
1841
 
    @classmethod
1842
 
    def get_format_string(cls):
1843
 
        """See BranchFormat.get_format_string()."""
1844
 
        return "Bazaar-NG branch format experimental\n"
1845
 
 
1846
 
    @classmethod
1847
 
    def get_format_description(cls):
1848
 
        """See BranchFormat.get_format_description()."""
1849
 
        return "Experimental branch format"
1850
 
 
1851
 
    @classmethod
1852
 
    def get_reference(cls, a_bzrdir):
1853
 
        """Get the target reference of the branch in a_bzrdir.
1854
 
 
1855
 
        format probing must have been completed before calling
1856
 
        this method - it is assumed that the format of the branch
1857
 
        in a_bzrdir is correct.
1858
 
 
1859
 
        :param a_bzrdir: The bzrdir to get the branch data from.
1860
 
        :return: None if the branch is not a reference branch.
1861
 
        """
1862
 
        return None
1863
 
 
1864
 
    @classmethod
1865
 
    def _initialize_control_files(cls, a_bzrdir, utf8_files, lock_filename,
1866
 
            lock_class):
1867
 
        branch_transport = a_bzrdir.get_branch_transport(cls)
1868
 
        control_files = lockable_files.LockableFiles(branch_transport,
1869
 
            lock_filename, lock_class)
1870
 
        control_files.create_lock()
1871
 
        control_files.lock_write()
1872
 
        try:
1873
 
            for filename, content in utf8_files:
1874
 
                control_files.put_utf8(filename, content)
1875
 
        finally:
1876
 
            control_files.unlock()
1877
 
        
1878
 
    @classmethod
1879
 
    def initialize(cls, a_bzrdir):
1880
 
        """Create a branch of this format in a_bzrdir."""
1881
 
        utf8_files = [('format', cls.get_format_string()),
1882
 
                      ('revision-history', ''),
1883
 
                      ('branch-name', ''),
1884
 
                      ('tags', ''),
1885
 
                      ]
1886
 
        cls._initialize_control_files(a_bzrdir, utf8_files,
1887
 
            'lock', lockdir.LockDir)
1888
 
        return cls.open(a_bzrdir, _found=True)
1889
 
 
1890
 
    @classmethod
1891
 
    def open(cls, a_bzrdir, _found=False):
1892
 
        """Return the branch object for a_bzrdir
1893
 
 
1894
 
        _found is a private parameter, do not use it. It is used to indicate
1895
 
               if format probing has already be done.
1896
 
        """
1897
 
        if not _found:
1898
 
            format = BranchFormat.find_format(a_bzrdir)
1899
 
            assert format.__class__ == cls
1900
 
        transport = a_bzrdir.get_branch_transport(None)
1901
 
        control_files = lockable_files.LockableFiles(transport, 'lock',
1902
 
                                                     lockdir.LockDir)
1903
 
        return cls(_format=cls,
1904
 
            _control_files=control_files,
1905
 
            a_bzrdir=a_bzrdir,
1906
 
            _repository=a_bzrdir.find_repository())
1907
 
 
1908
 
    @classmethod
1909
 
    def is_supported(cls):
1910
 
        return True
1911
 
 
1912
 
    def _make_tags(self):
1913
 
        return BasicTags(self)
1914
 
 
1915
 
    @classmethod
1916
 
    def supports_tags(cls):
1917
 
        return True
1918
 
 
1919
 
 
1920
 
BranchFormat.register_format(BzrBranchExperimental)
1921
 
 
1922
 
 
1923
 
class BzrBranch6(BzrBranch5):
1924
 
 
1925
 
    @needs_read_lock
1926
 
    def last_revision_info(self):
1927
 
        revision_string = self.control_files.get('last-revision').read()
1928
 
        revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
1929
 
        revision_id = cache_utf8.get_cached_utf8(revision_id)
1930
 
        revno = int(revno)
1931
 
        return revno, revision_id
1932
 
 
1933
 
    def last_revision(self):
1934
 
        """Return last revision id, or None"""
1935
 
        revision_id = self.last_revision_info()[1]
1936
 
        if revision_id == _mod_revision.NULL_REVISION:
1937
 
            revision_id = None
1938
 
        return revision_id
1939
 
 
1940
 
    def _write_last_revision_info(self, revno, revision_id):
1941
 
        """Simply write out the revision id, with no checks.
1942
 
 
1943
 
        Use set_last_revision_info to perform this safely.
1944
 
 
1945
 
        Does not update the revision_history cache.
1946
 
        Intended to be called by set_last_revision_info and
1947
 
        _write_revision_history.
1948
 
        """
1949
 
        if revision_id is None:
1950
 
            revision_id = 'null:'
1951
 
        out_string = '%d %s\n' % (revno, revision_id)
1952
 
        self.control_files.put_bytes('last-revision', out_string)
1953
 
 
1954
 
    @needs_write_lock
1955
 
    def set_last_revision_info(self, revno, revision_id):
1956
 
        revision_id = osutils.safe_revision_id(revision_id)
1957
 
        if self._get_append_revisions_only():
1958
 
            self._check_history_violation(revision_id)
1959
 
        self._write_last_revision_info(revno, revision_id)
1960
 
        self._clear_cached_state()
1961
 
 
1962
 
    def _check_history_violation(self, revision_id):
1963
 
        last_revision = self.last_revision()
1964
 
        if last_revision is None:
1965
 
            return
1966
 
        if last_revision not in self._lefthand_history(revision_id):
1967
 
            raise errors.AppendRevisionsOnlyViolation(self.base)
1968
 
 
1969
 
    def _gen_revision_history(self):
1970
 
        """Generate the revision history from last revision
1971
 
        """
1972
 
        history = list(self.repository.iter_reverse_revision_history(
1973
 
            self.last_revision()))
1974
 
        history.reverse()
1975
 
        return history
1976
 
 
1977
 
    def _write_revision_history(self, history):
1978
 
        """Factored out of set_revision_history.
1979
 
 
1980
 
        This performs the actual writing to disk, with format-specific checks.
1981
 
        It is intended to be called by BzrBranch5.set_revision_history.
1982
 
        """
1983
 
        if len(history) == 0:
1984
 
            last_revision = 'null:'
1985
 
        else:
1986
 
            if history != self._lefthand_history(history[-1]):
1987
 
                raise errors.NotLefthandHistory(history)
1988
 
            last_revision = history[-1]
1989
 
        if self._get_append_revisions_only():
1990
 
            self._check_history_violation(last_revision)
1991
 
        self._write_last_revision_info(len(history), last_revision)
1992
 
 
1993
 
    @needs_write_lock
1994
 
    def append_revision(self, *revision_ids):
1995
 
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1996
 
        if len(revision_ids) == 0:
1997
 
            return
1998
 
        prev_revno, prev_revision = self.last_revision_info()
1999
 
        for revision in self.repository.get_revisions(revision_ids):
2000
 
            if prev_revision == _mod_revision.NULL_REVISION:
2001
 
                if revision.parent_ids != []:
2002
 
                    raise errors.NotLeftParentDescendant(self, prev_revision,
2003
 
                                                         revision.revision_id)
2004
 
            else:
2005
 
                if revision.parent_ids[0] != prev_revision:
2006
 
                    raise errors.NotLeftParentDescendant(self, prev_revision,
2007
 
                                                         revision.revision_id)
2008
 
            prev_revision = revision.revision_id
2009
 
        self.set_last_revision_info(prev_revno + len(revision_ids),
2010
 
                                    revision_ids[-1])
2011
 
 
2012
 
    @needs_write_lock
2013
 
    def _set_parent_location(self, url):
2014
 
        """Set the parent branch"""
2015
 
        self._set_config_location('parent_location', url, make_relative=True)
2016
 
 
2017
 
    @needs_read_lock
2018
 
    def _get_parent_location(self):
2019
 
        """Set the parent branch"""
2020
 
        return self._get_config_location('parent_location')
2021
 
 
2022
 
    def set_push_location(self, location):
2023
 
        """See Branch.set_push_location."""
2024
 
        self._set_config_location('push_location', location)
2025
 
 
2026
 
    def set_bound_location(self, location):
2027
 
        """See Branch.set_push_location."""
2028
 
        result = None
2029
 
        config = self.get_config()
2030
 
        if location is None:
2031
 
            if config.get_user_option('bound') != 'True':
2032
 
                return False
2033
 
            else:
2034
 
                config.set_user_option('bound', 'False')
2035
 
                return True
2036
 
        else:
2037
 
            self._set_config_location('bound_location', location,
2038
 
                                      config=config)
2039
 
            config.set_user_option('bound', 'True')
2040
 
        return True
2041
 
 
2042
 
    def _get_bound_location(self, bound):
2043
 
        """Return the bound location in the config file.
2044
 
 
2045
 
        Return None if the bound parameter does not match"""
2046
 
        config = self.get_config()
2047
 
        config_bound = (config.get_user_option('bound') == 'True')
2048
 
        if config_bound != bound:
2049
 
            return None
2050
 
        return self._get_config_location('bound_location', config=config)
2051
 
 
2052
 
    def get_bound_location(self):
2053
 
        """See Branch.set_push_location."""
2054
 
        return self._get_bound_location(True)
2055
 
 
2056
 
    def get_old_bound_location(self):
2057
 
        """See Branch.get_old_bound_location"""
2058
 
        return self._get_bound_location(False)
2059
 
 
2060
 
    def set_append_revisions_only(self, enabled):
2061
 
        if enabled:
2062
 
            value = 'True'
2063
 
        else:
2064
 
            value = 'False'
2065
 
        self.get_config().set_user_option('append_revisions_only', value)
2066
 
 
2067
 
    def _get_append_revisions_only(self):
2068
 
        value = self.get_config().get_user_option('append_revisions_only')
2069
 
        return value == 'True'
2070
 
 
2071
 
    def _synchronize_history(self, destination, revision_id):
2072
 
        """Synchronize last revision and revision history between branches.
2073
 
 
2074
 
        This version is most efficient when the destination is also a
2075
 
        BzrBranch6, but works for BzrBranch5, as long as the destination's
2076
 
        repository contains all the lefthand ancestors of the intended
2077
 
        last_revision.  If not, set_last_revision_info will fail.
2078
 
 
2079
 
        :param destination: The branch to copy the history into
2080
 
        :param revision_id: The revision-id to truncate history at.  May
2081
 
          be None to copy complete history.
2082
 
        """
2083
 
        if revision_id is None:
2084
 
            revno, revision_id = self.last_revision_info()
2085
 
        else:
2086
 
            # To figure out the revno for a random revision, we need to build
2087
 
            # the revision history, and count its length.
2088
 
            # We don't care about the order, just how long it is.
2089
 
            # Alternatively, we could start at the current location, and count
2090
 
            # backwards. But there is no guarantee that we will find it since
2091
 
            # it may be a merged revision.
2092
 
            revno = len(list(self.repository.iter_reverse_revision_history(
2093
 
                                                                revision_id)))
2094
 
        destination.set_last_revision_info(revno, revision_id)
2095
 
 
2096
 
    def _make_tags(self):
2097
 
        return BasicTags(self)
 
1327
    def __init__(self, transport_server, transport_readonly_server, formats):
 
1328
        self._transport_server = transport_server
 
1329
        self._transport_readonly_server = transport_readonly_server
 
1330
        self._formats = formats
 
1331
    
 
1332
    def adapt(self, test):
 
1333
        result = TestSuite()
 
1334
        for branch_format, bzrdir_format in self._formats:
 
1335
            new_test = deepcopy(test)
 
1336
            new_test.transport_server = self._transport_server
 
1337
            new_test.transport_readonly_server = self._transport_readonly_server
 
1338
            new_test.bzrdir_format = bzrdir_format
 
1339
            new_test.branch_format = branch_format
 
1340
            def make_new_test_id():
 
1341
                new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
 
1342
                return lambda: new_id
 
1343
            new_test.id = make_new_test_id()
 
1344
            result.addTest(new_test)
 
1345
        return result
2098
1346
 
2099
1347
 
2100
1348
######################################################################
2101
 
# results of operations
2102
 
 
2103
 
 
2104
 
class _Result(object):
2105
 
 
2106
 
    def _show_tag_conficts(self, to_file):
2107
 
        if not getattr(self, 'tag_conflicts', None):
2108
 
            return
2109
 
        to_file.write('Conflicting tags:\n')
2110
 
        for name, value1, value2 in self.tag_conflicts:
2111
 
            to_file.write('    %s\n' % (name, ))
2112
 
 
2113
 
 
2114
 
class PullResult(_Result):
2115
 
    """Result of a Branch.pull operation.
2116
 
 
2117
 
    :ivar old_revno: Revision number before pull.
2118
 
    :ivar new_revno: Revision number after pull.
2119
 
    :ivar old_revid: Tip revision id before pull.
2120
 
    :ivar new_revid: Tip revision id after pull.
2121
 
    :ivar source_branch: Source (local) branch object.
2122
 
    :ivar master_branch: Master branch of the target, or None.
2123
 
    :ivar target_branch: Target/destination branch object.
2124
 
    """
2125
 
 
2126
 
    def __int__(self):
2127
 
        # DEPRECATED: pull used to return the change in revno
2128
 
        return self.new_revno - self.old_revno
2129
 
 
2130
 
    def report(self, to_file):
2131
 
        if self.old_revid == self.new_revid:
2132
 
            to_file.write('No revisions to pull.\n')
2133
 
        else:
2134
 
            to_file.write('Now on revision %d.\n' % self.new_revno)
2135
 
        self._show_tag_conficts(to_file)
2136
 
 
2137
 
 
2138
 
class PushResult(_Result):
2139
 
    """Result of a Branch.push operation.
2140
 
 
2141
 
    :ivar old_revno: Revision number before push.
2142
 
    :ivar new_revno: Revision number after push.
2143
 
    :ivar old_revid: Tip revision id before push.
2144
 
    :ivar new_revid: Tip revision id after push.
2145
 
    :ivar source_branch: Source branch object.
2146
 
    :ivar master_branch: Master branch of the target, or None.
2147
 
    :ivar target_branch: Target/destination branch object.
2148
 
    """
2149
 
 
2150
 
    def __int__(self):
2151
 
        # DEPRECATED: push used to return the change in revno
2152
 
        return self.new_revno - self.old_revno
2153
 
 
2154
 
    def report(self, to_file):
2155
 
        """Write a human-readable description of the result."""
2156
 
        if self.old_revid == self.new_revid:
2157
 
            to_file.write('No new revisions to push.\n')
2158
 
        else:
2159
 
            to_file.write('Pushed up to revision %d.\n' % self.new_revno)
2160
 
        self._show_tag_conficts(to_file)
2161
 
 
2162
 
 
2163
 
class BranchCheckResult(object):
2164
 
    """Results of checking branch consistency.
2165
 
 
2166
 
    :see: Branch.check
2167
 
    """
2168
 
 
2169
 
    def __init__(self, branch):
2170
 
        self.branch = branch
2171
 
 
2172
 
    def report_results(self, verbose):
2173
 
        """Report the check results via trace.note.
2174
 
        
2175
 
        :param verbose: Requests more detailed display of what was checked,
2176
 
            if any.
2177
 
        """
2178
 
        note('checked branch %s format %s',
2179
 
             self.branch.base,
2180
 
             self.branch._format)
2181
 
 
2182
 
 
2183
 
class Converter5to6(object):
2184
 
    """Perform an in-place upgrade of format 5 to format 6"""
2185
 
 
2186
 
    def convert(self, branch):
2187
 
        # Data for 5 and 6 can peacefully coexist.
2188
 
        format = BzrBranchFormat6()
2189
 
        new_branch = format.open(branch.bzrdir, _found=True)
2190
 
 
2191
 
        # Copy source data into target
2192
 
        new_branch.set_last_revision_info(*branch.last_revision_info())
2193
 
        new_branch.set_parent(branch.get_parent())
2194
 
        new_branch.set_bound_location(branch.get_bound_location())
2195
 
        new_branch.set_push_location(branch.get_push_location())
2196
 
 
2197
 
        # New branch has no tags by default
2198
 
        new_branch.tags._set_tag_dict({})
2199
 
 
2200
 
        # Copying done; now update target format
2201
 
        new_branch.control_files.put_utf8('format',
2202
 
            format.get_format_string())
2203
 
 
2204
 
        # Clean up old files
2205
 
        new_branch.control_files._transport.delete('revision-history')
2206
 
        try:
2207
 
            branch.set_parent(None)
2208
 
        except NoSuchFile:
2209
 
            pass
2210
 
        branch.set_bound_location(None)
 
1349
# predicates
 
1350
 
 
1351
 
 
1352
@deprecated_function(zero_eight)
 
1353
def ScratchBranch(*args, **kwargs):
 
1354
    """See bzrlib.bzrdir.ScratchDir."""
 
1355
    d = ScratchDir(*args, **kwargs)
 
1356
    return d.open_branch()
 
1357
 
 
1358
 
 
1359
@deprecated_function(zero_eight)
 
1360
def is_control_file(*args, **kwargs):
 
1361
    """See bzrlib.workingtree.is_control_file."""
 
1362
    return bzrlib.workingtree.is_control_file(*args, **kwargs)