← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Olaf Conradi
  • Date: 2006-03-28 23:30:02 UTC
  • mto: (1661.1.1 bzr.mbp.remember)
  • mto: This revision was merged to the branch mainline in revision 1663.
  • Revision ID: olaf@conradi.org-20060328233002-f6262df0e19c1963
Added testcases for using pull with --remember. Moved remember code to
beginning of cmd_pull. This remembers the location in case of a failure
during pull.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/branch.py
1
 
# Copyright (C) 2005 Canonical Ltd
2
 
 
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
 
 
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
 
18
from copy import deepcopy
 
19
from cStringIO import StringIO
 
20
import errno
 
21
import os
 
22
import shutil
18
23
import sys
19
 
import os
20
 
import errno
 
24
from unittest import TestSuite
21
25
from warnings import warn
22
 
from cStringIO import StringIO
23
 
 
24
26
 
25
27
import bzrlib
26
 
from bzrlib.inventory import InventoryEntry
27
 
import bzrlib.inventory as inventory
28
 
from bzrlib.trace import mutter, note
29
 
from bzrlib.osutils import (isdir, quotefn, compact_date, rand_bytes, 
30
 
                            rename, splitpath, sha_file, appendpath, 
31
 
                            file_kind, abspath)
 
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
32
import bzrlib.errors as errors
33
33
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
34
34
                           NoSuchRevision, HistoryMissing, NotBranchError,
35
 
                           DivergedBranches, LockError, UnlistableStore,
36
 
                           UnlistableBranch, NoSuchFile, NotVersionedError)
 
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
 
42
from bzrlib.lockable_files import LockableFiles, TransportLock
 
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
                            )
37
49
from bzrlib.textui import show_status
38
 
from bzrlib.revision import Revision, is_ancestor, get_intervening_revisions
39
 
 
40
 
from bzrlib.delta import compare_trees
 
50
from bzrlib.trace import mutter, note
41
51
from bzrlib.tree import EmptyTree, RevisionTree
42
 
from bzrlib.inventory import Inventory
 
52
from bzrlib.repository import Repository
 
53
from bzrlib.revision import (
 
54
                             get_intervening_revisions,
 
55
                             is_ancestor,
 
56
                             NULL_REVISION,
 
57
                             Revision,
 
58
                             )
43
59
from bzrlib.store import copy_all
44
 
from bzrlib.store.compressed_text import CompressedTextStore
45
 
from bzrlib.store.text import TextStore
46
 
from bzrlib.store.weave import WeaveStore
47
 
from bzrlib.testament import Testament
 
60
from bzrlib.symbol_versioning import *
48
61
import bzrlib.transactions as transactions
49
62
from bzrlib.transport import Transport, get_transport
 
63
from bzrlib.tree import EmptyTree, RevisionTree
 
64
import bzrlib.ui
50
65
import bzrlib.xml5
51
 
import bzrlib.ui
52
66
 
53
67
 
54
68
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
55
69
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
56
70
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
57
 
## TODO: Maybe include checks for common corruption of newlines, etc?
58
 
 
 
71
 
 
72
 
 
73
# TODO: Maybe include checks for common corruption of newlines, etc?
59
74
 
60
75
# TODO: Some operations like log might retrieve the same revisions
61
76
# repeatedly to calculate deltas.  We could perhaps have a weakref
62
77
# cache in memory to make this faster.  In general anything can be
63
 
# cached in memory between lock and unlock operations.
64
 
 
65
 
def find_branch(*ignored, **ignored_too):
66
 
    # XXX: leave this here for about one release, then remove it
67
 
    raise NotImplementedError('find_branch() is not supported anymore, '
68
 
                              'please use one of the new branch constructors')
69
 
 
70
 
 
71
 
def needs_read_lock(unbound):
72
 
    """Decorate unbound to take out and release a read lock."""
73
 
    def decorated(self, *args, **kwargs):
74
 
        self.lock_read()
75
 
        try:
76
 
            return unbound(self, *args, **kwargs)
77
 
        finally:
78
 
            self.unlock()
79
 
    return decorated
80
 
 
81
 
 
82
 
def needs_write_lock(unbound):
83
 
    """Decorate unbound to take out and release a write lock."""
84
 
    def decorated(self, *args, **kwargs):
85
 
        self.lock_write()
86
 
        try:
87
 
            return unbound(self, *args, **kwargs)
88
 
        finally:
89
 
            self.unlock()
90
 
    return decorated
 
78
# cached in memory between lock and unlock operations. .. nb thats
 
79
# what the transaction identity map provides
 
80
 
91
81
 
92
82
######################################################################
93
83
# branch objects
98
88
    base
99
89
        Base directory/url of the branch.
100
90
    """
 
91
    # this is really an instance variable - FIXME move it there
 
92
    # - RBC 20060112
101
93
    base = None
102
94
 
103
95
    def __init__(self, *ignored, **ignored_too):
104
96
        raise NotImplementedError('The Branch class is abstract')
105
97
 
106
98
    @staticmethod
 
99
    @deprecated_method(zero_eight)
107
100
    def open_downlevel(base):
108
 
        """Open a branch which may be of an old format.
109
 
        
110
 
        Only local branches are supported."""
111
 
        return _Branch(get_transport(base), relax_version_check=True)
 
101
        """Open a branch which may be of an old format."""
 
102
        return Branch.open(base, _unsupported=True)
112
103
        
113
104
    @staticmethod
114
 
    def open(base):
115
 
        """Open an existing branch, rooted at 'base' (url)"""
116
 
        t = get_transport(base)
117
 
        mutter("trying to open %r with transport %r", base, t)
118
 
        return _Branch(t)
 
105
    def open(base, _unsupported=False):
 
106
        """Open the repository rooted at base.
 
107
 
 
108
        For instance, if the repository is at URL/.bzr/repository,
 
109
        Repository.open(URL) -> a Repository instance.
 
110
        """
 
111
        control = bzrdir.BzrDir.open(base, _unsupported)
 
112
        return control.open_branch(_unsupported)
119
113
 
120
114
    @staticmethod
121
115
    def open_containing(url):
125
119
 
126
120
        Basically we keep looking up until we find the control directory or
127
121
        run into the root.  If there isn't one, raises NotBranchError.
 
122
        If there is one and it is either an unrecognised format or an unsupported 
 
123
        format, UnknownFormatError or UnsupportedFormatError are raised.
128
124
        If there is one, it is returned, along with the unused portion of url.
129
125
        """
130
 
        t = get_transport(url)
131
 
        while True:
132
 
            try:
133
 
                return _Branch(t), t.relpath(url)
134
 
            except NotBranchError:
135
 
                pass
136
 
            new_t = t.clone('..')
137
 
            if new_t.base == t.base:
138
 
                # reached the root, whatever that may be
139
 
                raise NotBranchError(path=url)
140
 
            t = new_t
 
126
        control, relpath = bzrdir.BzrDir.open_containing(url)
 
127
        return control.open_branch(), relpath
141
128
 
142
129
    @staticmethod
 
130
    @deprecated_function(zero_eight)
143
131
    def initialize(base):
144
 
        """Create a new branch, rooted at 'base' (url)"""
145
 
        t = get_transport(base)
146
 
        return _Branch(t, init=True)
 
132
        """Create a new working tree and branch, rooted at 'base' (url)
 
133
 
 
134
        NOTE: This will soon be deprecated in favour of creation
 
135
        through a BzrDir.
 
136
        """
 
137
        return bzrdir.BzrDir.create_standalone_workingtree(base).branch
147
138
 
148
139
    def setup_caching(self, cache_root):
149
140
        """Subclasses that care about caching should override this, and set
150
141
        up cached stores located under cache_root.
151
142
        """
 
143
        # seems to be unused, 2006-01-13 mbp
 
144
        warn('%s is deprecated' % self.setup_caching)
152
145
        self.cache_root = cache_root
153
146
 
154
 
 
155
 
class _Branch(Branch):
 
147
    def _get_nick(self):
 
148
        cfg = self.tree_config()
 
149
        return cfg.get_option(u"nickname", default=self.base.split('/')[-2])
 
150
 
 
151
    def _set_nick(self, nick):
 
152
        cfg = self.tree_config()
 
153
        cfg.set_option(nick, "nickname")
 
154
        assert cfg.get_option("nickname") == nick
 
155
 
 
156
    nick = property(_get_nick, _set_nick)
 
157
        
 
158
    def lock_write(self):
 
159
        raise NotImplementedError('lock_write is abstract')
 
160
        
 
161
    def lock_read(self):
 
162
        raise NotImplementedError('lock_read is abstract')
 
163
 
 
164
    def unlock(self):
 
165
        raise NotImplementedError('unlock is abstract')
 
166
 
 
167
    def peek_lock_mode(self):
 
168
        """Return lock mode for the Branch: 'r', 'w' or None"""
 
169
        raise NotImplementedError(self.peek_lock_mode)
 
170
 
 
171
    def abspath(self, name):
 
172
        """Return absolute filename for something in the branch
 
173
        
 
174
        XXX: Robert Collins 20051017 what is this used for? why is it a branch
 
175
        method and not a tree method.
 
176
        """
 
177
        raise NotImplementedError('abspath is abstract')
 
178
 
 
179
    def bind(self, other):
 
180
        """Bind the local branch the other branch.
 
181
 
 
182
        :param other: The branch to bind to
 
183
        :type other: Branch
 
184
        """
 
185
        raise errors.UpgradeRequired(self.base)
 
186
 
 
187
    @needs_write_lock
 
188
    def fetch(self, from_branch, last_revision=None, pb=None):
 
189
        """Copy revisions from from_branch into this branch.
 
190
 
 
191
        :param from_branch: Where to copy from.
 
192
        :param last_revision: What revision to stop at (None for at the end
 
193
                              of the branch.
 
194
        :param pb: An optional progress bar to use.
 
195
 
 
196
        Returns the copied revision count and the failed revisions in a tuple:
 
197
        (copied, failures).
 
198
        """
 
199
        if self.base == from_branch.base:
 
200
            raise Exception("can't fetch from a branch to itself %s, %s" % 
 
201
                            (self.base, to_branch.base))
 
202
        if pb is None:
 
203
            nested_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
204
            pb = nested_pb
 
205
        else:
 
206
            nested_pb = None
 
207
 
 
208
        from_branch.lock_read()
 
209
        try:
 
210
            if last_revision is None:
 
211
                pb.update('get source history')
 
212
                from_history = from_branch.revision_history()
 
213
                if from_history:
 
214
                    last_revision = from_history[-1]
 
215
                else:
 
216
                    # no history in the source branch
 
217
                    last_revision = NULL_REVISION
 
218
            return self.repository.fetch(from_branch.repository,
 
219
                                         revision_id=last_revision,
 
220
                                         pb=nested_pb)
 
221
        finally:
 
222
            if nested_pb is not None:
 
223
                nested_pb.finished()
 
224
            from_branch.unlock()
 
225
 
 
226
    def get_bound_location(self):
 
227
        """Return the URL of the rbanch we are bound to.
 
228
 
 
229
        Older format branches cannot bind, please be sure to use a metadir
 
230
        branch.
 
231
        """
 
232
        return None
 
233
 
 
234
    def get_master_branch(self):
 
235
        """Return the branch we are bound to.
 
236
        
 
237
        :return: Either a Branch, or None
 
238
        """
 
239
        return None
 
240
 
 
241
    def get_root_id(self):
 
242
        """Return the id of this branches root"""
 
243
        raise NotImplementedError('get_root_id is abstract')
 
244
 
 
245
    def print_file(self, file, revision_id):
 
246
        """Print `file` to stdout."""
 
247
        raise NotImplementedError('print_file is abstract')
 
248
 
 
249
    def append_revision(self, *revision_ids):
 
250
        raise NotImplementedError('append_revision is abstract')
 
251
 
 
252
    def set_revision_history(self, rev_history):
 
253
        raise NotImplementedError('set_revision_history is abstract')
 
254
 
 
255
    def revision_history(self):
 
256
        """Return sequence of revision hashes on to this branch."""
 
257
        raise NotImplementedError('revision_history is abstract')
 
258
 
 
259
    def revno(self):
 
260
        """Return current revision number for this branch.
 
261
 
 
262
        That is equivalent to the number of revisions committed to
 
263
        this branch.
 
264
        """
 
265
        return len(self.revision_history())
 
266
 
 
267
    def unbind(self):
 
268
        """Older format branches cannot bind or unbind."""
 
269
        raise errors.UpgradeRequired(self.base)
 
270
 
 
271
    def last_revision(self):
 
272
        """Return last patch hash, or None if no history."""
 
273
        ph = self.revision_history()
 
274
        if ph:
 
275
            return ph[-1]
 
276
        else:
 
277
            return None
 
278
 
 
279
    def missing_revisions(self, other, stop_revision=None):
 
280
        """Return a list of new revisions that would perfectly fit.
 
281
        
 
282
        If self and other have not diverged, return a list of the revisions
 
283
        present in other, but missing from self.
 
284
 
 
285
        >>> from bzrlib.workingtree import WorkingTree
 
286
        >>> bzrlib.trace.silent = True
 
287
        >>> d1 = bzrdir.ScratchDir()
 
288
        >>> br1 = d1.open_branch()
 
289
        >>> wt1 = d1.open_workingtree()
 
290
        >>> d2 = bzrdir.ScratchDir()
 
291
        >>> br2 = d2.open_branch()
 
292
        >>> wt2 = d2.open_workingtree()
 
293
        >>> br1.missing_revisions(br2)
 
294
        []
 
295
        >>> wt2.commit("lala!", rev_id="REVISION-ID-1")
 
296
        >>> br1.missing_revisions(br2)
 
297
        [u'REVISION-ID-1']
 
298
        >>> br2.missing_revisions(br1)
 
299
        []
 
300
        >>> wt1.commit("lala!", rev_id="REVISION-ID-1")
 
301
        >>> br1.missing_revisions(br2)
 
302
        []
 
303
        >>> wt2.commit("lala!", rev_id="REVISION-ID-2A")
 
304
        >>> br1.missing_revisions(br2)
 
305
        [u'REVISION-ID-2A']
 
306
        >>> wt1.commit("lala!", rev_id="REVISION-ID-2B")
 
307
        >>> br1.missing_revisions(br2)
 
308
        Traceback (most recent call last):
 
309
        DivergedBranches: These branches have diverged.  Try merge.
 
310
        """
 
311
        self_history = self.revision_history()
 
312
        self_len = len(self_history)
 
313
        other_history = other.revision_history()
 
314
        other_len = len(other_history)
 
315
        common_index = min(self_len, other_len) -1
 
316
        if common_index >= 0 and \
 
317
            self_history[common_index] != other_history[common_index]:
 
318
            raise DivergedBranches(self, other)
 
319
 
 
320
        if stop_revision is None:
 
321
            stop_revision = other_len
 
322
        else:
 
323
            assert isinstance(stop_revision, int)
 
324
            if stop_revision > other_len:
 
325
                raise bzrlib.errors.NoSuchRevision(self, stop_revision)
 
326
        return other_history[self_len:stop_revision]
 
327
 
 
328
    def update_revisions(self, other, stop_revision=None):
 
329
        """Pull in new perfect-fit revisions.
 
330
 
 
331
        :param other: Another Branch to pull from
 
332
        :param stop_revision: Updated until the given revision
 
333
        :return: None
 
334
        """
 
335
        raise NotImplementedError('update_revisions is abstract')
 
336
 
 
337
    def pullable_revisions(self, other, stop_revision):
 
338
        raise NotImplementedError('pullable_revisions is abstract')
 
339
        
 
340
    def revision_id_to_revno(self, revision_id):
 
341
        """Given a revision id, return its revno"""
 
342
        if revision_id is None:
 
343
            return 0
 
344
        history = self.revision_history()
 
345
        try:
 
346
            return history.index(revision_id) + 1
 
347
        except ValueError:
 
348
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
 
349
 
 
350
    def get_rev_id(self, revno, history=None):
 
351
        """Find the revision id of the specified revno."""
 
352
        if revno == 0:
 
353
            return None
 
354
        if history is None:
 
355
            history = self.revision_history()
 
356
        elif revno <= 0 or revno > len(history):
 
357
            raise bzrlib.errors.NoSuchRevision(self, revno)
 
358
        return history[revno - 1]
 
359
 
 
360
    def pull(self, source, overwrite=False, stop_revision=None):
 
361
        raise NotImplementedError('pull is abstract')
 
362
 
 
363
    def basis_tree(self):
 
364
        """Return `Tree` object for last revision.
 
365
 
 
366
        If there are no revisions yet, return an `EmptyTree`.
 
367
        """
 
368
        return self.repository.revision_tree(self.last_revision())
 
369
 
 
370
    def rename_one(self, from_rel, to_rel):
 
371
        """Rename one file.
 
372
 
 
373
        This can change the directory or the filename or both.
 
374
        """
 
375
        raise NotImplementedError('rename_one is abstract')
 
376
 
 
377
    def move(self, from_paths, to_name):
 
378
        """Rename files.
 
379
 
 
380
        to_name must exist as a versioned directory.
 
381
 
 
382
        If to_name exists and is a directory, the files are moved into
 
383
        it, keeping their old names.  If it is a directory, 
 
384
 
 
385
        Note that to_name is only the last component of the new name;
 
386
        this doesn't change the directory.
 
387
 
 
388
        This returns a list of (from_path, to_path) pairs for each
 
389
        entry that is moved.
 
390
        """
 
391
        raise NotImplementedError('move is abstract')
 
392
 
 
393
    def get_parent(self):
 
394
        """Return the parent location of the branch.
 
395
 
 
396
        This is the default location for push/pull/missing.  The usual
 
397
        pattern is that the user can override it by specifying a
 
398
        location.
 
399
        """
 
400
        raise NotImplementedError('get_parent is abstract')
 
401
 
 
402
    def get_push_location(self):
 
403
        """Return the None or the location to push this branch to."""
 
404
        raise NotImplementedError('get_push_location is abstract')
 
405
 
 
406
    def set_push_location(self, location):
 
407
        """Set a new push location for this branch."""
 
408
        raise NotImplementedError('set_push_location is abstract')
 
409
 
 
410
    def set_parent(self, url):
 
411
        raise NotImplementedError('set_parent is abstract')
 
412
 
 
413
    @needs_write_lock
 
414
    def update(self):
 
415
        """Synchronise this branch with the master branch if any. 
 
416
 
 
417
        :return: None or the last_revision pivoted out during the update.
 
418
        """
 
419
        return None
 
420
 
 
421
    def check_revno(self, revno):
 
422
        """\
 
423
        Check whether a revno corresponds to any revision.
 
424
        Zero (the NULL revision) is considered valid.
 
425
        """
 
426
        if revno != 0:
 
427
            self.check_real_revno(revno)
 
428
            
 
429
    def check_real_revno(self, revno):
 
430
        """\
 
431
        Check whether a revno corresponds to a real revision.
 
432
        Zero (the NULL revision) is considered invalid
 
433
        """
 
434
        if revno < 1 or revno > self.revno():
 
435
            raise InvalidRevisionNumber(revno)
 
436
 
 
437
    @needs_read_lock
 
438
    def clone(self, *args, **kwargs):
 
439
        """Clone this branch into to_bzrdir preserving all semantic values.
 
440
        
 
441
        revision_id: if not None, the revision history in the new branch will
 
442
                     be truncated to end with revision_id.
 
443
        """
 
444
        # for API compatability, until 0.8 releases we provide the old api:
 
445
        # def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
 
446
        # after 0.8 releases, the *args and **kwargs should be changed:
 
447
        # def clone(self, to_bzrdir, revision_id=None):
 
448
        if (kwargs.get('to_location', None) or
 
449
            kwargs.get('revision', None) or
 
450
            kwargs.get('basis_branch', None) or
 
451
            (len(args) and isinstance(args[0], basestring))):
 
452
            # backwards compatability api:
 
453
            warn("Branch.clone() has been deprecated for BzrDir.clone() from"
 
454
                 " bzrlib 0.8.", DeprecationWarning, stacklevel=3)
 
455
            # get basis_branch
 
456
            if len(args) > 2:
 
457
                basis_branch = args[2]
 
458
            else:
 
459
                basis_branch = kwargs.get('basis_branch', None)
 
460
            if basis_branch:
 
461
                basis = basis_branch.bzrdir
 
462
            else:
 
463
                basis = None
 
464
            # get revision
 
465
            if len(args) > 1:
 
466
                revision_id = args[1]
 
467
            else:
 
468
                revision_id = kwargs.get('revision', None)
 
469
            # get location
 
470
            if len(args):
 
471
                url = args[0]
 
472
            else:
 
473
                # no default to raise if not provided.
 
474
                url = kwargs.get('to_location')
 
475
            return self.bzrdir.clone(url,
 
476
                                     revision_id=revision_id,
 
477
                                     basis=basis).open_branch()
 
478
        # new cleaner api.
 
479
        # generate args by hand 
 
480
        if len(args) > 1:
 
481
            revision_id = args[1]
 
482
        else:
 
483
            revision_id = kwargs.get('revision_id', None)
 
484
        if len(args):
 
485
            to_bzrdir = args[0]
 
486
        else:
 
487
            # no default to raise if not provided.
 
488
            to_bzrdir = kwargs.get('to_bzrdir')
 
489
        result = self._format.initialize(to_bzrdir)
 
490
        self.copy_content_into(result, revision_id=revision_id)
 
491
        return  result
 
492
 
 
493
    @needs_read_lock
 
494
    def sprout(self, to_bzrdir, revision_id=None):
 
495
        """Create a new line of development from the branch, into to_bzrdir.
 
496
        
 
497
        revision_id: if not None, the revision history in the new branch will
 
498
                     be truncated to end with revision_id.
 
499
        """
 
500
        result = self._format.initialize(to_bzrdir)
 
501
        self.copy_content_into(result, revision_id=revision_id)
 
502
        result.set_parent(self.bzrdir.root_transport.base)
 
503
        return result
 
504
 
 
505
    @needs_read_lock
 
506
    def copy_content_into(self, destination, revision_id=None):
 
507
        """Copy the content of self into destination.
 
508
 
 
509
        revision_id: if not None, the revision history in the new branch will
 
510
                     be truncated to end with revision_id.
 
511
        """
 
512
        new_history = self.revision_history()
 
513
        if revision_id is not None:
 
514
            try:
 
515
                new_history = new_history[:new_history.index(revision_id) + 1]
 
516
            except ValueError:
 
517
                rev = self.repository.get_revision(revision_id)
 
518
                new_history = rev.get_history(self.repository)[1:]
 
519
        destination.set_revision_history(new_history)
 
520
        parent = self.get_parent()
 
521
        if parent:
 
522
            destination.set_parent(parent)
 
523
 
 
524
 
 
525
class BranchFormat(object):
 
526
    """An encapsulation of the initialization and open routines for a format.
 
527
 
 
528
    Formats provide three things:
 
529
     * An initialization routine,
 
530
     * a format string,
 
531
     * an open routine.
 
532
 
 
533
    Formats are placed in an dict by their format string for reference 
 
534
    during branch opening. Its not required that these be instances, they
 
535
    can be classes themselves with class methods - it simply depends on 
 
536
    whether state is needed for a given format or not.
 
537
 
 
538
    Once a format is deprecated, just deprecate the initialize and open
 
539
    methods on the format class. Do not deprecate the object, as the 
 
540
    object will be created every time regardless.
 
541
    """
 
542
 
 
543
    _default_format = None
 
544
    """The default format used for new branches."""
 
545
 
 
546
    _formats = {}
 
547
    """The known formats."""
 
548
 
 
549
    @classmethod
 
550
    def find_format(klass, a_bzrdir):
 
551
        """Return the format for the branch object in a_bzrdir."""
 
552
        try:
 
553
            transport = a_bzrdir.get_branch_transport(None)
 
554
            format_string = transport.get("format").read()
 
555
            return klass._formats[format_string]
 
556
        except NoSuchFile:
 
557
            raise NotBranchError(path=transport.base)
 
558
        except KeyError:
 
559
            raise errors.UnknownFormatError(format_string)
 
560
 
 
561
    @classmethod
 
562
    def get_default_format(klass):
 
563
        """Return the current default format."""
 
564
        return klass._default_format
 
565
 
 
566
    def get_format_string(self):
 
567
        """Return the ASCII format string that identifies this format."""
 
568
        raise NotImplementedError(self.get_format_string)
 
569
 
 
570
    def initialize(self, a_bzrdir):
 
571
        """Create a branch of this format in a_bzrdir."""
 
572
        raise NotImplementedError(self.initialized)
 
573
 
 
574
    def is_supported(self):
 
575
        """Is this format supported?
 
576
 
 
577
        Supported formats can be initialized and opened.
 
578
        Unsupported formats may not support initialization or committing or 
 
579
        some other features depending on the reason for not being supported.
 
580
        """
 
581
        return True
 
582
 
 
583
    def open(self, a_bzrdir, _found=False):
 
584
        """Return the branch object for a_bzrdir
 
585
 
 
586
        _found is a private parameter, do not use it. It is used to indicate
 
587
               if format probing has already be done.
 
588
        """
 
589
        raise NotImplementedError(self.open)
 
590
 
 
591
    @classmethod
 
592
    def register_format(klass, format):
 
593
        klass._formats[format.get_format_string()] = format
 
594
 
 
595
    @classmethod
 
596
    def set_default_format(klass, format):
 
597
        klass._default_format = format
 
598
 
 
599
    @classmethod
 
600
    def unregister_format(klass, format):
 
601
        assert klass._formats[format.get_format_string()] is format
 
602
        del klass._formats[format.get_format_string()]
 
603
 
 
604
 
 
605
class BzrBranchFormat4(BranchFormat):
 
606
    """Bzr branch format 4.
 
607
 
 
608
    This format has:
 
609
     - a revision-history file.
 
610
     - a branch-lock lock file [ to be shared with the bzrdir ]
 
611
    """
 
612
 
 
613
    def initialize(self, a_bzrdir):
 
614
        """Create a branch of this format in a_bzrdir."""
 
615
        mutter('creating branch in %s', a_bzrdir.transport.base)
 
616
        branch_transport = a_bzrdir.get_branch_transport(self)
 
617
        utf8_files = [('revision-history', ''),
 
618
                      ('branch-name', ''),
 
619
                      ]
 
620
        control_files = LockableFiles(branch_transport, 'branch-lock',
 
621
                                      TransportLock)
 
622
        control_files.create_lock()
 
623
        control_files.lock_write()
 
624
        try:
 
625
            for file, content in utf8_files:
 
626
                control_files.put_utf8(file, content)
 
627
        finally:
 
628
            control_files.unlock()
 
629
        return self.open(a_bzrdir, _found=True)
 
630
 
 
631
    def __init__(self):
 
632
        super(BzrBranchFormat4, self).__init__()
 
633
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
 
634
 
 
635
    def open(self, a_bzrdir, _found=False):
 
636
        """Return the branch object for a_bzrdir
 
637
 
 
638
        _found is a private parameter, do not use it. It is used to indicate
 
639
               if format probing has already be done.
 
640
        """
 
641
        if not _found:
 
642
            # we are being called directly and must probe.
 
643
            raise NotImplementedError
 
644
        return BzrBranch(_format=self,
 
645
                         _control_files=a_bzrdir._control_files,
 
646
                         a_bzrdir=a_bzrdir,
 
647
                         _repository=a_bzrdir.open_repository())
 
648
 
 
649
 
 
650
class BzrBranchFormat5(BranchFormat):
 
651
    """Bzr branch format 5.
 
652
 
 
653
    This format has:
 
654
     - a revision-history file.
 
655
     - a format string
 
656
     - a lock dir guarding the branch itself
 
657
     - all of this stored in a branch/ subdirectory
 
658
     - works with shared repositories.
 
659
 
 
660
    This format is new in bzr 0.8.
 
661
    """
 
662
 
 
663
    def get_format_string(self):
 
664
        """See BranchFormat.get_format_string()."""
 
665
        return "Bazaar-NG branch format 5\n"
 
666
        
 
667
    def initialize(self, a_bzrdir):
 
668
        """Create a branch of this format in a_bzrdir."""
 
669
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
 
670
        branch_transport = a_bzrdir.get_branch_transport(self)
 
671
        utf8_files = [('revision-history', ''),
 
672
                      ('branch-name', ''),
 
673
                      ]
 
674
        control_files = LockableFiles(branch_transport, 'lock', LockDir)
 
675
        control_files.create_lock()
 
676
        control_files.lock_write()
 
677
        control_files.put_utf8('format', self.get_format_string())
 
678
        try:
 
679
            for file, content in utf8_files:
 
680
                control_files.put_utf8(file, content)
 
681
        finally:
 
682
            control_files.unlock()
 
683
        return self.open(a_bzrdir, _found=True, )
 
684
 
 
685
    def __init__(self):
 
686
        super(BzrBranchFormat5, self).__init__()
 
687
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
688
 
 
689
    def open(self, a_bzrdir, _found=False):
 
690
        """Return the branch object for a_bzrdir
 
691
 
 
692
        _found is a private parameter, do not use it. It is used to indicate
 
693
               if format probing has already be done.
 
694
        """
 
695
        if not _found:
 
696
            format = BranchFormat.find_format(a_bzrdir)
 
697
            assert format.__class__ == self.__class__
 
698
        transport = a_bzrdir.get_branch_transport(None)
 
699
        control_files = LockableFiles(transport, 'lock', LockDir)
 
700
        return BzrBranch5(_format=self,
 
701
                          _control_files=control_files,
 
702
                          a_bzrdir=a_bzrdir,
 
703
                          _repository=a_bzrdir.find_repository())
 
704
 
 
705
    def __str__(self):
 
706
        return "Bazaar-NG Metadir branch format 5"
 
707
 
 
708
 
 
709
class BranchReferenceFormat(BranchFormat):
 
710
    """Bzr branch reference format.
 
711
 
 
712
    Branch references are used in implementing checkouts, they
 
713
    act as an alias to the real branch which is at some other url.
 
714
 
 
715
    This format has:
 
716
     - A location file
 
717
     - a format string
 
718
    """
 
719
 
 
720
    def get_format_string(self):
 
721
        """See BranchFormat.get_format_string()."""
 
722
        return "Bazaar-NG Branch Reference Format 1\n"
 
723
        
 
724
    def initialize(self, a_bzrdir, target_branch=None):
 
725
        """Create a branch of this format in a_bzrdir."""
 
726
        if target_branch is None:
 
727
            # this format does not implement branch itself, thus the implicit
 
728
            # creation contract must see it as uninitializable
 
729
            raise errors.UninitializableFormat(self)
 
730
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
 
731
        branch_transport = a_bzrdir.get_branch_transport(self)
 
732
        # FIXME rbc 20060209 one j-a-ms encoding branch lands this str() cast is not needed.
 
733
        branch_transport.put('location', StringIO(str(target_branch.bzrdir.root_transport.base)))
 
734
        branch_transport.put('format', StringIO(self.get_format_string()))
 
735
        return self.open(a_bzrdir, _found=True)
 
736
 
 
737
    def __init__(self):
 
738
        super(BranchReferenceFormat, self).__init__()
 
739
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
740
 
 
741
    def _make_reference_clone_function(format, a_branch):
 
742
        """Create a clone() routine for a branch dynamically."""
 
743
        def clone(to_bzrdir, revision_id=None):
 
744
            """See Branch.clone()."""
 
745
            return format.initialize(to_bzrdir, a_branch)
 
746
            # cannot obey revision_id limits when cloning a reference ...
 
747
            # FIXME RBC 20060210 either nuke revision_id for clone, or
 
748
            # emit some sort of warning/error to the caller ?!
 
749
        return clone
 
750
 
 
751
    def open(self, a_bzrdir, _found=False):
 
752
        """Return the branch that the branch reference in a_bzrdir points at.
 
753
 
 
754
        _found is a private parameter, do not use it. It is used to indicate
 
755
               if format probing has already be done.
 
756
        """
 
757
        if not _found:
 
758
            format = BranchFormat.find_format(a_bzrdir)
 
759
            assert format.__class__ == self.__class__
 
760
        transport = a_bzrdir.get_branch_transport(None)
 
761
        real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
 
762
        result = real_bzrdir.open_branch()
 
763
        # this changes the behaviour of result.clone to create a new reference
 
764
        # rather than a copy of the content of the branch.
 
765
        # I did not use a proxy object because that needs much more extensive
 
766
        # testing, and we are only changing one behaviour at the moment.
 
767
        # If we decide to alter more behaviours - i.e. the implicit nickname
 
768
        # then this should be refactored to introduce a tested proxy branch
 
769
        # and a subclass of that for use in overriding clone() and ....
 
770
        # - RBC 20060210
 
771
        result.clone = self._make_reference_clone_function(result)
 
772
        return result
 
773
 
 
774
 
 
775
# formats which have no format string are not discoverable
 
776
# and not independently creatable, so are not registered.
 
777
__default_format = BzrBranchFormat5()
 
778
BranchFormat.register_format(__default_format)
 
779
BranchFormat.register_format(BranchReferenceFormat())
 
780
BranchFormat.set_default_format(__default_format)
 
781
_legacy_formats = [BzrBranchFormat4(),
 
782
                   ]
 
783
 
 
784
class BzrBranch(Branch):
156
785
    """A branch stored in the actual filesystem.
157
786
 
158
787
    Note that it's "local" in the context of the filesystem; it doesn't
159
788
    really matter if it's on an nfs/smb/afs/coda/... share, as long as
160
789
    it's writable, and can be accessed via the normal filesystem API.
161
 
 
162
 
    _lock_mode
163
 
        None, or 'r' or 'w'
164
 
 
165
 
    _lock_count
166
 
        If _lock_mode is true, a positive count of the number of times the
167
 
        lock has been taken.
168
 
 
169
 
    _lock
170
 
        Lock object from bzrlib.lock.
171
790
    """
172
 
    # We actually expect this class to be somewhat short-lived; part of its
173
 
    # purpose is to try to isolate what bits of the branch logic are tied to
174
 
    # filesystem access, so that in a later step, we can extricate them to
175
 
    # a separarte ("storage") class.
176
 
    _lock_mode = None
177
 
    _lock_count = None
178
 
    _lock = None
179
 
    _inventory_weave = None
180
791
    
181
 
    # Map some sort of prefix into a namespace
182
 
    # stuff like "revno:10", "revid:", etc.
183
 
    # This should match a prefix with a function which accepts
184
 
    REVISION_NAMESPACES = {}
185
 
 
186
 
    def push_stores(self, branch_to):
187
 
        """Copy the content of this branches store to branch_to."""
188
 
        if (self._branch_format != branch_to._branch_format
189
 
            or self._branch_format != 4):
190
 
            from bzrlib.fetch import greedy_fetch
191
 
            mutter("falling back to fetch logic to push between %s(%s) and %s(%s)",
192
 
                   self, self._branch_format, branch_to, branch_to._branch_format)
193
 
            greedy_fetch(to_branch=branch_to, from_branch=self,
194
 
                         revision=self.last_revision())
195
 
            return
196
 
 
197
 
        store_pairs = ((self.text_store,      branch_to.text_store),
198
 
                       (self.inventory_store, branch_to.inventory_store),
199
 
                       (self.revision_store,  branch_to.revision_store))
200
 
        try:
201
 
            for from_store, to_store in store_pairs: 
202
 
                copy_all(from_store, to_store)
203
 
        except UnlistableStore:
204
 
            raise UnlistableBranch(from_store)
205
 
 
206
 
    def __init__(self, transport, init=False,
207
 
                 relax_version_check=False):
 
792
    def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
 
793
                 relax_version_check=DEPRECATED_PARAMETER, _format=None,
 
794
                 _control_files=None, a_bzrdir=None, _repository=None):
208
795
        """Create new branch object at a particular location.
209
796
 
210
797
        transport -- A Transport object, defining how to access files.
211
 
                (If a string, transport.transport() will be used to
212
 
                create a Transport object)
213
798
        
214
799
        init -- If True, create new control files in a previously
215
800
             unversioned directory.  If False, the branch must already
219
804
            version is not applied.  This is intended only for
220
805
            upgrade/recovery type use; it's not guaranteed that
221
806
            all operations will work on old format branches.
222
 
 
223
 
        In the test suite, creation of new trees is tested using the
224
 
        `ScratchBranch` class.
225
807
        """
226
 
        assert isinstance(transport, Transport), \
227
 
            "%r is not a Transport" % transport
228
 
        self._transport = transport
229
 
        if init:
230
 
            self._make_control()
231
 
        self._check_format(relax_version_check)
232
 
 
233
 
        def get_store(name, compressed=True, prefixed=False):
234
 
            # FIXME: This approach of assuming stores are all entirely compressed
235
 
            # or entirely uncompressed is tidy, but breaks upgrade from 
236
 
            # some existing branches where there's a mixture; we probably 
237
 
            # still want the option to look for both.
238
 
            relpath = self._rel_controlfilename(name)
239
 
            if compressed:
240
 
                store = CompressedTextStore(self._transport.clone(relpath),
241
 
                                            prefixed=prefixed)
242
 
            else:
243
 
                store = TextStore(self._transport.clone(relpath),
244
 
                                  prefixed=prefixed)
245
 
            #if self._transport.should_cache():
246
 
            #    cache_path = os.path.join(self.cache_root, name)
247
 
            #    os.mkdir(cache_path)
248
 
            #    store = bzrlib.store.CachedStore(store, cache_path)
249
 
            return store
250
 
        def get_weave(name, prefixed=False):
251
 
            relpath = self._rel_controlfilename(name)
252
 
            ws = WeaveStore(self._transport.clone(relpath), prefixed=prefixed)
253
 
            if self._transport.should_cache():
254
 
                ws.enable_cache = True
255
 
            return ws
256
 
 
257
 
        if self._branch_format == 4:
258
 
            self.inventory_store = get_store('inventory-store')
259
 
            self.text_store = get_store('text-store')
260
 
            self.revision_store = get_store('revision-store')
261
 
        elif self._branch_format == 5:
262
 
            self.control_weaves = get_weave('')
263
 
            self.weave_store = get_weave('weaves')
264
 
            self.revision_store = get_store('revision-store', compressed=False)
265
 
        elif self._branch_format == 6:
266
 
            self.control_weaves = get_weave('')
267
 
            self.weave_store = get_weave('weaves', prefixed=True)
268
 
            self.revision_store = get_store('revision-store', compressed=False,
269
 
                                            prefixed=True)
270
 
        self.revision_store.register_suffix('sig')
271
 
        self._transaction = None
 
808
        if a_bzrdir is None:
 
809
            self.bzrdir = bzrdir.BzrDir.open(transport.base)
 
810
        else:
 
811
            self.bzrdir = a_bzrdir
 
812
        self._transport = self.bzrdir.transport.clone('..')
 
813
        self._base = self._transport.base
 
814
        self._format = _format
 
815
        if _control_files is None:
 
816
            raise BzrBadParameterMissing('_control_files')
 
817
        self.control_files = _control_files
 
818
        if deprecated_passed(init):
 
819
            warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
 
820
                 "deprecated as of bzr 0.8. Please use Branch.create().",
 
821
                 DeprecationWarning,
 
822
                 stacklevel=2)
 
823
            if init:
 
824
                # this is slower than before deprecation, oh well never mind.
 
825
                # -> its deprecated.
 
826
                self._initialize(transport.base)
 
827
        self._check_format(_format)
 
828
        if deprecated_passed(relax_version_check):
 
829
            warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
 
830
                 "relax_version_check parameter is deprecated as of bzr 0.8. "
 
831
                 "Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
 
832
                 "open() method.",
 
833
                 DeprecationWarning,
 
834
                 stacklevel=2)
 
835
            if (not relax_version_check
 
836
                and not self._format.is_supported()):
 
837
                raise errors.UnsupportedFormatError(
 
838
                        'sorry, branch format %r not supported' % fmt,
 
839
                        ['use a different bzr version',
 
840
                         'or remove the .bzr directory'
 
841
                         ' and "bzr init" again'])
 
842
        if deprecated_passed(transport):
 
843
            warn("BzrBranch.__init__(transport=XXX...): The transport "
 
844
                 "parameter is deprecated as of bzr 0.8. "
 
845
                 "Please use Branch.open, or bzrdir.open_branch().",
 
846
                 DeprecationWarning,
 
847
                 stacklevel=2)
 
848
        self.repository = _repository
272
849
 
273
850
    def __str__(self):
274
 
        return '%s(%r)' % (self.__class__.__name__, self._transport.base)
275
 
 
 
851
        return '%s(%r)' % (self.__class__.__name__, self.base)
276
852
 
277
853
    __repr__ = __str__
278
854
 
279
 
 
280
855
    def __del__(self):
281
 
        if self._lock_mode or self._lock:
282
 
            # XXX: This should show something every time, and be suitable for
283
 
            # headless operation and embedding
284
 
            warn("branch %r was not explicitly unlocked" % self)
285
 
            self._lock.unlock()
286
 
 
287
856
        # TODO: It might be best to do this somewhere else,
288
857
        # but it is nice for a Branch object to automatically
289
858
        # cache it's information.
290
859
        # Alternatively, we could have the Transport objects cache requests
291
860
        # See the earlier discussion about how major objects (like Branch)
292
861
        # should never expect their __del__ function to run.
 
862
        # XXX: cache_root seems to be unused, 2006-01-13 mbp
293
863
        if hasattr(self, 'cache_root') and self.cache_root is not None:
294
864
            try:
295
 
                import shutil
296
865
                shutil.rmtree(self.cache_root)
297
866
            except:
298
867
                pass
299
868
            self.cache_root = None
300
869
 
301
870
    def _get_base(self):
302
 
        if self._transport:
303
 
            return self._transport.base
304
 
        return None
 
871
        return self._base
305
872
 
306
873
    base = property(_get_base, doc="The URL for the root of this branch.")
307
874
 
308
875
    def _finish_transaction(self):
309
876
        """Exit the current transaction."""
310
 
        if self._transaction is None:
311
 
            raise errors.LockError('Branch %s is not in a transaction' %
312
 
                                   self)
313
 
        transaction = self._transaction
314
 
        self._transaction = None
315
 
        transaction.finish()
 
877
        return self.control_files._finish_transaction()
316
878
 
317
879
    def get_transaction(self):
318
880
        """Return the current active transaction.
319
881
 
320
882
        If no transaction is active, this returns a passthrough object
321
 
        for which all data is immedaitely flushed and no caching happens.
 
883
        for which all data is immediately flushed and no caching happens.
322
884
        """
323
 
        if self._transaction is None:
324
 
            return transactions.PassThroughTransaction()
325
 
        else:
326
 
            return self._transaction
 
885
        # this is an explicit function so that we can do tricky stuff
 
886
        # when the storage in rev_storage is elsewhere.
 
887
        # we probably need to hook the two 'lock a location' and 
 
888
        # 'have a transaction' together more delicately, so that
 
889
        # we can have two locks (branch and storage) and one transaction
 
890
        # ... and finishing the transaction unlocks both, but unlocking
 
891
        # does not. - RBC 20051121
 
892
        return self.control_files.get_transaction()
327
893
 
328
 
    def _set_transaction(self, new_transaction):
 
894
    def _set_transaction(self, transaction):
329
895
        """Set a new active transaction."""
330
 
        if self._transaction is not None:
331
 
            raise errors.LockError('Branch %s is in a transaction already.' %
332
 
                                   self)
333
 
        self._transaction = new_transaction
 
896
        return self.control_files._set_transaction(transaction)
 
897
 
 
898
    def abspath(self, name):
 
899
        """See Branch.abspath."""
 
900
        return self.control_files._transport.abspath(name)
 
901
 
 
902
    def _check_format(self, format):
 
903
        """Identify the branch format if needed.
 
904
 
 
905
        The format is stored as a reference to the format object in
 
906
        self._format for code that needs to check it later.
 
907
 
 
908
        The format parameter is either None or the branch format class
 
909
        used to open this branch.
 
910
 
 
911
        FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
 
912
        """
 
913
        if format is None:
 
914
            format = BzrBranchFormat.find_format(self.bzrdir)
 
915
        self._format = format
 
916
        mutter("got branch format %s", self._format)
 
917
 
 
918
    @needs_read_lock
 
919
    def get_root_id(self):
 
920
        """See Branch.get_root_id."""
 
921
        tree = self.repository.revision_tree(self.last_revision())
 
922
        return tree.inventory.root.file_id
334
923
 
335
924
    def lock_write(self):
336
 
        mutter("lock write: %s (%s)", self, self._lock_count)
337
 
        # TODO: Upgrade locking to support using a Transport,
338
 
        # and potentially a remote locking protocol
339
 
        if self._lock_mode:
340
 
            if self._lock_mode != 'w':
341
 
                raise LockError("can't upgrade to a write lock from %r" %
342
 
                                self._lock_mode)
343
 
            self._lock_count += 1
344
 
        else:
345
 
            self._lock = self._transport.lock_write(
346
 
                    self._rel_controlfilename('branch-lock'))
347
 
            self._lock_mode = 'w'
348
 
            self._lock_count = 1
349
 
            self._set_transaction(transactions.PassThroughTransaction())
 
925
        # TODO: test for failed two phase locks. This is known broken.
 
926
        self.control_files.lock_write()
 
927
        self.repository.lock_write()
350
928
 
351
929
    def lock_read(self):
352
 
        mutter("lock read: %s (%s)", self, self._lock_count)
353
 
        if self._lock_mode:
354
 
            assert self._lock_mode in ('r', 'w'), \
355
 
                   "invalid lock mode %r" % self._lock_mode
356
 
            self._lock_count += 1
357
 
        else:
358
 
            self._lock = self._transport.lock_read(
359
 
                    self._rel_controlfilename('branch-lock'))
360
 
            self._lock_mode = 'r'
361
 
            self._lock_count = 1
362
 
            self._set_transaction(transactions.ReadOnlyTransaction())
363
 
            # 5K may be excessive, but hey, its a knob.
364
 
            self.get_transaction().set_cache_size(5000)
365
 
                        
 
930
        # TODO: test for failed two phase locks. This is known broken.
 
931
        self.control_files.lock_read()
 
932
        self.repository.lock_read()
 
933
 
366
934
    def unlock(self):
367
 
        mutter("unlock: %s (%s)", self, self._lock_count)
368
 
        if not self._lock_mode:
369
 
            raise LockError('branch %r is not locked' % (self))
370
 
 
371
 
        if self._lock_count > 1:
372
 
            self._lock_count -= 1
373
 
        else:
374
 
            self._finish_transaction()
375
 
            self._lock.unlock()
376
 
            self._lock = None
377
 
            self._lock_mode = self._lock_count = None
378
 
 
379
 
    def abspath(self, name):
380
 
        """Return absolute filename for something in the branch
381
 
        
382
 
        XXX: Robert Collins 20051017 what is this used for? why is it a branch
383
 
        method and not a tree method.
384
 
        """
385
 
        return self._transport.abspath(name)
386
 
 
387
 
    def _rel_controlfilename(self, file_or_path):
388
 
        if not isinstance(file_or_path, basestring):
389
 
            file_or_path = '/'.join(file_or_path)
390
 
        if file_or_path == '':
391
 
            return bzrlib.BZRDIR
392
 
        return bzrlib.transport.urlescape(bzrlib.BZRDIR + '/' + file_or_path)
393
 
 
394
 
    def controlfilename(self, file_or_path):
395
 
        """Return location relative to branch."""
396
 
        return self._transport.abspath(self._rel_controlfilename(file_or_path))
397
 
 
398
 
 
399
 
    def controlfile(self, file_or_path, mode='r'):
400
 
        """Open a control file for this branch.
401
 
 
402
 
        There are two classes of file in the control directory: text
403
 
        and binary.  binary files are untranslated byte streams.  Text
404
 
        control files are stored with Unix newlines and in UTF-8, even
405
 
        if the platform or locale defaults are different.
406
 
 
407
 
        Controlfiles should almost never be opened in write mode but
408
 
        rather should be atomically copied and replaced using atomicfile.
409
 
        """
410
 
        import codecs
411
 
 
412
 
        relpath = self._rel_controlfilename(file_or_path)
413
 
        #TODO: codecs.open() buffers linewise, so it was overloaded with
414
 
        # a much larger buffer, do we need to do the same for getreader/getwriter?
415
 
        if mode == 'rb': 
416
 
            return self._transport.get(relpath)
417
 
        elif mode == 'wb':
418
 
            raise BzrError("Branch.controlfile(mode='wb') is not supported, use put_controlfiles")
419
 
        elif mode == 'r':
420
 
            return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
421
 
        elif mode == 'w':
422
 
            raise BzrError("Branch.controlfile(mode='w') is not supported, use put_controlfiles")
423
 
        else:
424
 
            raise BzrError("invalid controlfile mode %r" % mode)
425
 
 
426
 
    def put_controlfile(self, path, f, encode=True):
427
 
        """Write an entry as a controlfile.
428
 
 
429
 
        :param path: The path to put the file, relative to the .bzr control
430
 
                     directory
431
 
        :param f: A file-like or string object whose contents should be copied.
432
 
        :param encode:  If true, encode the contents as utf-8
433
 
        """
434
 
        self.put_controlfiles([(path, f)], encode=encode)
435
 
 
436
 
    def put_controlfiles(self, files, encode=True):
437
 
        """Write several entries as controlfiles.
438
 
 
439
 
        :param files: A list of [(path, file)] pairs, where the path is the directory
440
 
                      underneath the bzr control directory
441
 
        :param encode:  If true, encode the contents as utf-8
442
 
        """
443
 
        import codecs
444
 
        ctrl_files = []
445
 
        for path, f in files:
446
 
            if encode:
447
 
                if isinstance(f, basestring):
448
 
                    f = f.encode('utf-8', 'replace')
449
 
                else:
450
 
                    f = codecs.getwriter('utf-8')(f, errors='replace')
451
 
            path = self._rel_controlfilename(path)
452
 
            ctrl_files.append((path, f))
453
 
        self._transport.put_multi(ctrl_files)
454
 
 
455
 
    def _make_control(self):
456
 
        from bzrlib.inventory import Inventory
457
 
        from bzrlib.weavefile import write_weave_v5
458
 
        from bzrlib.weave import Weave
459
 
        
460
 
        # Create an empty inventory
461
 
        sio = StringIO()
462
 
        # if we want per-tree root ids then this is the place to set
463
 
        # them; they're not needed for now and so ommitted for
464
 
        # simplicity.
465
 
        bzrlib.xml5.serializer_v5.write_inventory(Inventory(), sio)
466
 
        empty_inv = sio.getvalue()
467
 
        sio = StringIO()
468
 
        bzrlib.weavefile.write_weave_v5(Weave(), sio)
469
 
        empty_weave = sio.getvalue()
470
 
 
471
 
        dirs = [[], 'revision-store', 'weaves']
472
 
        files = [('README', 
473
 
            "This is a Bazaar-NG control directory.\n"
474
 
            "Do not change any files in this directory.\n"),
475
 
            ('branch-format', BZR_BRANCH_FORMAT_6),
476
 
            ('revision-history', ''),
477
 
            ('branch-name', ''),
478
 
            ('branch-lock', ''),
479
 
            ('pending-merges', ''),
480
 
            ('inventory', empty_inv),
481
 
            ('inventory.weave', empty_weave),
482
 
            ('ancestry.weave', empty_weave)
483
 
        ]
484
 
        cfn = self._rel_controlfilename
485
 
        self._transport.mkdir_multi([cfn(d) for d in dirs])
486
 
        self.put_controlfiles(files)
487
 
        mutter('created control directory in ' + self._transport.base)
488
 
 
489
 
    def _check_format(self, relax_version_check):
490
 
        """Check this branch format is supported.
491
 
 
492
 
        The format level is stored, as an integer, in
493
 
        self._branch_format for code that needs to check it later.
494
 
 
495
 
        In the future, we might need different in-memory Branch
496
 
        classes to support downlevel branches.  But not yet.
497
 
        """
498
 
        try:
499
 
            fmt = self.controlfile('branch-format', 'r').read()
500
 
        except NoSuchFile:
501
 
            raise NotBranchError(path=self.base)
502
 
        mutter("got branch format %r", fmt)
503
 
        if fmt == BZR_BRANCH_FORMAT_6:
504
 
            self._branch_format = 6
505
 
        elif fmt == BZR_BRANCH_FORMAT_5:
506
 
            self._branch_format = 5
507
 
        elif fmt == BZR_BRANCH_FORMAT_4:
508
 
            self._branch_format = 4
509
 
 
510
 
        if (not relax_version_check
511
 
            and self._branch_format not in (5, 6)):
512
 
            raise errors.UnsupportedFormatError(
513
 
                           'sorry, branch format %r not supported' % fmt,
514
 
                           ['use a different bzr version',
515
 
                            'or remove the .bzr directory'
516
 
                            ' and "bzr init" again'])
517
 
 
518
 
    def get_root_id(self):
519
 
        """Return the id of this branches root"""
520
 
        inv = self.read_working_inventory()
521
 
        return inv.root.file_id
522
 
 
523
 
    def set_root_id(self, file_id):
524
 
        inv = self.read_working_inventory()
525
 
        orig_root_id = inv.root.file_id
526
 
        del inv._byid[inv.root.file_id]
527
 
        inv.root.file_id = file_id
528
 
        inv._byid[inv.root.file_id] = inv.root
529
 
        for fid in inv:
530
 
            entry = inv[fid]
531
 
            if entry.parent_id in (None, orig_root_id):
532
 
                entry.parent_id = inv.root.file_id
533
 
        self._write_inventory(inv)
534
 
 
535
 
    @needs_read_lock
536
 
    def read_working_inventory(self):
537
 
        """Read the working inventory."""
538
 
        # ElementTree does its own conversion from UTF-8, so open in
539
 
        # binary.
540
 
        f = self.controlfile('inventory', 'rb')
541
 
        return bzrlib.xml5.serializer_v5.read_inventory(f)
542
 
 
543
 
    @needs_write_lock
544
 
    def _write_inventory(self, inv):
545
 
        """Update the working inventory.
546
 
 
547
 
        That is to say, the inventory describing changes underway, that
548
 
        will be committed to the next revision.
549
 
        """
550
 
        from cStringIO import StringIO
551
 
        sio = StringIO()
552
 
        bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
553
 
        sio.seek(0)
554
 
        # Transport handles atomicity
555
 
        self.put_controlfile('inventory', sio)
556
 
        
557
 
        mutter('wrote working inventory')
558
 
            
559
 
    inventory = property(read_working_inventory, _write_inventory, None,
560
 
                         """Inventory for the working copy.""")
561
 
 
562
 
    @needs_write_lock
563
 
    def add(self, files, ids=None):
564
 
        """Make files versioned.
565
 
 
566
 
        Note that the command line normally calls smart_add instead,
567
 
        which can automatically recurse.
568
 
 
569
 
        This puts the files in the Added state, so that they will be
570
 
        recorded by the next commit.
571
 
 
572
 
        files
573
 
            List of paths to add, relative to the base of the tree.
574
 
 
575
 
        ids
576
 
            If set, use these instead of automatically generated ids.
577
 
            Must be the same length as the list of files, but may
578
 
            contain None for ids that are to be autogenerated.
579
 
 
580
 
        TODO: Perhaps have an option to add the ids even if the files do
581
 
              not (yet) exist.
582
 
 
583
 
        TODO: Perhaps yield the ids and paths as they're added.
584
 
        """
585
 
        # TODO: Re-adding a file that is removed in the working copy
586
 
        # should probably put it back with the previous ID.
587
 
        if isinstance(files, basestring):
588
 
            assert(ids is None or isinstance(ids, basestring))
589
 
            files = [files]
590
 
            if ids is not None:
591
 
                ids = [ids]
592
 
 
593
 
        if ids is None:
594
 
            ids = [None] * len(files)
595
 
        else:
596
 
            assert(len(ids) == len(files))
597
 
 
598
 
        inv = self.read_working_inventory()
599
 
        for f,file_id in zip(files, ids):
600
 
            if is_control_file(f):
601
 
                raise BzrError("cannot add control file %s" % quotefn(f))
602
 
 
603
 
            fp = splitpath(f)
604
 
 
605
 
            if len(fp) == 0:
606
 
                raise BzrError("cannot add top-level %r" % f)
607
 
 
608
 
            fullpath = os.path.normpath(self.abspath(f))
609
 
 
610
 
            try:
611
 
                kind = file_kind(fullpath)
612
 
            except OSError:
613
 
                # maybe something better?
614
 
                raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
615
 
 
616
 
            if not InventoryEntry.versionable_kind(kind):
617
 
                raise BzrError('cannot add: not a versionable file ('
618
 
                               'i.e. regular file, symlink or directory): %s' % quotefn(f))
619
 
 
620
 
            if file_id is None:
621
 
                file_id = gen_file_id(f)
622
 
            inv.add_path(f, kind=kind, file_id=file_id)
623
 
 
624
 
            mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
625
 
 
626
 
        self._write_inventory(inv)
627
 
 
628
 
    @needs_read_lock
629
 
    def print_file(self, file, revno):
630
 
        """Print `file` to stdout."""
631
 
        tree = self.revision_tree(self.get_rev_id(revno))
632
 
        # use inventory as it was in that revision
633
 
        file_id = tree.inventory.path2id(file)
634
 
        if not file_id:
635
 
            raise BzrError("%r is not present in revision %s" % (file, revno))
636
 
        tree.print_file(file_id)
637
 
 
638
 
    # FIXME: this doesn't need to be a branch method
639
 
    def set_inventory(self, new_inventory_list):
640
 
        from bzrlib.inventory import Inventory, InventoryEntry
641
 
        inv = Inventory(self.get_root_id())
642
 
        for path, file_id, parent, kind in new_inventory_list:
643
 
            name = os.path.basename(path)
644
 
            if name == "":
645
 
                continue
646
 
            # fixme, there should be a factory function inv,add_?? 
647
 
            if kind == 'directory':
648
 
                inv.add(inventory.InventoryDirectory(file_id, name, parent))
649
 
            elif kind == 'file':
650
 
                inv.add(inventory.InventoryFile(file_id, name, parent))
651
 
            elif kind == 'symlink':
652
 
                inv.add(inventory.InventoryLink(file_id, name, parent))
653
 
            else:
654
 
                raise BzrError("unknown kind %r" % kind)
655
 
        self._write_inventory(inv)
656
 
 
657
 
    def unknowns(self):
658
 
        """Return all unknown files.
659
 
 
660
 
        These are files in the working directory that are not versioned or
661
 
        control files or ignored.
662
 
        
663
 
        >>> from bzrlib.workingtree import WorkingTree
664
 
        >>> b = ScratchBranch(files=['foo', 'foo~'])
665
 
        >>> map(str, b.unknowns())
666
 
        ['foo']
667
 
        >>> b.add('foo')
668
 
        >>> list(b.unknowns())
669
 
        []
670
 
        >>> WorkingTree(b.base, b).remove('foo')
671
 
        >>> list(b.unknowns())
672
 
        [u'foo']
673
 
        """
674
 
        return self.working_tree().unknowns()
 
935
        # TODO: test for failed two phase locks. This is known broken.
 
936
        self.repository.unlock()
 
937
        self.control_files.unlock()
 
938
        
 
939
    def peek_lock_mode(self):
 
940
        if self.control_files._lock_count == 0:
 
941
            return None
 
942
        else:
 
943
            return self.control_files._lock_mode
 
944
 
 
945
    @needs_read_lock
 
946
    def print_file(self, file, revision_id):
 
947
        """See Branch.print_file."""
 
948
        return self.repository.print_file(file, revision_id)
675
949
 
676
950
    @needs_write_lock
677
951
    def append_revision(self, *revision_ids):
 
952
        """See Branch.append_revision."""
678
953
        for revision_id in revision_ids:
679
954
            mutter("add {%s} to revision-history" % revision_id)
680
955
        rev_history = self.revision_history()
683
958
 
684
959
    @needs_write_lock
685
960
    def set_revision_history(self, rev_history):
686
 
        self.put_controlfile('revision-history', '\n'.join(rev_history))
687
 
 
688
 
    def has_revision(self, revision_id):
689
 
        """True if this branch has a copy of the revision.
690
 
 
691
 
        This does not necessarily imply the revision is merge
692
 
        or on the mainline."""
693
 
        return (revision_id is None
694
 
                or self.revision_store.has_id(revision_id))
695
 
 
696
 
    @needs_read_lock
697
 
    def get_revision_xml_file(self, revision_id):
698
 
        """Return XML file object for revision object."""
699
 
        if not revision_id or not isinstance(revision_id, basestring):
700
 
            raise InvalidRevisionId(revision_id)
701
 
        try:
702
 
            return self.revision_store.get(revision_id)
703
 
        except (IndexError, KeyError):
704
 
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
705
 
 
706
 
    #deprecated
707
 
    get_revision_xml = get_revision_xml_file
708
 
 
709
 
    def get_revision_xml(self, revision_id):
710
 
        return self.get_revision_xml_file(revision_id).read()
711
 
 
712
 
 
713
 
    def get_revision(self, revision_id):
714
 
        """Return the Revision object for a named revision"""
715
 
        xml_file = self.get_revision_xml_file(revision_id)
716
 
 
717
 
        try:
718
 
            r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
719
 
        except SyntaxError, e:
720
 
            raise bzrlib.errors.BzrError('failed to unpack revision_xml',
721
 
                                         [revision_id,
722
 
                                          str(e)])
723
 
            
724
 
        assert r.revision_id == revision_id
725
 
        return r
 
961
        """See Branch.set_revision_history."""
 
962
        self.control_files.put_utf8(
 
963
            'revision-history', '\n'.join(rev_history))
 
964
        transaction = self.get_transaction()
 
965
        history = transaction.map.find_revision_history()
 
966
        if history is not None:
 
967
            # update the revision history in the identity map.
 
968
            history[:] = list(rev_history)
 
969
            # this call is disabled because revision_history is 
 
970
            # not really an object yet, and the transaction is for objects.
 
971
            # transaction.register_dirty(history)
 
972
        else:
 
973
            transaction.map.add_revision_history(rev_history)
 
974
            # this call is disabled because revision_history is 
 
975
            # not really an object yet, and the transaction is for objects.
 
976
            # transaction.register_clean(history)
726
977
 
727
978
    def get_revision_delta(self, revno):
728
979
        """Return the delta for one revision.
737
988
 
738
989
        # revno is 1-based; list is 0-based
739
990
 
740
 
        new_tree = self.revision_tree(rh[revno-1])
 
991
        new_tree = self.repository.revision_tree(rh[revno-1])
741
992
        if revno == 1:
742
993
            old_tree = EmptyTree()
743
994
        else:
744
 
            old_tree = self.revision_tree(rh[revno-2])
745
 
 
 
995
            old_tree = self.repository.revision_tree(rh[revno-2])
746
996
        return compare_trees(old_tree, new_tree)
747
997
 
748
 
    def get_revision_sha1(self, revision_id):
749
 
        """Hash the stored value of a revision, and return it."""
750
 
        # In the future, revision entries will be signed. At that
751
 
        # point, it is probably best *not* to include the signature
752
 
        # in the revision hash. Because that lets you re-sign
753
 
        # the revision, (add signatures/remove signatures) and still
754
 
        # have all hash pointers stay consistent.
755
 
        # But for now, just hash the contents.
756
 
        return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
757
 
 
758
 
    def get_ancestry(self, revision_id):
759
 
        """Return a list of revision-ids integrated by a revision.
760
 
        
761
 
        This currently returns a list, but the ordering is not guaranteed:
762
 
        treat it as a set.
763
 
        """
764
 
        if revision_id is None:
765
 
            return [None]
766
 
        w = self.get_inventory_weave()
767
 
        return [None] + map(w.idx_to_name,
768
 
                            w.inclusions([w.lookup(revision_id)]))
769
 
 
770
 
    def get_inventory_weave(self):
771
 
        return self.control_weaves.get_weave('inventory',
772
 
                                             self.get_transaction())
773
 
 
774
 
    def get_inventory(self, revision_id):
775
 
        """Get Inventory object by hash."""
776
 
        xml = self.get_inventory_xml(revision_id)
777
 
        return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
778
 
 
779
 
    def get_inventory_xml(self, revision_id):
780
 
        """Get inventory XML as a file object."""
781
 
        try:
782
 
            assert isinstance(revision_id, basestring), type(revision_id)
783
 
            iw = self.get_inventory_weave()
784
 
            return iw.get_text(iw.lookup(revision_id))
785
 
        except IndexError:
786
 
            raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
787
 
 
788
 
    def get_inventory_sha1(self, revision_id):
789
 
        """Return the sha1 hash of the inventory entry
790
 
        """
791
 
        return self.get_revision(revision_id).inventory_sha1
792
 
 
793
 
    def get_revision_inventory(self, revision_id):
794
 
        """Return inventory of a past revision."""
795
 
        # TODO: Unify this with get_inventory()
796
 
        # bzr 0.0.6 and later imposes the constraint that the inventory_id
797
 
        # must be the same as its revision, so this is trivial.
798
 
        if revision_id == None:
799
 
            return Inventory(self.get_root_id())
800
 
        else:
801
 
            return self.get_inventory(revision_id)
802
 
 
803
998
    @needs_read_lock
804
999
    def revision_history(self):
805
 
        """Return sequence of revision hashes on to this branch."""
 
1000
        """See Branch.revision_history."""
806
1001
        transaction = self.get_transaction()
807
1002
        history = transaction.map.find_revision_history()
808
1003
        if history is not None:
809
1004
            mutter("cache hit for revision-history in %s", self)
810
1005
            return list(history)
811
1006
        history = [l.rstrip('\r\n') for l in
812
 
                self.controlfile('revision-history', 'r').readlines()]
 
1007
                self.control_files.get_utf8('revision-history').readlines()]
813
1008
        transaction.map.add_revision_history(history)
814
1009
        # this call is disabled because revision_history is 
815
1010
        # not really an object yet, and the transaction is for objects.
816
1011
        # transaction.register_clean(history, precious=True)
817
1012
        return list(history)
818
1013
 
819
 
    def revno(self):
820
 
        """Return current revision number for this branch.
821
 
 
822
 
        That is equivalent to the number of revisions committed to
823
 
        this branch.
824
 
        """
825
 
        return len(self.revision_history())
826
 
 
827
 
    def last_revision(self):
828
 
        """Return last patch hash, or None if no history.
829
 
        """
830
 
        ph = self.revision_history()
831
 
        if ph:
832
 
            return ph[-1]
833
 
        else:
834
 
            return None
835
 
 
836
 
    def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
837
 
        """Return a list of new revisions that would perfectly fit.
838
 
        
839
 
        If self and other have not diverged, return a list of the revisions
840
 
        present in other, but missing from self.
841
 
 
842
 
        >>> from bzrlib.commit import commit
843
 
        >>> bzrlib.trace.silent = True
844
 
        >>> br1 = ScratchBranch()
845
 
        >>> br2 = ScratchBranch()
846
 
        >>> br1.missing_revisions(br2)
847
 
        []
848
 
        >>> commit(br2, "lala!", rev_id="REVISION-ID-1")
849
 
        >>> br1.missing_revisions(br2)
850
 
        [u'REVISION-ID-1']
851
 
        >>> br2.missing_revisions(br1)
852
 
        []
853
 
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1")
854
 
        >>> br1.missing_revisions(br2)
855
 
        []
856
 
        >>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
857
 
        >>> br1.missing_revisions(br2)
858
 
        [u'REVISION-ID-2A']
859
 
        >>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
860
 
        >>> br1.missing_revisions(br2)
861
 
        Traceback (most recent call last):
862
 
        DivergedBranches: These branches have diverged.
863
 
        """
864
 
        self_history = self.revision_history()
865
 
        self_len = len(self_history)
866
 
        other_history = other.revision_history()
867
 
        other_len = len(other_history)
868
 
        common_index = min(self_len, other_len) -1
869
 
        if common_index >= 0 and \
870
 
            self_history[common_index] != other_history[common_index]:
871
 
            raise DivergedBranches(self, other)
872
 
 
873
 
        if stop_revision is None:
874
 
            stop_revision = other_len
875
 
        else:
876
 
            assert isinstance(stop_revision, int)
877
 
            if stop_revision > other_len:
878
 
                raise bzrlib.errors.NoSuchRevision(self, stop_revision)
879
 
        return other_history[self_len:stop_revision]
880
 
 
881
1014
    def update_revisions(self, other, stop_revision=None):
882
 
        """Pull in new perfect-fit revisions."""
883
 
        # FIXME: If the branches have diverged, but the latest
884
 
        # revision in this branch is completely merged into the other,
885
 
        # then we should still be able to pull.
886
 
        from bzrlib.fetch import greedy_fetch
 
1015
        """See Branch.update_revisions."""
887
1016
        if stop_revision is None:
888
1017
            stop_revision = other.last_revision()
889
1018
        ### Should this be checking is_ancestor instead of revision_history?
890
1019
        if (stop_revision is not None and 
891
1020
            stop_revision in self.revision_history()):
892
1021
            return
893
 
        greedy_fetch(to_branch=self, from_branch=other,
894
 
                     revision=stop_revision)
 
1022
        self.fetch(other, stop_revision)
895
1023
        pullable_revs = self.pullable_revisions(other, stop_revision)
896
1024
        if len(pullable_revs) > 0:
897
1025
            self.append_revision(*pullable_revs)
903
1031
        except DivergedBranches, e:
904
1032
            try:
905
1033
                pullable_revs = get_intervening_revisions(self.last_revision(),
906
 
                                                          stop_revision, self)
 
1034
                                                          stop_revision, 
 
1035
                                                          self.repository)
907
1036
                assert self.last_revision() not in pullable_revs
908
1037
                return pullable_revs
909
1038
            except bzrlib.errors.NotAncestor:
912
1041
                else:
913
1042
                    raise e
914
1043
        
915
 
    def commit(self, *args, **kw):
916
 
        from bzrlib.commit import Commit
917
 
        Commit().commit(self, *args, **kw)
918
 
    
919
 
    def revision_id_to_revno(self, revision_id):
920
 
        """Given a revision id, return its revno"""
921
 
        if revision_id is None:
922
 
            return 0
923
 
        history = self.revision_history()
924
 
        try:
925
 
            return history.index(revision_id) + 1
926
 
        except ValueError:
927
 
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
928
 
 
929
 
    def get_rev_id(self, revno, history=None):
930
 
        """Find the revision id of the specified revno."""
931
 
        if revno == 0:
932
 
            return None
933
 
        if history is None:
934
 
            history = self.revision_history()
935
 
        elif revno <= 0 or revno > len(history):
936
 
            raise bzrlib.errors.NoSuchRevision(self, revno)
937
 
        return history[revno - 1]
938
 
 
939
 
    def revision_tree(self, revision_id):
940
 
        """Return Tree for a revision on this branch.
941
 
 
942
 
        `revision_id` may be None for the null revision, in which case
943
 
        an `EmptyTree` is returned."""
944
 
        # TODO: refactor this to use an existing revision object
945
 
        # so we don't need to read it in twice.
946
 
        if revision_id == None:
947
 
            return EmptyTree()
948
 
        else:
949
 
            inv = self.get_revision_inventory(revision_id)
950
 
            return RevisionTree(self.weave_store, inv, revision_id)
951
 
 
 
1044
    def basis_tree(self):
 
1045
        """See Branch.basis_tree."""
 
1046
        return self.repository.revision_tree(self.last_revision())
 
1047
 
 
1048
    @deprecated_method(zero_eight)
952
1049
    def working_tree(self):
953
 
        """Return a `Tree` for the working copy."""
 
1050
        """Create a Working tree object for this branch."""
954
1051
        from bzrlib.workingtree import WorkingTree
955
 
        # TODO: In the future, perhaps WorkingTree should utilize Transport
956
 
        # RobertCollins 20051003 - I don't think it should - working trees are
957
 
        # much more complex to keep consistent than our careful .bzr subset.
958
 
        # instead, we should say that working trees are local only, and optimise
959
 
        # for that.
960
 
        return WorkingTree(self.base, branch=self)
961
 
 
962
 
 
963
 
    def basis_tree(self):
964
 
        """Return `Tree` object for last revision.
965
 
 
966
 
        If there are no revisions yet, return an `EmptyTree`.
967
 
        """
968
 
        return self.revision_tree(self.last_revision())
 
1052
        from bzrlib.transport.local import LocalTransport
 
1053
        if (self.base.find('://') != -1 or 
 
1054
            not isinstance(self._transport, LocalTransport)):
 
1055
            raise NoWorkingTree(self.base)
 
1056
        return self.bzrdir.open_workingtree()
969
1057
 
970
1058
    @needs_write_lock
971
 
    def rename_one(self, from_rel, to_rel):
972
 
        """Rename one file.
973
 
 
974
 
        This can change the directory or the filename or both.
975
 
        """
976
 
        tree = self.working_tree()
977
 
        inv = tree.inventory
978
 
        if not tree.has_filename(from_rel):
979
 
            raise BzrError("can't rename: old working file %r does not exist" % from_rel)
980
 
        if tree.has_filename(to_rel):
981
 
            raise BzrError("can't rename: new working file %r already exists" % to_rel)
982
 
 
983
 
        file_id = inv.path2id(from_rel)
984
 
        if file_id == None:
985
 
            raise BzrError("can't rename: old name %r is not versioned" % from_rel)
986
 
 
987
 
        if inv.path2id(to_rel):
988
 
            raise BzrError("can't rename: new name %r is already versioned" % to_rel)
989
 
 
990
 
        to_dir, to_tail = os.path.split(to_rel)
991
 
        to_dir_id = inv.path2id(to_dir)
992
 
        if to_dir_id == None and to_dir != '':
993
 
            raise BzrError("can't determine destination directory id for %r" % to_dir)
994
 
 
995
 
        mutter("rename_one:")
996
 
        mutter("  file_id    {%s}" % file_id)
997
 
        mutter("  from_rel   %r" % from_rel)
998
 
        mutter("  to_rel     %r" % to_rel)
999
 
        mutter("  to_dir     %r" % to_dir)
1000
 
        mutter("  to_dir_id  {%s}" % to_dir_id)
1001
 
 
1002
 
        inv.rename(file_id, to_dir_id, to_tail)
1003
 
 
1004
 
        from_abs = self.abspath(from_rel)
1005
 
        to_abs = self.abspath(to_rel)
 
1059
    def pull(self, source, overwrite=False, stop_revision=None):
 
1060
        """See Branch.pull."""
 
1061
        source.lock_read()
1006
1062
        try:
1007
 
            rename(from_abs, to_abs)
1008
 
        except OSError, e:
1009
 
            raise BzrError("failed to rename %r to %r: %s"
1010
 
                    % (from_abs, to_abs, e[1]),
1011
 
                    ["rename rolled back"])
1012
 
 
1013
 
        self._write_inventory(inv)
1014
 
 
1015
 
    @needs_write_lock
1016
 
    def move(self, from_paths, to_name):
1017
 
        """Rename files.
1018
 
 
1019
 
        to_name must exist as a versioned directory.
1020
 
 
1021
 
        If to_name exists and is a directory, the files are moved into
1022
 
        it, keeping their old names.  If it is a directory, 
1023
 
 
1024
 
        Note that to_name is only the last component of the new name;
1025
 
        this doesn't change the directory.
1026
 
 
1027
 
        This returns a list of (from_path, to_path) pairs for each
1028
 
        entry that is moved.
1029
 
        """
1030
 
        result = []
1031
 
        ## TODO: Option to move IDs only
1032
 
        assert not isinstance(from_paths, basestring)
1033
 
        tree = self.working_tree()
1034
 
        inv = tree.inventory
1035
 
        to_abs = self.abspath(to_name)
1036
 
        if not isdir(to_abs):
1037
 
            raise BzrError("destination %r is not a directory" % to_abs)
1038
 
        if not tree.has_filename(to_name):
1039
 
            raise BzrError("destination %r not in working directory" % to_abs)
1040
 
        to_dir_id = inv.path2id(to_name)
1041
 
        if to_dir_id == None and to_name != '':
1042
 
            raise BzrError("destination %r is not a versioned directory" % to_name)
1043
 
        to_dir_ie = inv[to_dir_id]
1044
 
        if to_dir_ie.kind not in ('directory', 'root_directory'):
1045
 
            raise BzrError("destination %r is not a directory" % to_abs)
1046
 
 
1047
 
        to_idpath = inv.get_idpath(to_dir_id)
1048
 
 
1049
 
        for f in from_paths:
1050
 
            if not tree.has_filename(f):
1051
 
                raise BzrError("%r does not exist in working tree" % f)
1052
 
            f_id = inv.path2id(f)
1053
 
            if f_id == None:
1054
 
                raise BzrError("%r is not versioned" % f)
1055
 
            name_tail = splitpath(f)[-1]
1056
 
            dest_path = appendpath(to_name, name_tail)
1057
 
            if tree.has_filename(dest_path):
1058
 
                raise BzrError("destination %r already exists" % dest_path)
1059
 
            if f_id in to_idpath:
1060
 
                raise BzrError("can't move %r to a subdirectory of itself" % f)
1061
 
 
1062
 
        # OK, so there's a race here, it's possible that someone will
1063
 
        # create a file in this interval and then the rename might be
1064
 
        # left half-done.  But we should have caught most problems.
1065
 
 
1066
 
        for f in from_paths:
1067
 
            name_tail = splitpath(f)[-1]
1068
 
            dest_path = appendpath(to_name, name_tail)
1069
 
            result.append((f, dest_path))
1070
 
            inv.rename(inv.path2id(f), to_dir_id, name_tail)
1071
 
            try:
1072
 
                rename(self.abspath(f), self.abspath(dest_path))
1073
 
            except OSError, e:
1074
 
                raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1075
 
                        ["rename rolled back"])
1076
 
 
1077
 
        self._write_inventory(inv)
1078
 
        return result
1079
 
 
1080
 
 
1081
 
    def revert(self, filenames, old_tree=None, backups=True):
1082
 
        """Restore selected files to the versions from a previous tree.
1083
 
 
1084
 
        backups
1085
 
            If true (default) backups are made of files before
1086
 
            they're renamed.
1087
 
        """
1088
 
        from bzrlib.atomicfile import AtomicFile
1089
 
        from bzrlib.osutils import backup_file
1090
 
        
1091
 
        inv = self.read_working_inventory()
1092
 
        if old_tree is None:
1093
 
            old_tree = self.basis_tree()
1094
 
        old_inv = old_tree.inventory
1095
 
 
1096
 
        nids = []
1097
 
        for fn in filenames:
1098
 
            file_id = inv.path2id(fn)
1099
 
            if not file_id:
1100
 
                raise NotVersionedError(path=fn)
1101
 
            if not old_inv.has_id(file_id):
1102
 
                raise BzrError("file not present in old tree", fn, file_id)
1103
 
            nids.append((fn, file_id))
1104
 
            
1105
 
        # TODO: Rename back if it was previously at a different location
1106
 
 
1107
 
        # TODO: If given a directory, restore the entire contents from
1108
 
        # the previous version.
1109
 
 
1110
 
        # TODO: Make a backup to a temporary file.
1111
 
 
1112
 
        # TODO: If the file previously didn't exist, delete it?
1113
 
        for fn, file_id in nids:
1114
 
            backup_file(fn)
1115
 
            
1116
 
            f = AtomicFile(fn, 'wb')
1117
 
            try:
1118
 
                f.write(old_tree.get_file(file_id).read())
1119
 
                f.commit()
1120
 
            finally:
1121
 
                f.close()
1122
 
 
1123
 
 
1124
 
    def pending_merges(self):
1125
 
        """Return a list of pending merges.
1126
 
 
1127
 
        These are revisions that have been merged into the working
1128
 
        directory but not yet committed.
1129
 
        """
1130
 
        cfn = self._rel_controlfilename('pending-merges')
1131
 
        if not self._transport.has(cfn):
1132
 
            return []
1133
 
        p = []
1134
 
        for l in self.controlfile('pending-merges', 'r').readlines():
1135
 
            p.append(l.rstrip('\n'))
1136
 
        return p
1137
 
 
1138
 
 
1139
 
    def add_pending_merge(self, *revision_ids):
1140
 
        # TODO: Perhaps should check at this point that the
1141
 
        # history of the revision is actually present?
1142
 
        p = self.pending_merges()
1143
 
        updated = False
1144
 
        for rev_id in revision_ids:
1145
 
            if rev_id in p:
1146
 
                continue
1147
 
            p.append(rev_id)
1148
 
            updated = True
1149
 
        if updated:
1150
 
            self.set_pending_merges(p)
1151
 
 
1152
 
    @needs_write_lock
1153
 
    def set_pending_merges(self, rev_list):
1154
 
        self.put_controlfile('pending-merges', '\n'.join(rev_list))
 
1063
            old_count = len(self.revision_history())
 
1064
            try:
 
1065
                self.update_revisions(source,stop_revision)
 
1066
            except DivergedBranches:
 
1067
                if not overwrite:
 
1068
                    raise
 
1069
            if overwrite:
 
1070
                self.set_revision_history(source.revision_history())
 
1071
            new_count = len(self.revision_history())
 
1072
            return new_count - old_count
 
1073
        finally:
 
1074
            source.unlock()
1155
1075
 
1156
1076
    def get_parent(self):
1157
 
        """Return the parent location of the branch.
1158
 
 
1159
 
        This is the default location for push/pull/missing.  The usual
1160
 
        pattern is that the user can override it by specifying a
1161
 
        location.
1162
 
        """
 
1077
        """See Branch.get_parent."""
1163
1078
        import errno
1164
1079
        _locs = ['parent', 'pull', 'x-pull']
1165
1080
        for l in _locs:
1166
1081
            try:
1167
 
                return self.controlfile(l, 'r').read().strip('\n')
1168
 
            except IOError, e:
1169
 
                if e.errno != errno.ENOENT:
1170
 
                    raise
 
1082
                return self.control_files.get_utf8(l).read().strip('\n')
 
1083
            except NoSuchFile:
 
1084
                pass
1171
1085
        return None
1172
1086
 
 
1087
    def get_push_location(self):
 
1088
        """See Branch.get_push_location."""
 
1089
        config = bzrlib.config.BranchConfig(self)
 
1090
        push_loc = config.get_user_option('push_location')
 
1091
        return push_loc
 
1092
 
 
1093
    def set_push_location(self, location):
 
1094
        """See Branch.set_push_location."""
 
1095
        config = bzrlib.config.LocationConfig(self.base)
 
1096
        config.set_user_option('push_location', location)
 
1097
 
1173
1098
    @needs_write_lock
1174
1099
    def set_parent(self, url):
 
1100
        """See Branch.set_parent."""
1175
1101
        # TODO: Maybe delete old location files?
1176
 
        from bzrlib.atomicfile import AtomicFile
1177
 
        f = AtomicFile(self.controlfilename('parent'))
1178
 
        try:
1179
 
            f.write(url + '\n')
1180
 
            f.commit()
 
1102
        # URLs should never be unicode, even on the local fs,
 
1103
        # FIXUP this and get_parent in a future branch format bump:
 
1104
        # read and rewrite the file, and have the new format code read
 
1105
        # using .get not .get_utf8. RBC 20060125
 
1106
        if url is None:
 
1107
            self.control_files._transport.delete('parent')
 
1108
        else:
 
1109
            self.control_files.put_utf8('parent', url + '\n')
 
1110
 
 
1111
    def tree_config(self):
 
1112
        return TreeConfig(self)
 
1113
 
 
1114
 
 
1115
class BzrBranch5(BzrBranch):
 
1116
    """A format 5 branch. This supports new features over plan branches.
 
1117
 
 
1118
    It has support for a master_branch which is the data for bound branches.
 
1119
    """
 
1120
 
 
1121
    def __init__(self,
 
1122
                 _format,
 
1123
                 _control_files,
 
1124
                 a_bzrdir,
 
1125
                 _repository):
 
1126
        super(BzrBranch5, self).__init__(_format=_format,
 
1127
                                         _control_files=_control_files,
 
1128
                                         a_bzrdir=a_bzrdir,
 
1129
                                         _repository=_repository)
 
1130
        
 
1131
    @needs_write_lock
 
1132
    def pull(self, source, overwrite=False, stop_revision=None):
 
1133
        """Updates branch.pull to be bound branch aware."""
 
1134
        bound_location = self.get_bound_location()
 
1135
        if source.base != bound_location:
 
1136
            # not pulling from master, so we need to update master.
 
1137
            master_branch = self.get_master_branch()
 
1138
            if master_branch:
 
1139
                master_branch.pull(source)
 
1140
                source = master_branch
 
1141
        return super(BzrBranch5, self).pull(source, overwrite, stop_revision)
 
1142
 
 
1143
    def get_bound_location(self):
 
1144
        try:
 
1145
            return self.control_files.get_utf8('bound').read()[:-1]
 
1146
        except errors.NoSuchFile:
 
1147
            return None
 
1148
 
 
1149
    @needs_read_lock
 
1150
    def get_master_branch(self):
 
1151
        """Return the branch we are bound to.
 
1152
        
 
1153
        :return: Either a Branch, or None
 
1154
 
 
1155
        This could memoise the branch, but if thats done
 
1156
        it must be revalidated on each new lock.
 
1157
        So for now we just dont memoise it.
 
1158
        # RBC 20060304 review this decision.
 
1159
        """
 
1160
        bound_loc = self.get_bound_location()
 
1161
        if not bound_loc:
 
1162
            return None
 
1163
        try:
 
1164
            return Branch.open(bound_loc)
 
1165
        except (errors.NotBranchError, errors.ConnectionError), e:
 
1166
            raise errors.BoundBranchConnectionFailure(
 
1167
                    self, bound_loc, e)
 
1168
 
 
1169
    @needs_write_lock
 
1170
    def set_bound_location(self, location):
 
1171
        """Set the target where this branch is bound to.
 
1172
 
 
1173
        :param location: URL to the target branch
 
1174
        """
 
1175
        if location:
 
1176
            self.control_files.put_utf8('bound', location+'\n')
 
1177
        else:
 
1178
            try:
 
1179
                self.control_files._transport.delete('bound')
 
1180
            except NoSuchFile:
 
1181
                return False
 
1182
            return True
 
1183
 
 
1184
    @needs_write_lock
 
1185
    def bind(self, other):
 
1186
        """Bind the local branch the other branch.
 
1187
 
 
1188
        :param other: The branch to bind to
 
1189
        :type other: Branch
 
1190
        """
 
1191
        # TODO: jam 20051230 Consider checking if the target is bound
 
1192
        #       It is debatable whether you should be able to bind to
 
1193
        #       a branch which is itself bound.
 
1194
        #       Committing is obviously forbidden,
 
1195
        #       but binding itself may not be.
 
1196
        #       Since we *have* to check at commit time, we don't
 
1197
        #       *need* to check here
 
1198
        self.pull(other)
 
1199
 
 
1200
        # we are now equal to or a suffix of other.
 
1201
 
 
1202
        # Since we have 'pulled' from the remote location,
 
1203
        # now we should try to pull in the opposite direction
 
1204
        # in case the local tree has more revisions than the
 
1205
        # remote one.
 
1206
        # There may be a different check you could do here
 
1207
        # rather than actually trying to install revisions remotely.
 
1208
        # TODO: capture an exception which indicates the remote branch
 
1209
        #       is not writeable. 
 
1210
        #       If it is up-to-date, this probably should not be a failure
 
1211
        
 
1212
        # lock other for write so the revision-history syncing cannot race
 
1213
        other.lock_write()
 
1214
        try:
 
1215
            other.pull(self)
 
1216
            # if this does not error, other now has the same last rev we do
 
1217
            # it can only error if the pull from other was concurrent with
 
1218
            # a commit to other from someone else.
 
1219
 
 
1220
            # until we ditch revision-history, we need to sync them up:
 
1221
            self.set_revision_history(other.revision_history())
 
1222
            # now other and self are up to date with each other and have the
 
1223
            # same revision-history.
1181
1224
        finally:
1182
 
            f.close()
1183
 
 
1184
 
    def check_revno(self, revno):
1185
 
        """\
1186
 
        Check whether a revno corresponds to any revision.
1187
 
        Zero (the NULL revision) is considered valid.
1188
 
        """
1189
 
        if revno != 0:
1190
 
            self.check_real_revno(revno)
1191
 
            
1192
 
    def check_real_revno(self, revno):
1193
 
        """\
1194
 
        Check whether a revno corresponds to a real revision.
1195
 
        Zero (the NULL revision) is considered invalid
1196
 
        """
1197
 
        if revno < 1 or revno > self.revno():
1198
 
            raise InvalidRevisionNumber(revno)
1199
 
        
1200
 
    def sign_revision(self, revision_id, gpg_strategy):
1201
 
        plaintext = Testament.from_revision(self, revision_id).as_short_text()
1202
 
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1203
 
 
1204
 
    @needs_write_lock
1205
 
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1206
 
        self.revision_store.add(StringIO(gpg_strategy.sign(plaintext)), 
1207
 
                                revision_id, "sig")
1208
 
 
1209
 
 
1210
 
class ScratchBranch(_Branch):
1211
 
    """Special test class: a branch that cleans up after itself.
1212
 
 
1213
 
    >>> b = ScratchBranch()
1214
 
    >>> isdir(b.base)
1215
 
    True
1216
 
    >>> bd = b.base
1217
 
    >>> b._transport.__del__()
1218
 
    >>> isdir(bd)
1219
 
    False
 
1225
            other.unlock()
 
1226
 
 
1227
        self.set_bound_location(other.base)
 
1228
 
 
1229
    @needs_write_lock
 
1230
    def unbind(self):
 
1231
        """If bound, unbind"""
 
1232
        return self.set_bound_location(None)
 
1233
 
 
1234
    @needs_write_lock
 
1235
    def update(self):
 
1236
        """Synchronise this branch with the master branch if any. 
 
1237
 
 
1238
        :return: None or the last_revision that was pivoted out during the
 
1239
                 update.
 
1240
        """
 
1241
        master = self.get_master_branch()
 
1242
        if master is not None:
 
1243
            old_tip = self.last_revision()
 
1244
            self.pull(master, overwrite=True)
 
1245
            if old_tip in self.repository.get_ancestry(self.last_revision()):
 
1246
                return None
 
1247
            return old_tip
 
1248
        return None
 
1249
 
 
1250
 
 
1251
class BranchTestProviderAdapter(object):
 
1252
    """A tool to generate a suite testing multiple branch formats at once.
 
1253
 
 
1254
    This is done by copying the test once for each transport and injecting
 
1255
    the transport_server, transport_readonly_server, and branch_format
 
1256
    classes into each copy. Each copy is also given a new id() to make it
 
1257
    easy to identify.
1220
1258
    """
1221
1259
 
1222
 
    def __init__(self, files=[], dirs=[], transport=None):
1223
 
        """Make a test branch.
1224
 
 
1225
 
        This creates a temporary directory and runs init-tree in it.
1226
 
 
1227
 
        If any files are listed, they are created in the working copy.
1228
 
        """
1229
 
        if transport is None:
1230
 
            transport = bzrlib.transport.local.ScratchTransport()
1231
 
            super(ScratchBranch, self).__init__(transport, init=True)
1232
 
        else:
1233
 
            super(ScratchBranch, self).__init__(transport)
1234
 
 
1235
 
        for d in dirs:
1236
 
            self._transport.mkdir(d)
1237
 
            
1238
 
        for f in files:
1239
 
            self._transport.put(f, 'content of %s' % f)
1240
 
 
1241
 
 
1242
 
    def clone(self):
1243
 
        """
1244
 
        >>> orig = ScratchBranch(files=["file1", "file2"])
1245
 
        >>> clone = orig.clone()
1246
 
        >>> if os.name != 'nt':
1247
 
        ...   os.path.samefile(orig.base, clone.base)
1248
 
        ... else:
1249
 
        ...   orig.base == clone.base
1250
 
        ...
1251
 
        False
1252
 
        >>> os.path.isfile(os.path.join(clone.base, "file1"))
1253
 
        True
1254
 
        """
1255
 
        from shutil import copytree
1256
 
        from tempfile import mkdtemp
1257
 
        base = mkdtemp()
1258
 
        os.rmdir(base)
1259
 
        copytree(self.base, base, symlinks=True)
1260
 
        return ScratchBranch(
1261
 
            transport=bzrlib.transport.local.ScratchTransport(base))
 
1260
    def __init__(self, transport_server, transport_readonly_server, formats):
 
1261
        self._transport_server = transport_server
 
1262
        self._transport_readonly_server = transport_readonly_server
 
1263
        self._formats = formats
1262
1264
    
 
1265
    def adapt(self, test):
 
1266
        result = TestSuite()
 
1267
        for branch_format, bzrdir_format in self._formats:
 
1268
            new_test = deepcopy(test)
 
1269
            new_test.transport_server = self._transport_server
 
1270
            new_test.transport_readonly_server = self._transport_readonly_server
 
1271
            new_test.bzrdir_format = bzrdir_format
 
1272
            new_test.branch_format = branch_format
 
1273
            def make_new_test_id():
 
1274
                new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
 
1275
                return lambda: new_id
 
1276
            new_test.id = make_new_test_id()
 
1277
            result.addTest(new_test)
 
1278
        return result
 
1279
 
1263
1280
 
1264
1281
######################################################################
1265
1282
# predicates
1266
1283
 
1267
1284
 
1268
 
def is_control_file(filename):
1269
 
    ## FIXME: better check
1270
 
    filename = os.path.normpath(filename)
1271
 
    while filename != '':
1272
 
        head, tail = os.path.split(filename)
1273
 
        ## mutter('check %r for control file' % ((head, tail), ))
1274
 
        if tail == bzrlib.BZRDIR:
1275
 
            return True
1276
 
        if filename == head:
1277
 
            break
1278
 
        filename = head
1279
 
    return False
1280
 
 
1281
 
 
1282
 
 
1283
 
def gen_file_id(name):
1284
 
    """Return new file id.
1285
 
 
1286
 
    This should probably generate proper UUIDs, but for the moment we
1287
 
    cope with just randomness because running uuidgen every time is
1288
 
    slow."""
1289
 
    import re
1290
 
    from binascii import hexlify
1291
 
    from time import time
1292
 
 
1293
 
    # get last component
1294
 
    idx = name.rfind('/')
1295
 
    if idx != -1:
1296
 
        name = name[idx+1 : ]
1297
 
    idx = name.rfind('\\')
1298
 
    if idx != -1:
1299
 
        name = name[idx+1 : ]
1300
 
 
1301
 
    # make it not a hidden file
1302
 
    name = name.lstrip('.')
1303
 
 
1304
 
    # remove any wierd characters; we don't escape them but rather
1305
 
    # just pull them out
1306
 
    name = re.sub(r'[^\w.]', '', name)
1307
 
 
1308
 
    s = hexlify(rand_bytes(8))
1309
 
    return '-'.join((name, compact_date(time()), s))
1310
 
 
1311
 
 
1312
 
def gen_root_id():
1313
 
    """Return a new tree-root file id."""
1314
 
    return gen_file_id('TREE_ROOT')
1315
 
 
1316
 
 
 
1285
@deprecated_function(zero_eight)
 
1286
def ScratchBranch(*args, **kwargs):
 
1287
    """See bzrlib.bzrdir.ScratchDir."""
 
1288
    d = ScratchDir(*args, **kwargs)
 
1289
    return d.open_branch()
 
1290
 
 
1291
 
 
1292
@deprecated_function(zero_eight)
 
1293
def is_control_file(*args, **kwargs):
 
1294
    """See bzrlib.workingtree.is_control_file."""
 
1295
    return bzrlib.workingtree.is_control_file(*args, **kwargs)