~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: John Arbash Meinel
  • Date: 2007-03-12 16:29:47 UTC
  • mfrom: (2325.2.5 bzr.dev)
  • mto: This revision was merged to the branch mainline in revision 2343.
  • Revision ID: john@arbash-meinel.com-20070312162947-y3a3fjf0iwalwot5
(Marien Zwart) RevisionSpec.from_string() should support Unicode parameters. (especially for revid:)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 Canonical Ltd
2
 
 
 
1
# Copyright (C) 2005, 2006, 2007 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
 
import sys, os
 
18
from cStringIO import StringIO
 
19
 
 
20
from bzrlib.lazy_import import lazy_import
 
21
lazy_import(globals(), """
 
22
from copy import deepcopy
 
23
from unittest import TestSuite
 
24
from warnings import warn
19
25
 
20
26
import bzrlib
 
27
from bzrlib import (
 
28
        bzrdir,
 
29
        cache_utf8,
 
30
        config as _mod_config,
 
31
        errors,
 
32
        lockdir,
 
33
        lockable_files,
 
34
        osutils,
 
35
        revision as _mod_revision,
 
36
        transport,
 
37
        tree,
 
38
        ui,
 
39
        urlutils,
 
40
        )
 
41
from bzrlib.config import BranchConfig, TreeConfig
 
42
from bzrlib.lockable_files import LockableFiles, TransportLock
 
43
from bzrlib.tag import (
 
44
    BasicTags,
 
45
    DisabledTags,
 
46
    )
 
47
""")
 
48
 
 
49
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
50
from bzrlib.errors import (BzrError, BzrCheckError, DivergedBranches,
 
51
                           HistoryMissing, InvalidRevisionId,
 
52
                           InvalidRevisionNumber, LockError, NoSuchFile,
 
53
                           NoSuchRevision, NoWorkingTree, NotVersionedError,
 
54
                           NotBranchError, UninitializableFormat,
 
55
                           UnlistableStore, UnlistableBranch,
 
56
                           )
 
57
from bzrlib.symbol_versioning import (deprecated_function,
 
58
                                      deprecated_method,
 
59
                                      DEPRECATED_PARAMETER,
 
60
                                      deprecated_passed,
 
61
                                      zero_eight, zero_nine,
 
62
                                      )
21
63
from bzrlib.trace import mutter, note
22
 
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, splitpath, \
23
 
     sha_file, appendpath, file_kind
24
 
from bzrlib.errors import BzrError
25
 
 
26
 
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
27
 
## TODO: Maybe include checks for common corruption of newlines, etc?
28
 
 
29
 
 
30
 
 
31
 
def find_branch(f, **args):
32
 
    if f and (f.startswith('http://') or f.startswith('https://')):
33
 
        import remotebranch 
34
 
        return remotebranch.RemoteBranch(f, **args)
35
 
    else:
36
 
        return Branch(f, **args)
37
 
 
38
 
 
39
 
def find_cached_branch(f, cache_root, **args):
40
 
    from remotebranch import RemoteBranch
41
 
    br = find_branch(f, **args)
42
 
    def cacheify(br, store_name):
43
 
        from meta_store import CachedStore
44
 
        cache_path = os.path.join(cache_root, store_name)
45
 
        os.mkdir(cache_path)
46
 
        new_store = CachedStore(getattr(br, store_name), cache_path)
47
 
        setattr(br, store_name, new_store)
48
 
 
49
 
    if isinstance(br, RemoteBranch):
50
 
        cacheify(br, 'inventory_store')
51
 
        cacheify(br, 'text_store')
52
 
        cacheify(br, 'revision_store')
53
 
    return br
54
 
 
55
 
 
56
 
def _relpath(base, path):
57
 
    """Return path relative to base, or raise exception.
58
 
 
59
 
    The path may be either an absolute path or a path relative to the
60
 
    current working directory.
61
 
 
62
 
    Lifted out of Branch.relpath for ease of testing.
63
 
 
64
 
    os.path.commonprefix (python2.4) has a bad bug that it works just
65
 
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
66
 
    avoids that problem."""
67
 
    rp = os.path.abspath(path)
68
 
 
69
 
    s = []
70
 
    head = rp
71
 
    while len(head) >= len(base):
72
 
        if head == base:
73
 
            break
74
 
        head, tail = os.path.split(head)
75
 
        if tail:
76
 
            s.insert(0, tail)
77
 
    else:
78
 
        from errors import NotBranchError
79
 
        raise NotBranchError("path %r is not within branch %r" % (rp, base))
80
 
 
81
 
    return os.sep.join(s)
82
 
        
83
 
 
84
 
def find_branch_root(f=None):
85
 
    """Find the branch root enclosing f, or pwd.
86
 
 
87
 
    f may be a filename or a URL.
88
 
 
89
 
    It is not necessary that f exists.
90
 
 
91
 
    Basically we keep looking up until we find the control directory or
92
 
    run into the root."""
93
 
    if f == None:
94
 
        f = os.getcwd()
95
 
    elif hasattr(os.path, 'realpath'):
96
 
        f = os.path.realpath(f)
97
 
    else:
98
 
        f = os.path.abspath(f)
99
 
    if not os.path.exists(f):
100
 
        raise BzrError('%r does not exist' % f)
101
 
        
102
 
 
103
 
    orig_f = f
104
 
 
105
 
    while True:
106
 
        if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
107
 
            return f
108
 
        head, tail = os.path.split(f)
109
 
        if head == f:
110
 
            # reached the root, whatever that may be
111
 
            raise BzrError('%r is not in a branch' % orig_f)
112
 
        f = head
113
 
    
114
 
class DivergedBranches(Exception):
115
 
    def __init__(self, branch1, branch2):
116
 
        self.branch1 = branch1
117
 
        self.branch2 = branch2
118
 
        Exception.__init__(self, "These branches have diverged.")
119
 
 
120
 
 
121
 
class NoSuchRevision(BzrError):
122
 
    def __init__(self, branch, revision):
123
 
        self.branch = branch
124
 
        self.revision = revision
125
 
        msg = "Branch %s has no revision %d" % (branch, revision)
126
 
        BzrError.__init__(self, msg)
 
64
 
 
65
 
 
66
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
 
67
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
 
68
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
 
69
 
 
70
 
 
71
# TODO: Maybe include checks for common corruption of newlines, etc?
 
72
 
 
73
# TODO: Some operations like log might retrieve the same revisions
 
74
# repeatedly to calculate deltas.  We could perhaps have a weakref
 
75
# cache in memory to make this faster.  In general anything can be
 
76
# cached in memory between lock and unlock operations. .. nb thats
 
77
# what the transaction identity map provides
127
78
 
128
79
 
129
80
######################################################################
133
84
    """Branch holding a history of revisions.
134
85
 
135
86
    base
136
 
        Base directory of the branch.
137
 
 
138
 
    _lock_mode
139
 
        None, or 'r' or 'w'
140
 
 
141
 
    _lock_count
142
 
        If _lock_mode is true, a positive count of the number of times the
143
 
        lock has been taken.
144
 
 
145
 
    _lock
146
 
        Lock object from bzrlib.lock.
 
87
        Base directory/url of the branch.
 
88
 
 
89
    hooks: An instance of BranchHooks.
147
90
    """
 
91
    # this is really an instance variable - FIXME move it there
 
92
    # - RBC 20060112
148
93
    base = None
149
 
    _lock_mode = None
150
 
    _lock_count = None
151
 
    _lock = None
152
 
    
153
 
    # Map some sort of prefix into a namespace
154
 
    # stuff like "revno:10", "revid:", etc.
155
 
    # This should match a prefix with a function which accepts
156
 
    REVISION_NAMESPACES = {}
157
 
 
158
 
    def __init__(self, base, init=False, find_root=True):
159
 
        """Create new branch object at a particular location.
160
 
 
161
 
        base -- Base directory for the branch.
162
 
        
163
 
        init -- If True, create new control files in a previously
164
 
             unversioned directory.  If False, the branch must already
165
 
             be versioned.
166
 
 
167
 
        find_root -- If true and init is false, find the root of the
168
 
             existing branch containing base.
169
 
 
170
 
        In the test suite, creation of new trees is tested using the
171
 
        `ScratchBranch` class.
172
 
        """
173
 
        from bzrlib.store import ImmutableStore
174
 
        if init:
175
 
            self.base = os.path.realpath(base)
176
 
            self._make_control()
177
 
        elif find_root:
178
 
            self.base = find_branch_root(base)
179
 
        else:
180
 
            self.base = os.path.realpath(base)
181
 
            if not isdir(self.controlfilename('.')):
182
 
                from errors import NotBranchError
183
 
                raise NotBranchError("not a bzr branch: %s" % quotefn(base),
184
 
                                     ['use "bzr init" to initialize a new working tree',
185
 
                                      'current bzr can only operate from top-of-tree'])
186
 
        self._check_format()
187
 
 
188
 
        self.text_store = ImmutableStore(self.controlfilename('text-store'))
189
 
        self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
190
 
        self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
191
 
 
192
 
 
193
 
    def __str__(self):
194
 
        return '%s(%r)' % (self.__class__.__name__, self.base)
195
 
 
196
 
 
197
 
    __repr__ = __str__
198
 
 
199
 
 
200
 
    def __del__(self):
201
 
        if self._lock_mode or self._lock:
202
 
            from warnings import warn
203
 
            warn("branch %r was not explicitly unlocked" % self)
204
 
            self._lock.unlock()
205
 
 
206
 
 
 
94
 
 
95
    # override this to set the strategy for storing tags
 
96
    def _make_tags(self):
 
97
        return DisabledTags(self)
 
98
 
 
99
    def __init__(self, *ignored, **ignored_too):
 
100
        self.tags = self._make_tags()
 
101
 
 
102
    def break_lock(self):
 
103
        """Break a lock if one is present from another instance.
 
104
 
 
105
        Uses the ui factory to ask for confirmation if the lock may be from
 
106
        an active process.
 
107
 
 
108
        This will probe the repository for its lock as well.
 
109
        """
 
110
        self.control_files.break_lock()
 
111
        self.repository.break_lock()
 
112
        master = self.get_master_branch()
 
113
        if master is not None:
 
114
            master.break_lock()
 
115
 
 
116
    @staticmethod
 
117
    @deprecated_method(zero_eight)
 
118
    def open_downlevel(base):
 
119
        """Open a branch which may be of an old format."""
 
120
        return Branch.open(base, _unsupported=True)
 
121
        
 
122
    @staticmethod
 
123
    def open(base, _unsupported=False):
 
124
        """Open the branch rooted at base.
 
125
 
 
126
        For instance, if the branch is at URL/.bzr/branch,
 
127
        Branch.open(URL) -> a Branch instance.
 
128
        """
 
129
        control = bzrdir.BzrDir.open(base, _unsupported)
 
130
        return control.open_branch(_unsupported)
 
131
 
 
132
    @staticmethod
 
133
    def open_containing(url):
 
134
        """Open an existing branch which contains url.
 
135
        
 
136
        This probes for a branch at url, and searches upwards from there.
 
137
 
 
138
        Basically we keep looking up until we find the control directory or
 
139
        run into the root.  If there isn't one, raises NotBranchError.
 
140
        If there is one and it is either an unrecognised format or an unsupported 
 
141
        format, UnknownFormatError or UnsupportedFormatError are raised.
 
142
        If there is one, it is returned, along with the unused portion of url.
 
143
        """
 
144
        control, relpath = bzrdir.BzrDir.open_containing(url)
 
145
        return control.open_branch(), relpath
 
146
 
 
147
    @staticmethod
 
148
    @deprecated_function(zero_eight)
 
149
    def initialize(base):
 
150
        """Create a new working tree and branch, rooted at 'base' (url)
 
151
 
 
152
        NOTE: This will soon be deprecated in favour of creation
 
153
        through a BzrDir.
 
154
        """
 
155
        return bzrdir.BzrDir.create_standalone_workingtree(base).branch
 
156
 
 
157
    @deprecated_function(zero_eight)
 
158
    def setup_caching(self, cache_root):
 
159
        """Subclasses that care about caching should override this, and set
 
160
        up cached stores located under cache_root.
 
161
        
 
162
        NOTE: This is unused.
 
163
        """
 
164
        pass
 
165
 
 
166
    def get_config(self):
 
167
        return BranchConfig(self)
 
168
 
 
169
    def _get_nick(self):
 
170
        return self.get_config().get_nickname()
 
171
 
 
172
    def _set_nick(self, nick):
 
173
        self.get_config().set_user_option('nickname', nick)
 
174
 
 
175
    nick = property(_get_nick, _set_nick)
 
176
 
 
177
    def is_locked(self):
 
178
        raise NotImplementedError(self.is_locked)
207
179
 
208
180
    def lock_write(self):
209
 
        if self._lock_mode:
210
 
            if self._lock_mode != 'w':
211
 
                from errors import LockError
212
 
                raise LockError("can't upgrade to a write lock from %r" %
213
 
                                self._lock_mode)
214
 
            self._lock_count += 1
215
 
        else:
216
 
            from bzrlib.lock import WriteLock
217
 
 
218
 
            self._lock = WriteLock(self.controlfilename('branch-lock'))
219
 
            self._lock_mode = 'w'
220
 
            self._lock_count = 1
221
 
 
222
 
 
 
181
        raise NotImplementedError(self.lock_write)
223
182
 
224
183
    def lock_read(self):
225
 
        if self._lock_mode:
226
 
            assert self._lock_mode in ('r', 'w'), \
227
 
                   "invalid lock mode %r" % self._lock_mode
228
 
            self._lock_count += 1
229
 
        else:
230
 
            from bzrlib.lock import ReadLock
231
 
 
232
 
            self._lock = ReadLock(self.controlfilename('branch-lock'))
233
 
            self._lock_mode = 'r'
234
 
            self._lock_count = 1
235
 
                        
236
 
 
237
 
            
 
184
        raise NotImplementedError(self.lock_read)
 
185
 
238
186
    def unlock(self):
239
 
        if not self._lock_mode:
240
 
            from errors import LockError
241
 
            raise LockError('branch %r is not locked' % (self))
242
 
 
243
 
        if self._lock_count > 1:
244
 
            self._lock_count -= 1
245
 
        else:
246
 
            self._lock.unlock()
247
 
            self._lock = None
248
 
            self._lock_mode = self._lock_count = None
249
 
 
 
187
        raise NotImplementedError(self.unlock)
 
188
 
 
189
    def peek_lock_mode(self):
 
190
        """Return lock mode for the Branch: 'r', 'w' or None"""
 
191
        raise NotImplementedError(self.peek_lock_mode)
 
192
 
 
193
    def get_physical_lock_status(self):
 
194
        raise NotImplementedError(self.get_physical_lock_status)
250
195
 
251
196
    def abspath(self, name):
252
 
        """Return absolute filename for something in the branch"""
253
 
        return os.path.join(self.base, name)
254
 
 
255
 
 
256
 
    def relpath(self, path):
257
 
        """Return path relative to this branch of something inside it.
258
 
 
259
 
        Raises an error if path is not in this branch."""
260
 
        return _relpath(self.base, path)
261
 
 
262
 
 
263
 
    def controlfilename(self, file_or_path):
264
 
        """Return location relative to branch."""
265
 
        if isinstance(file_or_path, basestring):
266
 
            file_or_path = [file_or_path]
267
 
        return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
268
 
 
269
 
 
270
 
    def controlfile(self, file_or_path, mode='r'):
271
 
        """Open a control file for this branch.
272
 
 
273
 
        There are two classes of file in the control directory: text
274
 
        and binary.  binary files are untranslated byte streams.  Text
275
 
        control files are stored with Unix newlines and in UTF-8, even
276
 
        if the platform or locale defaults are different.
277
 
 
278
 
        Controlfiles should almost never be opened in write mode but
279
 
        rather should be atomically copied and replaced using atomicfile.
280
 
        """
281
 
 
282
 
        fn = self.controlfilename(file_or_path)
283
 
 
284
 
        if mode == 'rb' or mode == 'wb':
285
 
            return file(fn, mode)
286
 
        elif mode == 'r' or mode == 'w':
287
 
            # open in binary mode anyhow so there's no newline translation;
288
 
            # codecs uses line buffering by default; don't want that.
289
 
            import codecs
290
 
            return codecs.open(fn, mode + 'b', 'utf-8',
291
 
                               buffering=60000)
 
197
        """Return absolute filename for something in the branch
 
198
        
 
199
        XXX: Robert Collins 20051017 what is this used for? why is it a branch
 
200
        method and not a tree method.
 
201
        """
 
202
        raise NotImplementedError(self.abspath)
 
203
 
 
204
    def bind(self, other):
 
205
        """Bind the local branch the other branch.
 
206
 
 
207
        :param other: The branch to bind to
 
208
        :type other: Branch
 
209
        """
 
210
        raise errors.UpgradeRequired(self.base)
 
211
 
 
212
    @needs_write_lock
 
213
    def fetch(self, from_branch, last_revision=None, pb=None):
 
214
        """Copy revisions from from_branch into this branch.
 
215
 
 
216
        :param from_branch: Where to copy from.
 
217
        :param last_revision: What revision to stop at (None for at the end
 
218
                              of the branch.
 
219
        :param pb: An optional progress bar to use.
 
220
 
 
221
        Returns the copied revision count and the failed revisions in a tuple:
 
222
        (copied, failures).
 
223
        """
 
224
        if self.base == from_branch.base:
 
225
            return (0, [])
 
226
        if pb is None:
 
227
            nested_pb = ui.ui_factory.nested_progress_bar()
 
228
            pb = nested_pb
292
229
        else:
293
 
            raise BzrError("invalid controlfile mode %r" % mode)
294
 
 
295
 
 
296
 
 
297
 
    def _make_control(self):
298
 
        from bzrlib.inventory import Inventory
299
 
        from bzrlib.xml import pack_xml
300
 
        
301
 
        os.mkdir(self.controlfilename([]))
302
 
        self.controlfile('README', 'w').write(
303
 
            "This is a Bazaar-NG control directory.\n"
304
 
            "Do not change any files in this directory.\n")
305
 
        self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
306
 
        for d in ('text-store', 'inventory-store', 'revision-store'):
307
 
            os.mkdir(self.controlfilename(d))
308
 
        for f in ('revision-history', 'merged-patches',
309
 
                  'pending-merged-patches', 'branch-name',
310
 
                  'branch-lock',
311
 
                  'pending-merges'):
312
 
            self.controlfile(f, 'w').write('')
313
 
        mutter('created control directory in ' + self.base)
314
 
 
315
 
        pack_xml(Inventory(gen_root_id()), self.controlfile('inventory','w'))
316
 
 
317
 
 
318
 
    def _check_format(self):
319
 
        """Check this branch format is supported.
320
 
 
321
 
        The current tool only supports the current unstable format.
322
 
 
323
 
        In the future, we might need different in-memory Branch
324
 
        classes to support downlevel branches.  But not yet.
325
 
        """
326
 
        # This ignores newlines so that we can open branches created
327
 
        # on Windows from Linux and so on.  I think it might be better
328
 
        # to always make all internal files in unix format.
329
 
        fmt = self.controlfile('branch-format', 'r').read()
330
 
        fmt.replace('\r\n', '')
331
 
        if fmt != BZR_BRANCH_FORMAT:
332
 
            raise BzrError('sorry, branch format %r not supported' % fmt,
333
 
                           ['use a different bzr version',
334
 
                            'or remove the .bzr directory and "bzr init" again'])
 
230
            nested_pb = None
 
231
 
 
232
        from_branch.lock_read()
 
233
        try:
 
234
            if last_revision is None:
 
235
                pb.update('get source history')
 
236
                last_revision = from_branch.last_revision()
 
237
                if last_revision is None:
 
238
                    last_revision = _mod_revision.NULL_REVISION
 
239
            return self.repository.fetch(from_branch.repository,
 
240
                                         revision_id=last_revision,
 
241
                                         pb=nested_pb)
 
242
        finally:
 
243
            if nested_pb is not None:
 
244
                nested_pb.finished()
 
245
            from_branch.unlock()
 
246
 
 
247
    def get_bound_location(self):
 
248
        """Return the URL of the branch we are bound to.
 
249
 
 
250
        Older format branches cannot bind, please be sure to use a metadir
 
251
        branch.
 
252
        """
 
253
        return None
 
254
    
 
255
    def get_old_bound_location(self):
 
256
        """Return the URL of the branch we used to be bound to
 
257
        """
 
258
        raise errors.UpgradeRequired(self.base)
 
259
 
 
260
    def get_commit_builder(self, parents, config=None, timestamp=None, 
 
261
                           timezone=None, committer=None, revprops=None, 
 
262
                           revision_id=None):
 
263
        """Obtain a CommitBuilder for this branch.
 
264
        
 
265
        :param parents: Revision ids of the parents of the new revision.
 
266
        :param config: Optional configuration to use.
 
267
        :param timestamp: Optional timestamp recorded for commit.
 
268
        :param timezone: Optional timezone for timestamp.
 
269
        :param committer: Optional committer to set for commit.
 
270
        :param revprops: Optional dictionary of revision properties.
 
271
        :param revision_id: Optional revision id.
 
272
        """
 
273
 
 
274
        if config is None:
 
275
            config = self.get_config()
 
276
        
 
277
        return self.repository.get_commit_builder(self, parents, config,
 
278
            timestamp, timezone, committer, revprops, revision_id)
 
279
 
 
280
    def get_master_branch(self):
 
281
        """Return the branch we are bound to.
 
282
        
 
283
        :return: Either a Branch, or None
 
284
        """
 
285
        return None
 
286
 
 
287
    def get_revision_delta(self, revno):
 
288
        """Return the delta for one revision.
 
289
 
 
290
        The delta is relative to its mainline predecessor, or the
 
291
        empty tree for revision 1.
 
292
        """
 
293
        assert isinstance(revno, int)
 
294
        rh = self.revision_history()
 
295
        if not (1 <= revno <= len(rh)):
 
296
            raise InvalidRevisionNumber(revno)
 
297
        return self.repository.get_revision_delta(rh[revno-1])
335
298
 
336
299
    def get_root_id(self):
337
300
        """Return the id of this branches root"""
338
 
        inv = self.read_working_inventory()
339
 
        return inv.root.file_id
340
 
 
341
 
    def set_root_id(self, file_id):
342
 
        inv = self.read_working_inventory()
343
 
        orig_root_id = inv.root.file_id
344
 
        del inv._byid[inv.root.file_id]
345
 
        inv.root.file_id = file_id
346
 
        inv._byid[inv.root.file_id] = inv.root
347
 
        for fid in inv:
348
 
            entry = inv[fid]
349
 
            if entry.parent_id in (None, orig_root_id):
350
 
                entry.parent_id = inv.root.file_id
351
 
        self._write_inventory(inv)
352
 
 
353
 
    def read_working_inventory(self):
354
 
        """Read the working inventory."""
355
 
        from bzrlib.inventory import Inventory
356
 
        from bzrlib.xml import unpack_xml
357
 
        from time import time
358
 
        before = time()
359
 
        self.lock_read()
360
 
        try:
361
 
            # ElementTree does its own conversion from UTF-8, so open in
362
 
            # binary.
363
 
            inv = unpack_xml(Inventory,
364
 
                             self.controlfile('inventory', 'rb'))
365
 
            mutter("loaded inventory of %d items in %f"
366
 
                   % (len(inv), time() - before))
367
 
            return inv
368
 
        finally:
369
 
            self.unlock()
370
 
            
371
 
 
372
 
    def _write_inventory(self, inv):
373
 
        """Update the working inventory.
374
 
 
375
 
        That is to say, the inventory describing changes underway, that
376
 
        will be committed to the next revision.
377
 
        """
378
 
        from bzrlib.atomicfile import AtomicFile
379
 
        from bzrlib.xml import pack_xml
380
 
        
381
 
        self.lock_write()
382
 
        try:
383
 
            f = AtomicFile(self.controlfilename('inventory'), 'wb')
384
 
            try:
385
 
                pack_xml(inv, f)
386
 
                f.commit()
387
 
            finally:
388
 
                f.close()
389
 
        finally:
390
 
            self.unlock()
391
 
        
392
 
        mutter('wrote working inventory')
393
 
            
394
 
 
395
 
    inventory = property(read_working_inventory, _write_inventory, None,
396
 
                         """Inventory for the working copy.""")
397
 
 
398
 
 
399
 
    def add(self, files, verbose=False, ids=None):
400
 
        """Make files versioned.
401
 
 
402
 
        Note that the command line normally calls smart_add instead.
403
 
 
404
 
        This puts the files in the Added state, so that they will be
405
 
        recorded by the next commit.
406
 
 
407
 
        files
408
 
            List of paths to add, relative to the base of the tree.
409
 
 
410
 
        ids
411
 
            If set, use these instead of automatically generated ids.
412
 
            Must be the same length as the list of files, but may
413
 
            contain None for ids that are to be autogenerated.
414
 
 
415
 
        TODO: Perhaps have an option to add the ids even if the files do
416
 
              not (yet) exist.
417
 
 
418
 
        TODO: Perhaps return the ids of the files?  But then again it
419
 
              is easy to retrieve them if they're needed.
420
 
 
421
 
        TODO: Adding a directory should optionally recurse down and
422
 
              add all non-ignored children.  Perhaps do that in a
423
 
              higher-level method.
424
 
        """
425
 
        from bzrlib.textui import show_status
426
 
        # TODO: Re-adding a file that is removed in the working copy
427
 
        # should probably put it back with the previous ID.
428
 
        if isinstance(files, basestring):
429
 
            assert(ids is None or isinstance(ids, basestring))
430
 
            files = [files]
431
 
            if ids is not None:
432
 
                ids = [ids]
433
 
 
434
 
        if ids is None:
435
 
            ids = [None] * len(files)
436
 
        else:
437
 
            assert(len(ids) == len(files))
438
 
 
439
 
        self.lock_write()
440
 
        try:
441
 
            inv = self.read_working_inventory()
442
 
            for f,file_id in zip(files, ids):
443
 
                if is_control_file(f):
444
 
                    raise BzrError("cannot add control file %s" % quotefn(f))
445
 
 
446
 
                fp = splitpath(f)
447
 
 
448
 
                if len(fp) == 0:
449
 
                    raise BzrError("cannot add top-level %r" % f)
450
 
 
451
 
                fullpath = os.path.normpath(self.abspath(f))
452
 
 
453
 
                try:
454
 
                    kind = file_kind(fullpath)
455
 
                except OSError:
456
 
                    # maybe something better?
457
 
                    raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
458
 
 
459
 
                if kind != 'file' and kind != 'directory':
460
 
                    raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
461
 
 
462
 
                if file_id is None:
463
 
                    file_id = gen_file_id(f)
464
 
                inv.add_path(f, kind=kind, file_id=file_id)
465
 
 
466
 
                if verbose:
467
 
                    print 'added', quotefn(f)
468
 
 
469
 
                mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
470
 
 
471
 
            self._write_inventory(inv)
472
 
        finally:
473
 
            self.unlock()
474
 
            
475
 
 
476
 
    def print_file(self, file, revno):
 
301
        raise NotImplementedError(self.get_root_id)
 
302
 
 
303
    def print_file(self, file, revision_id):
477
304
        """Print `file` to stdout."""
478
 
        self.lock_read()
479
 
        try:
480
 
            tree = self.revision_tree(self.lookup_revision(revno))
481
 
            # use inventory as it was in that revision
482
 
            file_id = tree.inventory.path2id(file)
483
 
            if not file_id:
484
 
                raise BzrError("%r is not present in revision %s" % (file, revno))
485
 
            tree.print_file(file_id)
486
 
        finally:
487
 
            self.unlock()
488
 
 
489
 
 
490
 
    def remove(self, files, verbose=False):
491
 
        """Mark nominated files for removal from the inventory.
492
 
 
493
 
        This does not remove their text.  This does not run on 
494
 
 
495
 
        TODO: Refuse to remove modified files unless --force is given?
496
 
 
497
 
        TODO: Do something useful with directories.
498
 
 
499
 
        TODO: Should this remove the text or not?  Tough call; not
500
 
        removing may be useful and the user can just use use rm, and
501
 
        is the opposite of add.  Removing it is consistent with most
502
 
        other tools.  Maybe an option.
503
 
        """
504
 
        from bzrlib.textui import show_status
505
 
        ## TODO: Normalize names
506
 
        ## TODO: Remove nested loops; better scalability
507
 
        if isinstance(files, basestring):
508
 
            files = [files]
509
 
 
510
 
        self.lock_write()
511
 
 
512
 
        try:
513
 
            tree = self.working_tree()
514
 
            inv = tree.inventory
515
 
 
516
 
            # do this before any modifications
517
 
            for f in files:
518
 
                fid = inv.path2id(f)
519
 
                if not fid:
520
 
                    raise BzrError("cannot remove unversioned file %s" % quotefn(f))
521
 
                mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
522
 
                if verbose:
523
 
                    # having remove it, it must be either ignored or unknown
524
 
                    if tree.is_ignored(f):
525
 
                        new_status = 'I'
526
 
                    else:
527
 
                        new_status = '?'
528
 
                    show_status(new_status, inv[fid].kind, quotefn(f))
529
 
                del inv[fid]
530
 
 
531
 
            self._write_inventory(inv)
532
 
        finally:
533
 
            self.unlock()
534
 
 
535
 
 
536
 
    # FIXME: this doesn't need to be a branch method
537
 
    def set_inventory(self, new_inventory_list):
538
 
        from bzrlib.inventory import Inventory, InventoryEntry
539
 
        inv = Inventory(self.get_root_id())
540
 
        for path, file_id, parent, kind in new_inventory_list:
541
 
            name = os.path.basename(path)
542
 
            if name == "":
543
 
                continue
544
 
            inv.add(InventoryEntry(file_id, name, kind, parent))
545
 
        self._write_inventory(inv)
546
 
 
547
 
 
548
 
    def unknowns(self):
549
 
        """Return all unknown files.
550
 
 
551
 
        These are files in the working directory that are not versioned or
552
 
        control files or ignored.
553
 
        
554
 
        >>> b = ScratchBranch(files=['foo', 'foo~'])
555
 
        >>> list(b.unknowns())
556
 
        ['foo']
557
 
        >>> b.add('foo')
558
 
        >>> list(b.unknowns())
559
 
        []
560
 
        >>> b.remove('foo')
561
 
        >>> list(b.unknowns())
562
 
        ['foo']
563
 
        """
564
 
        return self.working_tree().unknowns()
565
 
 
 
305
        raise NotImplementedError(self.print_file)
566
306
 
567
307
    def append_revision(self, *revision_ids):
568
 
        from bzrlib.atomicfile import AtomicFile
569
 
 
570
 
        for revision_id in revision_ids:
571
 
            mutter("add {%s} to revision-history" % revision_id)
572
 
 
573
 
        rev_history = self.revision_history()
574
 
        rev_history.extend(revision_ids)
575
 
 
576
 
        f = AtomicFile(self.controlfilename('revision-history'))
577
 
        try:
578
 
            for rev_id in rev_history:
579
 
                print >>f, rev_id
580
 
            f.commit()
581
 
        finally:
582
 
            f.close()
583
 
 
584
 
 
585
 
    def get_revision(self, revision_id):
586
 
        """Return the Revision object for a named revision"""
587
 
        from bzrlib.revision import Revision
588
 
        from bzrlib.xml import unpack_xml
589
 
 
590
 
        self.lock_read()
591
 
        try:
592
 
            if not revision_id or not isinstance(revision_id, basestring):
593
 
                raise ValueError('invalid revision-id: %r' % revision_id)
594
 
            r = unpack_xml(Revision, self.revision_store[revision_id])
595
 
        finally:
596
 
            self.unlock()
597
 
            
598
 
        assert r.revision_id == revision_id
599
 
        return r
600
 
        
601
 
 
602
 
    def get_revision_sha1(self, revision_id):
603
 
        """Hash the stored value of a revision, and return it."""
604
 
        # In the future, revision entries will be signed. At that
605
 
        # point, it is probably best *not* to include the signature
606
 
        # in the revision hash. Because that lets you re-sign
607
 
        # the revision, (add signatures/remove signatures) and still
608
 
        # have all hash pointers stay consistent.
609
 
        # But for now, just hash the contents.
610
 
        return sha_file(self.revision_store[revision_id])
611
 
 
612
 
 
613
 
    def get_inventory(self, inventory_id):
614
 
        """Get Inventory object by hash.
615
 
 
616
 
        TODO: Perhaps for this and similar methods, take a revision
617
 
               parameter which can be either an integer revno or a
618
 
               string hash."""
619
 
        from bzrlib.inventory import Inventory
620
 
        from bzrlib.xml import unpack_xml
621
 
 
622
 
        return unpack_xml(Inventory, self.inventory_store[inventory_id])
623
 
            
624
 
 
625
 
    def get_inventory_sha1(self, inventory_id):
626
 
        """Return the sha1 hash of the inventory entry
627
 
        """
628
 
        return sha_file(self.inventory_store[inventory_id])
629
 
 
630
 
 
631
 
    def get_revision_inventory(self, revision_id):
632
 
        """Return inventory of a past revision."""
633
 
        # bzr 0.0.6 imposes the constraint that the inventory_id
634
 
        # must be the same as its revision, so this is trivial.
635
 
        if revision_id == None:
636
 
            from bzrlib.inventory import Inventory
637
 
            return Inventory(self.get_root_id())
638
 
        else:
639
 
            return self.get_inventory(revision_id)
640
 
 
 
308
        raise NotImplementedError(self.append_revision)
 
309
 
 
310
    def set_revision_history(self, rev_history):
 
311
        raise NotImplementedError(self.set_revision_history)
641
312
 
642
313
    def revision_history(self):
643
 
        """Return sequence of revision hashes on to this branch.
644
 
 
645
 
        >>> ScratchBranch().revision_history()
646
 
        []
647
 
        """
648
 
        self.lock_read()
649
 
        try:
650
 
            return [l.rstrip('\r\n') for l in
651
 
                    self.controlfile('revision-history', 'r').readlines()]
652
 
        finally:
653
 
            self.unlock()
654
 
 
655
 
 
656
 
    def common_ancestor(self, other, self_revno=None, other_revno=None):
657
 
        """
658
 
        >>> import commit
659
 
        >>> sb = ScratchBranch(files=['foo', 'foo~'])
660
 
        >>> sb.common_ancestor(sb) == (None, None)
661
 
        True
662
 
        >>> commit.commit(sb, "Committing first revision", verbose=False)
663
 
        >>> sb.common_ancestor(sb)[0]
664
 
        1
665
 
        >>> clone = sb.clone()
666
 
        >>> commit.commit(sb, "Committing second revision", verbose=False)
667
 
        >>> sb.common_ancestor(sb)[0]
668
 
        2
669
 
        >>> sb.common_ancestor(clone)[0]
670
 
        1
671
 
        >>> commit.commit(clone, "Committing divergent second revision", 
672
 
        ...               verbose=False)
673
 
        >>> sb.common_ancestor(clone)[0]
674
 
        1
675
 
        >>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
676
 
        True
677
 
        >>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
678
 
        True
679
 
        >>> clone2 = sb.clone()
680
 
        >>> sb.common_ancestor(clone2)[0]
681
 
        2
682
 
        >>> sb.common_ancestor(clone2, self_revno=1)[0]
683
 
        1
684
 
        >>> sb.common_ancestor(clone2, other_revno=1)[0]
685
 
        1
686
 
        """
687
 
        my_history = self.revision_history()
688
 
        other_history = other.revision_history()
689
 
        if self_revno is None:
690
 
            self_revno = len(my_history)
691
 
        if other_revno is None:
692
 
            other_revno = len(other_history)
693
 
        indices = range(min((self_revno, other_revno)))
694
 
        indices.reverse()
695
 
        for r in indices:
696
 
            if my_history[r] == other_history[r]:
697
 
                return r+1, my_history[r]
698
 
        return None, None
699
 
 
700
 
    def enum_history(self, direction):
701
 
        """Return (revno, revision_id) for history of branch.
702
 
 
703
 
        direction
704
 
            'forward' is from earliest to latest
705
 
            'reverse' is from latest to earliest
706
 
        """
707
 
        rh = self.revision_history()
708
 
        if direction == 'forward':
709
 
            i = 1
710
 
            for rid in rh:
711
 
                yield i, rid
712
 
                i += 1
713
 
        elif direction == 'reverse':
714
 
            i = len(rh)
715
 
            while i > 0:
716
 
                yield i, rh[i-1]
717
 
                i -= 1
718
 
        else:
719
 
            raise ValueError('invalid history direction', direction)
720
 
 
 
314
        """Return sequence of revision hashes on to this branch."""
 
315
        raise NotImplementedError(self.revision_history)
721
316
 
722
317
    def revno(self):
723
318
        """Return current revision number for this branch.
727
322
        """
728
323
        return len(self.revision_history())
729
324
 
730
 
 
731
 
    def last_patch(self):
732
 
        """Return last patch hash, or None if no history.
733
 
        """
 
325
    def unbind(self):
 
326
        """Older format branches cannot bind or unbind."""
 
327
        raise errors.UpgradeRequired(self.base)
 
328
 
 
329
    def set_append_revisions_only(self, enabled):
 
330
        """Older format branches are never restricted to append-only"""
 
331
        raise errors.UpgradeRequired(self.base)
 
332
 
 
333
    def last_revision(self):
 
334
        """Return last revision id, or None"""
734
335
        ph = self.revision_history()
735
336
        if ph:
736
337
            return ph[-1]
737
338
        else:
738
339
            return None
739
340
 
 
341
    def last_revision_info(self):
 
342
        """Return information about the last revision.
 
343
 
 
344
        :return: A tuple (revno, last_revision_id).
 
345
        """
 
346
        rh = self.revision_history()
 
347
        revno = len(rh)
 
348
        if revno:
 
349
            return (revno, rh[-1])
 
350
        else:
 
351
            return (0, _mod_revision.NULL_REVISION)
740
352
 
741
353
    def missing_revisions(self, other, stop_revision=None):
742
 
        """
 
354
        """Return a list of new revisions that would perfectly fit.
 
355
        
743
356
        If self and other have not diverged, return a list of the revisions
744
357
        present in other, but missing from self.
745
 
 
746
 
        >>> from bzrlib.commit import commit
747
 
        >>> bzrlib.trace.silent = True
748
 
        >>> br1 = ScratchBranch()
749
 
        >>> br2 = ScratchBranch()
750
 
        >>> br1.missing_revisions(br2)
751
 
        []
752
 
        >>> commit(br2, "lala!", rev_id="REVISION-ID-1")
753
 
        >>> br1.missing_revisions(br2)
754
 
        [u'REVISION-ID-1']
755
 
        >>> br2.missing_revisions(br1)
756
 
        []
757
 
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1")
758
 
        >>> br1.missing_revisions(br2)
759
 
        []
760
 
        >>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
761
 
        >>> br1.missing_revisions(br2)
762
 
        [u'REVISION-ID-2A']
763
 
        >>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
764
 
        >>> br1.missing_revisions(br2)
765
 
        Traceback (most recent call last):
766
 
        DivergedBranches: These branches have diverged.
767
358
        """
768
359
        self_history = self.revision_history()
769
360
        self_len = len(self_history)
776
367
 
777
368
        if stop_revision is None:
778
369
            stop_revision = other_len
779
 
        elif stop_revision > other_len:
780
 
            raise NoSuchRevision(self, stop_revision)
781
 
        
 
370
        else:
 
371
            assert isinstance(stop_revision, int)
 
372
            if stop_revision > other_len:
 
373
                raise errors.NoSuchRevision(self, stop_revision)
782
374
        return other_history[self_len:stop_revision]
783
375
 
784
 
 
785
376
    def update_revisions(self, other, stop_revision=None):
786
 
        """Pull in all new revisions from other branch.
787
 
        
788
 
        >>> from bzrlib.commit import commit
789
 
        >>> bzrlib.trace.silent = True
790
 
        >>> br1 = ScratchBranch(files=['foo', 'bar'])
791
 
        >>> br1.add('foo')
792
 
        >>> br1.add('bar')
793
 
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
794
 
        >>> br2 = ScratchBranch()
795
 
        >>> br2.update_revisions(br1)
796
 
        Added 2 texts.
797
 
        Added 1 inventories.
798
 
        Added 1 revisions.
799
 
        >>> br2.revision_history()
800
 
        [u'REVISION-ID-1']
801
 
        >>> br2.update_revisions(br1)
802
 
        Added 0 texts.
803
 
        Added 0 inventories.
804
 
        Added 0 revisions.
805
 
        >>> br1.text_store.total_size() == br2.text_store.total_size()
806
 
        True
807
 
        """
808
 
        from bzrlib.progress import ProgressBar
809
 
 
810
 
        pb = ProgressBar()
811
 
 
812
 
        pb.update('comparing histories')
813
 
        revision_ids = self.missing_revisions(other, stop_revision)
814
 
 
815
 
        if hasattr(other.revision_store, "prefetch"):
816
 
            other.revision_store.prefetch(revision_ids)
817
 
        if hasattr(other.inventory_store, "prefetch"):
818
 
            inventory_ids = [other.get_revision(r).inventory_id
819
 
                             for r in revision_ids]
820
 
            other.inventory_store.prefetch(inventory_ids)
821
 
                
822
 
        revisions = []
823
 
        needed_texts = set()
824
 
        i = 0
825
 
        for rev_id in revision_ids:
826
 
            i += 1
827
 
            pb.update('fetching revision', i, len(revision_ids))
828
 
            rev = other.get_revision(rev_id)
829
 
            revisions.append(rev)
830
 
            inv = other.get_inventory(str(rev.inventory_id))
831
 
            for key, entry in inv.iter_entries():
832
 
                if entry.text_id is None:
833
 
                    continue
834
 
                if entry.text_id not in self.text_store:
835
 
                    needed_texts.add(entry.text_id)
836
 
 
837
 
        pb.clear()
838
 
                    
839
 
        count = self.text_store.copy_multi(other.text_store, needed_texts)
840
 
        print "Added %d texts." % count 
841
 
        inventory_ids = [ f.inventory_id for f in revisions ]
842
 
        count = self.inventory_store.copy_multi(other.inventory_store, 
843
 
                                                inventory_ids)
844
 
        print "Added %d inventories." % count 
845
 
        revision_ids = [ f.revision_id for f in revisions]
846
 
        count = self.revision_store.copy_multi(other.revision_store, 
847
 
                                               revision_ids)
848
 
        for revision_id in revision_ids:
849
 
            self.append_revision(revision_id)
850
 
        print "Added %d revisions." % count
851
 
                    
852
 
        
853
 
    def commit(self, *args, **kw):
854
 
        from bzrlib.commit import commit
855
 
        commit(self, *args, **kw)
856
 
        
857
 
 
858
 
    def lookup_revision(self, revision):
859
 
        """Return the revision identifier for a given revision information."""
860
 
        revno, info = self.get_revision_info(revision)
861
 
        return info
862
 
 
863
 
    def get_revision_info(self, revision):
864
 
        """Return (revno, revision id) for revision identifier.
865
 
 
866
 
        revision can be an integer, in which case it is assumed to be revno (though
867
 
            this will translate negative values into positive ones)
868
 
        revision can also be a string, in which case it is parsed for something like
869
 
            'date:' or 'revid:' etc.
870
 
        """
871
 
        if revision is None:
872
 
            return 0, None
873
 
        revno = None
874
 
        try:# Convert to int if possible
875
 
            revision = int(revision)
876
 
        except ValueError:
877
 
            pass
878
 
        revs = self.revision_history()
879
 
        if isinstance(revision, int):
880
 
            if revision == 0:
881
 
                return 0, None
882
 
            # Mabye we should do this first, but we don't need it if revision == 0
883
 
            if revision < 0:
884
 
                revno = len(revs) + revision + 1
885
 
            else:
886
 
                revno = revision
887
 
        elif isinstance(revision, basestring):
888
 
            for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
889
 
                if revision.startswith(prefix):
890
 
                    revno = func(self, revs, revision)
891
 
                    break
892
 
            else:
893
 
                raise BzrError('No namespace registered for string: %r' % revision)
894
 
 
895
 
        if revno is None or revno <= 0 or revno > len(revs):
896
 
            raise BzrError("no such revision %s" % revision)
897
 
        return revno, revs[revno-1]
898
 
 
899
 
    def _namespace_revno(self, revs, revision):
900
 
        """Lookup a revision by revision number"""
901
 
        assert revision.startswith('revno:')
902
 
        try:
903
 
            return int(revision[6:])
904
 
        except ValueError:
905
 
            return None
906
 
    REVISION_NAMESPACES['revno:'] = _namespace_revno
907
 
 
908
 
    def _namespace_revid(self, revs, revision):
909
 
        assert revision.startswith('revid:')
910
 
        try:
911
 
            return revs.index(revision[6:]) + 1
912
 
        except ValueError:
913
 
            return None
914
 
    REVISION_NAMESPACES['revid:'] = _namespace_revid
915
 
 
916
 
    def _namespace_last(self, revs, revision):
917
 
        assert revision.startswith('last:')
918
 
        try:
919
 
            offset = int(revision[5:])
920
 
        except ValueError:
921
 
            return None
922
 
        else:
923
 
            if offset <= 0:
924
 
                raise BzrError('You must supply a positive value for --revision last:XXX')
925
 
            return len(revs) - offset + 1
926
 
    REVISION_NAMESPACES['last:'] = _namespace_last
927
 
 
928
 
    def _namespace_tag(self, revs, revision):
929
 
        assert revision.startswith('tag:')
930
 
        raise BzrError('tag: namespace registered, but not implemented.')
931
 
    REVISION_NAMESPACES['tag:'] = _namespace_tag
932
 
 
933
 
    def _namespace_date(self, revs, revision):
934
 
        assert revision.startswith('date:')
935
 
        import datetime
936
 
        # Spec for date revisions:
937
 
        #   date:value
938
 
        #   value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
939
 
        #   it can also start with a '+/-/='. '+' says match the first
940
 
        #   entry after the given date. '-' is match the first entry before the date
941
 
        #   '=' is match the first entry after, but still on the given date.
942
 
        #
943
 
        #   +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
944
 
        #   -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
945
 
        #   =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
946
 
        #       May 13th, 2005 at 0:00
947
 
        #
948
 
        #   So the proper way of saying 'give me all entries for today' is:
949
 
        #       -r {date:+today}:{date:-tomorrow}
950
 
        #   The default is '=' when not supplied
951
 
        val = revision[5:]
952
 
        match_style = '='
953
 
        if val[:1] in ('+', '-', '='):
954
 
            match_style = val[:1]
955
 
            val = val[1:]
956
 
 
957
 
        today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
958
 
        if val.lower() == 'yesterday':
959
 
            dt = today - datetime.timedelta(days=1)
960
 
        elif val.lower() == 'today':
961
 
            dt = today
962
 
        elif val.lower() == 'tomorrow':
963
 
            dt = today + datetime.timedelta(days=1)
964
 
        else:
965
 
            import re
966
 
            # This should be done outside the function to avoid recompiling it.
967
 
            _date_re = re.compile(
968
 
                    r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
969
 
                    r'(,|T)?\s*'
970
 
                    r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
971
 
                )
972
 
            m = _date_re.match(val)
973
 
            if not m or (not m.group('date') and not m.group('time')):
974
 
                raise BzrError('Invalid revision date %r' % revision)
975
 
 
976
 
            if m.group('date'):
977
 
                year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
978
 
            else:
979
 
                year, month, day = today.year, today.month, today.day
980
 
            if m.group('time'):
981
 
                hour = int(m.group('hour'))
982
 
                minute = int(m.group('minute'))
983
 
                if m.group('second'):
984
 
                    second = int(m.group('second'))
985
 
                else:
986
 
                    second = 0
987
 
            else:
988
 
                hour, minute, second = 0,0,0
989
 
 
990
 
            dt = datetime.datetime(year=year, month=month, day=day,
991
 
                    hour=hour, minute=minute, second=second)
992
 
        first = dt
993
 
        last = None
994
 
        reversed = False
995
 
        if match_style == '-':
996
 
            reversed = True
997
 
        elif match_style == '=':
998
 
            last = dt + datetime.timedelta(days=1)
999
 
 
1000
 
        if reversed:
1001
 
            for i in range(len(revs)-1, -1, -1):
1002
 
                r = self.get_revision(revs[i])
1003
 
                # TODO: Handle timezone.
1004
 
                dt = datetime.datetime.fromtimestamp(r.timestamp)
1005
 
                if first >= dt and (last is None or dt >= last):
1006
 
                    return i+1
1007
 
        else:
1008
 
            for i in range(len(revs)):
1009
 
                r = self.get_revision(revs[i])
1010
 
                # TODO: Handle timezone.
1011
 
                dt = datetime.datetime.fromtimestamp(r.timestamp)
1012
 
                if first <= dt and (last is None or dt <= last):
1013
 
                    return i+1
1014
 
    REVISION_NAMESPACES['date:'] = _namespace_date
1015
 
 
1016
 
    def revision_tree(self, revision_id):
1017
 
        """Return Tree for a revision on this branch.
1018
 
 
1019
 
        `revision_id` may be None for the null revision, in which case
1020
 
        an `EmptyTree` is returned."""
1021
 
        from bzrlib.tree import EmptyTree, RevisionTree
1022
 
        # TODO: refactor this to use an existing revision object
1023
 
        # so we don't need to read it in twice.
1024
 
        if revision_id == None:
1025
 
            return EmptyTree(self.get_root_id())
1026
 
        else:
1027
 
            inv = self.get_revision_inventory(revision_id)
1028
 
            return RevisionTree(self.text_store, inv)
1029
 
 
1030
 
 
1031
 
    def working_tree(self):
1032
 
        """Return a `Tree` for the working copy."""
1033
 
        from workingtree import WorkingTree
1034
 
        return WorkingTree(self.base, self.read_working_inventory())
1035
 
 
 
377
        """Pull in new perfect-fit revisions.
 
378
 
 
379
        :param other: Another Branch to pull from
 
380
        :param stop_revision: Updated until the given revision
 
381
        :return: None
 
382
        """
 
383
        raise NotImplementedError(self.update_revisions)
 
384
 
 
385
    def revision_id_to_revno(self, revision_id):
 
386
        """Given a revision id, return its revno"""
 
387
        if revision_id is None:
 
388
            return 0
 
389
        revision_id = osutils.safe_revision_id(revision_id)
 
390
        history = self.revision_history()
 
391
        try:
 
392
            return history.index(revision_id) + 1
 
393
        except ValueError:
 
394
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
 
395
 
 
396
    def get_rev_id(self, revno, history=None):
 
397
        """Find the revision id of the specified revno."""
 
398
        if revno == 0:
 
399
            return None
 
400
        if history is None:
 
401
            history = self.revision_history()
 
402
        if revno <= 0 or revno > len(history):
 
403
            raise bzrlib.errors.NoSuchRevision(self, revno)
 
404
        return history[revno - 1]
 
405
 
 
406
    def pull(self, source, overwrite=False, stop_revision=None):
 
407
        """Mirror source into this branch.
 
408
 
 
409
        This branch is considered to be 'local', having low latency.
 
410
 
 
411
        :returns: PullResult instance
 
412
        """
 
413
        raise NotImplementedError(self.pull)
 
414
 
 
415
    def push(self, target, overwrite=False, stop_revision=None):
 
416
        """Mirror this branch into target.
 
417
 
 
418
        This branch is considered to be 'local', having low latency.
 
419
        """
 
420
        raise NotImplementedError(self.push)
1036
421
 
1037
422
    def basis_tree(self):
1038
 
        """Return `Tree` object for last revision.
1039
 
 
1040
 
        If there are no revisions yet, return an `EmptyTree`.
1041
 
        """
1042
 
        from bzrlib.tree import EmptyTree, RevisionTree
1043
 
        r = self.last_patch()
1044
 
        if r == None:
1045
 
            return EmptyTree(self.get_root_id())
1046
 
        else:
1047
 
            return RevisionTree(self.text_store, self.get_revision_inventory(r))
1048
 
 
1049
 
 
 
423
        """Return `Tree` object for last revision."""
 
424
        return self.repository.revision_tree(self.last_revision())
1050
425
 
1051
426
    def rename_one(self, from_rel, to_rel):
1052
427
        """Rename one file.
1053
428
 
1054
429
        This can change the directory or the filename or both.
1055
430
        """
1056
 
        self.lock_write()
1057
 
        try:
1058
 
            tree = self.working_tree()
1059
 
            inv = tree.inventory
1060
 
            if not tree.has_filename(from_rel):
1061
 
                raise BzrError("can't rename: old working file %r does not exist" % from_rel)
1062
 
            if tree.has_filename(to_rel):
1063
 
                raise BzrError("can't rename: new working file %r already exists" % to_rel)
1064
 
 
1065
 
            file_id = inv.path2id(from_rel)
1066
 
            if file_id == None:
1067
 
                raise BzrError("can't rename: old name %r is not versioned" % from_rel)
1068
 
 
1069
 
            if inv.path2id(to_rel):
1070
 
                raise BzrError("can't rename: new name %r is already versioned" % to_rel)
1071
 
 
1072
 
            to_dir, to_tail = os.path.split(to_rel)
1073
 
            to_dir_id = inv.path2id(to_dir)
1074
 
            if to_dir_id == None and to_dir != '':
1075
 
                raise BzrError("can't determine destination directory id for %r" % to_dir)
1076
 
 
1077
 
            mutter("rename_one:")
1078
 
            mutter("  file_id    {%s}" % file_id)
1079
 
            mutter("  from_rel   %r" % from_rel)
1080
 
            mutter("  to_rel     %r" % to_rel)
1081
 
            mutter("  to_dir     %r" % to_dir)
1082
 
            mutter("  to_dir_id  {%s}" % to_dir_id)
1083
 
 
1084
 
            inv.rename(file_id, to_dir_id, to_tail)
1085
 
 
1086
 
            print "%s => %s" % (from_rel, to_rel)
1087
 
 
1088
 
            from_abs = self.abspath(from_rel)
1089
 
            to_abs = self.abspath(to_rel)
1090
 
            try:
1091
 
                os.rename(from_abs, to_abs)
1092
 
            except OSError, e:
1093
 
                raise BzrError("failed to rename %r to %r: %s"
1094
 
                        % (from_abs, to_abs, e[1]),
1095
 
                        ["rename rolled back"])
1096
 
 
1097
 
            self._write_inventory(inv)
1098
 
        finally:
1099
 
            self.unlock()
1100
 
 
 
431
        raise NotImplementedError(self.rename_one)
1101
432
 
1102
433
    def move(self, from_paths, to_name):
1103
434
        """Rename files.
1109
440
 
1110
441
        Note that to_name is only the last component of the new name;
1111
442
        this doesn't change the directory.
1112
 
        """
1113
 
        self.lock_write()
1114
 
        try:
1115
 
            ## TODO: Option to move IDs only
1116
 
            assert not isinstance(from_paths, basestring)
1117
 
            tree = self.working_tree()
1118
 
            inv = tree.inventory
1119
 
            to_abs = self.abspath(to_name)
1120
 
            if not isdir(to_abs):
1121
 
                raise BzrError("destination %r is not a directory" % to_abs)
1122
 
            if not tree.has_filename(to_name):
1123
 
                raise BzrError("destination %r not in working directory" % to_abs)
1124
 
            to_dir_id = inv.path2id(to_name)
1125
 
            if to_dir_id == None and to_name != '':
1126
 
                raise BzrError("destination %r is not a versioned directory" % to_name)
1127
 
            to_dir_ie = inv[to_dir_id]
1128
 
            if to_dir_ie.kind not in ('directory', 'root_directory'):
1129
 
                raise BzrError("destination %r is not a directory" % to_abs)
1130
 
 
1131
 
            to_idpath = inv.get_idpath(to_dir_id)
1132
 
 
1133
 
            for f in from_paths:
1134
 
                if not tree.has_filename(f):
1135
 
                    raise BzrError("%r does not exist in working tree" % f)
1136
 
                f_id = inv.path2id(f)
1137
 
                if f_id == None:
1138
 
                    raise BzrError("%r is not versioned" % f)
1139
 
                name_tail = splitpath(f)[-1]
1140
 
                dest_path = appendpath(to_name, name_tail)
1141
 
                if tree.has_filename(dest_path):
1142
 
                    raise BzrError("destination %r already exists" % dest_path)
1143
 
                if f_id in to_idpath:
1144
 
                    raise BzrError("can't move %r to a subdirectory of itself" % f)
1145
 
 
1146
 
            # OK, so there's a race here, it's possible that someone will
1147
 
            # create a file in this interval and then the rename might be
1148
 
            # left half-done.  But we should have caught most problems.
1149
 
 
1150
 
            for f in from_paths:
1151
 
                name_tail = splitpath(f)[-1]
1152
 
                dest_path = appendpath(to_name, name_tail)
1153
 
                print "%s => %s" % (f, dest_path)
1154
 
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
1155
 
                try:
1156
 
                    os.rename(self.abspath(f), self.abspath(dest_path))
1157
 
                except OSError, e:
1158
 
                    raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1159
 
                            ["rename rolled back"])
1160
 
 
1161
 
            self._write_inventory(inv)
1162
 
        finally:
1163
 
            self.unlock()
1164
 
 
1165
 
 
1166
 
    def revert(self, filenames, old_tree=None, backups=True):
1167
 
        """Restore selected files to the versions from a previous tree.
1168
 
 
1169
 
        backups
1170
 
            If true (default) backups are made of files before
1171
 
            they're renamed.
1172
 
        """
1173
 
        from bzrlib.errors import NotVersionedError, BzrError
1174
 
        from bzrlib.atomicfile import AtomicFile
1175
 
        from bzrlib.osutils import backup_file
1176
 
        
1177
 
        inv = self.read_working_inventory()
1178
 
        if old_tree is None:
1179
 
            old_tree = self.basis_tree()
1180
 
        old_inv = old_tree.inventory
1181
 
 
1182
 
        nids = []
1183
 
        for fn in filenames:
1184
 
            file_id = inv.path2id(fn)
1185
 
            if not file_id:
1186
 
                raise NotVersionedError("not a versioned file", fn)
1187
 
            if not old_inv.has_id(file_id):
1188
 
                raise BzrError("file not present in old tree", fn, file_id)
1189
 
            nids.append((fn, file_id))
1190
 
            
1191
 
        # TODO: Rename back if it was previously at a different location
1192
 
 
1193
 
        # TODO: If given a directory, restore the entire contents from
1194
 
        # the previous version.
1195
 
 
1196
 
        # TODO: Make a backup to a temporary file.
1197
 
 
1198
 
        # TODO: If the file previously didn't exist, delete it?
1199
 
        for fn, file_id in nids:
1200
 
            backup_file(fn)
1201
 
            
1202
 
            f = AtomicFile(fn, 'wb')
1203
 
            try:
1204
 
                f.write(old_tree.get_file(file_id).read())
1205
 
                f.commit()
1206
 
            finally:
1207
 
                f.close()
1208
 
 
1209
 
 
1210
 
    def pending_merges(self):
1211
 
        """Return a list of pending merges.
1212
 
 
1213
 
        These are revisions that have been merged into the working
1214
 
        directory but not yet committed.
1215
 
        """
1216
 
        cfn = self.controlfilename('pending-merges')
1217
 
        if not os.path.exists(cfn):
1218
 
            return []
1219
 
        p = []
1220
 
        for l in self.controlfile('pending-merges', 'r').readlines():
1221
 
            p.append(l.rstrip('\n'))
1222
 
        return p
1223
 
 
1224
 
 
1225
 
    def add_pending_merge(self, revision_id):
1226
 
        from bzrlib.revision import validate_revision_id
1227
 
 
1228
 
        validate_revision_id(revision_id)
1229
 
 
1230
 
        p = self.pending_merges()
1231
 
        if revision_id in p:
1232
 
            return
1233
 
        p.append(revision_id)
1234
 
        self.set_pending_merges(p)
1235
 
 
1236
 
 
1237
 
    def set_pending_merges(self, rev_list):
1238
 
        from bzrlib.atomicfile import AtomicFile
1239
 
        self.lock_write()
1240
 
        try:
1241
 
            f = AtomicFile(self.controlfilename('pending-merges'))
1242
 
            try:
1243
 
                for l in rev_list:
1244
 
                    print >>f, l
1245
 
                f.commit()
1246
 
            finally:
1247
 
                f.close()
1248
 
        finally:
1249
 
            self.unlock()
1250
 
 
1251
 
 
1252
 
 
1253
 
class ScratchBranch(Branch):
1254
 
    """Special test class: a branch that cleans up after itself.
1255
 
 
1256
 
    >>> b = ScratchBranch()
1257
 
    >>> isdir(b.base)
1258
 
    True
1259
 
    >>> bd = b.base
1260
 
    >>> b.destroy()
1261
 
    >>> isdir(bd)
1262
 
    False
1263
 
    """
1264
 
    def __init__(self, files=[], dirs=[], base=None):
1265
 
        """Make a test branch.
1266
 
 
1267
 
        This creates a temporary directory and runs init-tree in it.
1268
 
 
1269
 
        If any files are listed, they are created in the working copy.
1270
 
        """
1271
 
        from tempfile import mkdtemp
1272
 
        init = False
1273
 
        if base is None:
1274
 
            base = mkdtemp()
1275
 
            init = True
1276
 
        Branch.__init__(self, base, init=init)
1277
 
        for d in dirs:
1278
 
            os.mkdir(self.abspath(d))
1279
 
            
1280
 
        for f in files:
1281
 
            file(os.path.join(self.base, f), 'w').write('content of %s' % f)
1282
 
 
1283
 
 
1284
 
    def clone(self):
1285
 
        """
1286
 
        >>> orig = ScratchBranch(files=["file1", "file2"])
1287
 
        >>> clone = orig.clone()
1288
 
        >>> os.path.samefile(orig.base, clone.base)
1289
 
        False
1290
 
        >>> os.path.isfile(os.path.join(clone.base, "file1"))
1291
 
        True
1292
 
        """
1293
 
        from shutil import copytree
1294
 
        from tempfile import mkdtemp
1295
 
        base = mkdtemp()
1296
 
        os.rmdir(base)
1297
 
        copytree(self.base, base, symlinks=True)
1298
 
        return ScratchBranch(base=base)
1299
 
        
1300
 
    def __del__(self):
1301
 
        self.destroy()
1302
 
 
1303
 
    def destroy(self):
1304
 
        """Destroy the test branch, removing the scratch directory."""
1305
 
        from shutil import rmtree
1306
 
        try:
1307
 
            if self.base:
1308
 
                mutter("delete ScratchBranch %s" % self.base)
1309
 
                rmtree(self.base)
1310
 
        except OSError, e:
1311
 
            # Work around for shutil.rmtree failing on Windows when
1312
 
            # readonly files are encountered
1313
 
            mutter("hit exception in destroying ScratchBranch: %s" % e)
1314
 
            for root, dirs, files in os.walk(self.base, topdown=False):
1315
 
                for name in files:
1316
 
                    os.chmod(os.path.join(root, name), 0700)
1317
 
            rmtree(self.base)
1318
 
        self.base = None
1319
 
 
1320
 
    
1321
 
 
1322
 
######################################################################
1323
 
# predicates
1324
 
 
1325
 
 
1326
 
def is_control_file(filename):
1327
 
    ## FIXME: better check
1328
 
    filename = os.path.normpath(filename)
1329
 
    while filename != '':
1330
 
        head, tail = os.path.split(filename)
1331
 
        ## mutter('check %r for control file' % ((head, tail), ))
1332
 
        if tail == bzrlib.BZRDIR:
 
443
 
 
444
        This returns a list of (from_path, to_path) pairs for each
 
445
        entry that is moved.
 
446
        """
 
447
        raise NotImplementedError(self.move)
 
448
 
 
449
    def get_parent(self):
 
450
        """Return the parent location of the branch.
 
451
 
 
452
        This is the default location for push/pull/missing.  The usual
 
453
        pattern is that the user can override it by specifying a
 
454
        location.
 
455
        """
 
456
        raise NotImplementedError(self.get_parent)
 
457
 
 
458
    def _set_config_location(self, name, url, config=None,
 
459
                             make_relative=False):
 
460
        if config is None:
 
461
            config = self.get_config()
 
462
        if url is None:
 
463
            url = ''
 
464
        elif make_relative:
 
465
            url = urlutils.relative_url(self.base, url)
 
466
        config.set_user_option(name, url)
 
467
 
 
468
    def _get_config_location(self, name, config=None):
 
469
        if config is None:
 
470
            config = self.get_config()
 
471
        location = config.get_user_option(name)
 
472
        if location == '':
 
473
            location = None
 
474
        return location
 
475
 
 
476
    def get_submit_branch(self):
 
477
        """Return the submit location of the branch.
 
478
 
 
479
        This is the default location for bundle.  The usual
 
480
        pattern is that the user can override it by specifying a
 
481
        location.
 
482
        """
 
483
        return self.get_config().get_user_option('submit_branch')
 
484
 
 
485
    def set_submit_branch(self, location):
 
486
        """Return the submit location of the branch.
 
487
 
 
488
        This is the default location for bundle.  The usual
 
489
        pattern is that the user can override it by specifying a
 
490
        location.
 
491
        """
 
492
        self.get_config().set_user_option('submit_branch', location)
 
493
 
 
494
    def get_public_branch(self):
 
495
        """Return the public location of the branch.
 
496
 
 
497
        This is is used by merge directives.
 
498
        """
 
499
        return self._get_config_location('public_branch')
 
500
 
 
501
    def set_public_branch(self, location):
 
502
        """Return the submit location of the branch.
 
503
 
 
504
        This is the default location for bundle.  The usual
 
505
        pattern is that the user can override it by specifying a
 
506
        location.
 
507
        """
 
508
        self._set_config_location('public_branch', location)
 
509
 
 
510
    def get_push_location(self):
 
511
        """Return the None or the location to push this branch to."""
 
512
        raise NotImplementedError(self.get_push_location)
 
513
 
 
514
    def set_push_location(self, location):
 
515
        """Set a new push location for this branch."""
 
516
        raise NotImplementedError(self.set_push_location)
 
517
 
 
518
    def set_parent(self, url):
 
519
        raise NotImplementedError(self.set_parent)
 
520
 
 
521
    @needs_write_lock
 
522
    def update(self):
 
523
        """Synchronise this branch with the master branch if any. 
 
524
 
 
525
        :return: None or the last_revision pivoted out during the update.
 
526
        """
 
527
        return None
 
528
 
 
529
    def check_revno(self, revno):
 
530
        """\
 
531
        Check whether a revno corresponds to any revision.
 
532
        Zero (the NULL revision) is considered valid.
 
533
        """
 
534
        if revno != 0:
 
535
            self.check_real_revno(revno)
 
536
            
 
537
    def check_real_revno(self, revno):
 
538
        """\
 
539
        Check whether a revno corresponds to a real revision.
 
540
        Zero (the NULL revision) is considered invalid
 
541
        """
 
542
        if revno < 1 or revno > self.revno():
 
543
            raise InvalidRevisionNumber(revno)
 
544
 
 
545
    @needs_read_lock
 
546
    def clone(self, *args, **kwargs):
 
547
        """Clone this branch into to_bzrdir preserving all semantic values.
 
548
        
 
549
        revision_id: if not None, the revision history in the new branch will
 
550
                     be truncated to end with revision_id.
 
551
        """
 
552
        # for API compatibility, until 0.8 releases we provide the old api:
 
553
        # def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
 
554
        # after 0.8 releases, the *args and **kwargs should be changed:
 
555
        # def clone(self, to_bzrdir, revision_id=None):
 
556
        if (kwargs.get('to_location', None) or
 
557
            kwargs.get('revision', None) or
 
558
            kwargs.get('basis_branch', None) or
 
559
            (len(args) and isinstance(args[0], basestring))):
 
560
            # backwards compatibility api:
 
561
            warn("Branch.clone() has been deprecated for BzrDir.clone() from"
 
562
                 " bzrlib 0.8.", DeprecationWarning, stacklevel=3)
 
563
            # get basis_branch
 
564
            if len(args) > 2:
 
565
                basis_branch = args[2]
 
566
            else:
 
567
                basis_branch = kwargs.get('basis_branch', None)
 
568
            if basis_branch:
 
569
                basis = basis_branch.bzrdir
 
570
            else:
 
571
                basis = None
 
572
            # get revision
 
573
            if len(args) > 1:
 
574
                revision_id = args[1]
 
575
            else:
 
576
                revision_id = kwargs.get('revision', None)
 
577
            # get location
 
578
            if len(args):
 
579
                url = args[0]
 
580
            else:
 
581
                # no default to raise if not provided.
 
582
                url = kwargs.get('to_location')
 
583
            return self.bzrdir.clone(url,
 
584
                                     revision_id=revision_id,
 
585
                                     basis=basis).open_branch()
 
586
        # new cleaner api.
 
587
        # generate args by hand 
 
588
        if len(args) > 1:
 
589
            revision_id = args[1]
 
590
        else:
 
591
            revision_id = kwargs.get('revision_id', None)
 
592
        if len(args):
 
593
            to_bzrdir = args[0]
 
594
        else:
 
595
            # no default to raise if not provided.
 
596
            to_bzrdir = kwargs.get('to_bzrdir')
 
597
        result = self._format.initialize(to_bzrdir)
 
598
        self.copy_content_into(result, revision_id=revision_id)
 
599
        return  result
 
600
 
 
601
    @needs_read_lock
 
602
    def sprout(self, to_bzrdir, revision_id=None):
 
603
        """Create a new line of development from the branch, into to_bzrdir.
 
604
        
 
605
        revision_id: if not None, the revision history in the new branch will
 
606
                     be truncated to end with revision_id.
 
607
        """
 
608
        result = self._format.initialize(to_bzrdir)
 
609
        self.copy_content_into(result, revision_id=revision_id)
 
610
        result.set_parent(self.bzrdir.root_transport.base)
 
611
        return result
 
612
 
 
613
    def _synchronize_history(self, destination, revision_id):
 
614
        """Synchronize last revision and revision history between branches.
 
615
 
 
616
        This version is most efficient when the destination is also a
 
617
        BzrBranch5, but works for BzrBranch6 as long as the revision
 
618
        history is the true lefthand parent history, and all of the revisions
 
619
        are in the destination's repository.  If not, set_revision_history
 
620
        will fail.
 
621
 
 
622
        :param destination: The branch to copy the history into
 
623
        :param revision_id: The revision-id to truncate history at.  May
 
624
          be None to copy complete history.
 
625
        """
 
626
        new_history = self.revision_history()
 
627
        if revision_id is not None:
 
628
            revision_id = osutils.safe_revision_id(revision_id)
 
629
            try:
 
630
                new_history = new_history[:new_history.index(revision_id) + 1]
 
631
            except ValueError:
 
632
                rev = self.repository.get_revision(revision_id)
 
633
                new_history = rev.get_history(self.repository)[1:]
 
634
        destination.set_revision_history(new_history)
 
635
 
 
636
    @needs_read_lock
 
637
    def copy_content_into(self, destination, revision_id=None):
 
638
        """Copy the content of self into destination.
 
639
 
 
640
        revision_id: if not None, the revision history in the new branch will
 
641
                     be truncated to end with revision_id.
 
642
        """
 
643
        self._synchronize_history(destination, revision_id)
 
644
        try:
 
645
            parent = self.get_parent()
 
646
        except errors.InaccessibleParent, e:
 
647
            mutter('parent was not accessible to copy: %s', e)
 
648
        else:
 
649
            if parent:
 
650
                destination.set_parent(parent)
 
651
 
 
652
    @needs_read_lock
 
653
    def check(self):
 
654
        """Check consistency of the branch.
 
655
 
 
656
        In particular this checks that revisions given in the revision-history
 
657
        do actually match up in the revision graph, and that they're all 
 
658
        present in the repository.
 
659
        
 
660
        Callers will typically also want to check the repository.
 
661
 
 
662
        :return: A BranchCheckResult.
 
663
        """
 
664
        mainline_parent_id = None
 
665
        for revision_id in self.revision_history():
 
666
            try:
 
667
                revision = self.repository.get_revision(revision_id)
 
668
            except errors.NoSuchRevision, e:
 
669
                raise errors.BzrCheckError("mainline revision {%s} not in repository"
 
670
                            % revision_id)
 
671
            # In general the first entry on the revision history has no parents.
 
672
            # But it's not illegal for it to have parents listed; this can happen
 
673
            # in imports from Arch when the parents weren't reachable.
 
674
            if mainline_parent_id is not None:
 
675
                if mainline_parent_id not in revision.parent_ids:
 
676
                    raise errors.BzrCheckError("previous revision {%s} not listed among "
 
677
                                        "parents of {%s}"
 
678
                                        % (mainline_parent_id, revision_id))
 
679
            mainline_parent_id = revision_id
 
680
        return BranchCheckResult(self)
 
681
 
 
682
    def _get_checkout_format(self):
 
683
        """Return the most suitable metadir for a checkout of this branch.
 
684
        Weaves are used if this branch's repostory uses weaves.
 
685
        """
 
686
        if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
 
687
            from bzrlib.repofmt import weaverepo
 
688
            format = bzrdir.BzrDirMetaFormat1()
 
689
            format.repository_format = weaverepo.RepositoryFormat7()
 
690
        else:
 
691
            format = self.repository.bzrdir.checkout_metadir()
 
692
            format.branch_format = self._format
 
693
        return format
 
694
 
 
695
    def create_checkout(self, to_location, revision_id=None,
 
696
                        lightweight=False):
 
697
        """Create a checkout of a branch.
 
698
        
 
699
        :param to_location: The url to produce the checkout at
 
700
        :param revision_id: The revision to check out
 
701
        :param lightweight: If True, produce a lightweight checkout, otherwise,
 
702
        produce a bound branch (heavyweight checkout)
 
703
        :return: The tree of the created checkout
 
704
        """
 
705
        t = transport.get_transport(to_location)
 
706
        try:
 
707
            t.mkdir('.')
 
708
        except errors.FileExists:
 
709
            pass
 
710
        if lightweight:
 
711
            format = self._get_checkout_format()
 
712
            checkout = format.initialize_on_transport(t)
 
713
            BranchReferenceFormat().initialize(checkout, self)
 
714
        else:
 
715
            format = self._get_checkout_format()
 
716
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
 
717
                to_location, force_new_tree=False, format=format)
 
718
            checkout = checkout_branch.bzrdir
 
719
            checkout_branch.bind(self)
 
720
            # pull up to the specified revision_id to set the initial 
 
721
            # branch tip correctly, and seed it with history.
 
722
            checkout_branch.pull(self, stop_revision=revision_id)
 
723
        tree = checkout.create_workingtree(revision_id)
 
724
        basis_tree = tree.basis_tree()
 
725
        basis_tree.lock_read()
 
726
        try:
 
727
            for path, file_id in basis_tree.iter_references():
 
728
                reference_parent = self.reference_parent(file_id, path)
 
729
                reference_parent.create_checkout(tree.abspath(path),
 
730
                    basis_tree.get_reference_revision(file_id, path),
 
731
                    lightweight)
 
732
        finally:
 
733
            basis_tree.unlock()
 
734
        return tree
 
735
 
 
736
    def reference_parent(self, file_id, path):
 
737
        """Return the parent branch for a tree-reference file_id
 
738
        :param file_id: The file_id of the tree reference
 
739
        :param path: The path of the file_id in the tree
 
740
        :return: A branch associated with the file_id
 
741
        """
 
742
        # FIXME should provide multiple branches, based on config
 
743
        return Branch.open(self.bzrdir.root_transport.clone(path).base)
 
744
 
 
745
    def supports_tags(self):
 
746
        return self._format.supports_tags()
 
747
 
 
748
 
 
749
class BranchFormat(object):
 
750
    """An encapsulation of the initialization and open routines for a format.
 
751
 
 
752
    Formats provide three things:
 
753
     * An initialization routine,
 
754
     * a format string,
 
755
     * an open routine.
 
756
 
 
757
    Formats are placed in an dict by their format string for reference 
 
758
    during branch opening. Its not required that these be instances, they
 
759
    can be classes themselves with class methods - it simply depends on 
 
760
    whether state is needed for a given format or not.
 
761
 
 
762
    Once a format is deprecated, just deprecate the initialize and open
 
763
    methods on the format class. Do not deprecate the object, as the 
 
764
    object will be created every time regardless.
 
765
    """
 
766
 
 
767
    _default_format = None
 
768
    """The default format used for new branches."""
 
769
 
 
770
    _formats = {}
 
771
    """The known formats."""
 
772
 
 
773
    @classmethod
 
774
    def find_format(klass, a_bzrdir):
 
775
        """Return the format for the branch object in a_bzrdir."""
 
776
        try:
 
777
            transport = a_bzrdir.get_branch_transport(None)
 
778
            format_string = transport.get("format").read()
 
779
            return klass._formats[format_string]
 
780
        except NoSuchFile:
 
781
            raise NotBranchError(path=transport.base)
 
782
        except KeyError:
 
783
            raise errors.UnknownFormatError(format=format_string)
 
784
 
 
785
    @classmethod
 
786
    def get_default_format(klass):
 
787
        """Return the current default format."""
 
788
        return klass._default_format
 
789
 
 
790
    def get_format_string(self):
 
791
        """Return the ASCII format string that identifies this format."""
 
792
        raise NotImplementedError(self.get_format_string)
 
793
 
 
794
    def get_format_description(self):
 
795
        """Return the short format description for this format."""
 
796
        raise NotImplementedError(self.get_format_description)
 
797
 
 
798
    def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
 
799
                           set_format=True):
 
800
        """Initialize a branch in a bzrdir, with specified files
 
801
 
 
802
        :param a_bzrdir: The bzrdir to initialize the branch in
 
803
        :param utf8_files: The files to create as a list of
 
804
            (filename, content) tuples
 
805
        :param set_format: If True, set the format with
 
806
            self.get_format_string.  (BzrBranch4 has its format set
 
807
            elsewhere)
 
808
        :return: a branch in this format
 
809
        """
 
810
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
 
811
        branch_transport = a_bzrdir.get_branch_transport(self)
 
812
        lock_map = {
 
813
            'metadir': ('lock', lockdir.LockDir),
 
814
            'branch4': ('branch-lock', lockable_files.TransportLock),
 
815
        }
 
816
        lock_name, lock_class = lock_map[lock_type]
 
817
        control_files = lockable_files.LockableFiles(branch_transport,
 
818
            lock_name, lock_class)
 
819
        control_files.create_lock()
 
820
        control_files.lock_write()
 
821
        if set_format:
 
822
            control_files.put_utf8('format', self.get_format_string())
 
823
        try:
 
824
            for file, content in utf8_files:
 
825
                control_files.put_utf8(file, content)
 
826
        finally:
 
827
            control_files.unlock()
 
828
        return self.open(a_bzrdir, _found=True)
 
829
 
 
830
    def initialize(self, a_bzrdir):
 
831
        """Create a branch of this format in a_bzrdir."""
 
832
        raise NotImplementedError(self.initialize)
 
833
 
 
834
    def is_supported(self):
 
835
        """Is this format supported?
 
836
 
 
837
        Supported formats can be initialized and opened.
 
838
        Unsupported formats may not support initialization or committing or 
 
839
        some other features depending on the reason for not being supported.
 
840
        """
 
841
        return True
 
842
 
 
843
    def open(self, a_bzrdir, _found=False):
 
844
        """Return the branch object for a_bzrdir
 
845
 
 
846
        _found is a private parameter, do not use it. It is used to indicate
 
847
               if format probing has already be done.
 
848
        """
 
849
        raise NotImplementedError(self.open)
 
850
 
 
851
    @classmethod
 
852
    def register_format(klass, format):
 
853
        klass._formats[format.get_format_string()] = format
 
854
 
 
855
    @classmethod
 
856
    def set_default_format(klass, format):
 
857
        klass._default_format = format
 
858
 
 
859
    @classmethod
 
860
    def unregister_format(klass, format):
 
861
        assert klass._formats[format.get_format_string()] is format
 
862
        del klass._formats[format.get_format_string()]
 
863
 
 
864
    def __str__(self):
 
865
        return self.get_format_string().rstrip()
 
866
 
 
867
    def supports_tags(self):
 
868
        """True if this format supports tags stored in the branch"""
 
869
        return False  # by default
 
870
 
 
871
    # XXX: Probably doesn't really belong here -- mbp 20070212
 
872
    def _initialize_control_files(self, a_bzrdir, utf8_files, lock_filename,
 
873
            lock_class):
 
874
        branch_transport = a_bzrdir.get_branch_transport(self)
 
875
        control_files = lockable_files.LockableFiles(branch_transport,
 
876
            lock_filename, lock_class)
 
877
        control_files.create_lock()
 
878
        control_files.lock_write()
 
879
        try:
 
880
            for filename, content in utf8_files:
 
881
                control_files.put_utf8(filename, content)
 
882
        finally:
 
883
            control_files.unlock()
 
884
 
 
885
 
 
886
class BranchHooks(dict):
 
887
    """A dictionary mapping hook name to a list of callables for branch hooks.
 
888
    
 
889
    e.g. ['set_rh'] Is the list of items to be called when the
 
890
    set_revision_history function is invoked.
 
891
    """
 
892
 
 
893
    def __init__(self):
 
894
        """Create the default hooks.
 
895
 
 
896
        These are all empty initially, because by default nothing should get
 
897
        notified.
 
898
        """
 
899
        dict.__init__(self)
 
900
        # Introduced in 0.15:
 
901
        # invoked whenever the revision history has been set
 
902
        # with set_revision_history. The api signature is
 
903
        # (branch, revision_history), and the branch will
 
904
        # be write-locked.
 
905
        self['set_rh'] = []
 
906
        # invoked after a push operation completes.
 
907
        # the api signature is
 
908
        # (push_result)
 
909
        # containing the members
 
910
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
 
911
        # where local is the local branch or None, master is the target 
 
912
        # master branch, and the rest should be self explanatory. The source
 
913
        # is read locked and the target branches write locked. Source will
 
914
        # be the local low-latency branch.
 
915
        self['post_push'] = []
 
916
        # invoked after a pull operation completes.
 
917
        # the api signature is
 
918
        # (pull_result)
 
919
        # containing the members
 
920
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
 
921
        # where local is the local branch or None, master is the target 
 
922
        # master branch, and the rest should be self explanatory. The source
 
923
        # is read locked and the target branches write locked. The local
 
924
        # branch is the low-latency branch.
 
925
        self['post_pull'] = []
 
926
        # invoked after a commit operation completes.
 
927
        # the api signature is 
 
928
        # (local, master, old_revno, old_revid, new_revno, new_revid)
 
929
        # old_revid is NULL_REVISION for the first commit to a branch.
 
930
        self['post_commit'] = []
 
931
        # invoked after a uncommit operation completes.
 
932
        # the api signature is
 
933
        # (local, master, old_revno, old_revid, new_revno, new_revid) where
 
934
        # local is the local branch or None, master is the target branch,
 
935
        # and an empty branch recieves new_revno of 0, new_revid of None.
 
936
        self['post_uncommit'] = []
 
937
 
 
938
    def install_hook(self, hook_name, a_callable):
 
939
        """Install a_callable in to the hook hook_name.
 
940
 
 
941
        :param hook_name: A hook name. See the __init__ method of BranchHooks
 
942
            for the complete list of hooks.
 
943
        :param a_callable: The callable to be invoked when the hook triggers.
 
944
            The exact signature will depend on the hook - see the __init__ 
 
945
            method of BranchHooks for details on each hook.
 
946
        """
 
947
        try:
 
948
            self[hook_name].append(a_callable)
 
949
        except KeyError:
 
950
            raise errors.UnknownHook('branch', hook_name)
 
951
 
 
952
 
 
953
# install the default hooks into the Branch class.
 
954
Branch.hooks = BranchHooks()
 
955
 
 
956
 
 
957
class BzrBranchFormat4(BranchFormat):
 
958
    """Bzr branch format 4.
 
959
 
 
960
    This format has:
 
961
     - a revision-history file.
 
962
     - a branch-lock lock file [ to be shared with the bzrdir ]
 
963
    """
 
964
 
 
965
    def get_format_description(self):
 
966
        """See BranchFormat.get_format_description()."""
 
967
        return "Branch format 4"
 
968
 
 
969
    def initialize(self, a_bzrdir):
 
970
        """Create a branch of this format in a_bzrdir."""
 
971
        utf8_files = [('revision-history', ''),
 
972
                      ('branch-name', ''),
 
973
                      ]
 
974
        return self._initialize_helper(a_bzrdir, utf8_files,
 
975
                                       lock_type='branch4', set_format=False)
 
976
 
 
977
    def __init__(self):
 
978
        super(BzrBranchFormat4, self).__init__()
 
979
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
 
980
 
 
981
    def open(self, a_bzrdir, _found=False):
 
982
        """Return the branch object for a_bzrdir
 
983
 
 
984
        _found is a private parameter, do not use it. It is used to indicate
 
985
               if format probing has already be done.
 
986
        """
 
987
        if not _found:
 
988
            # we are being called directly and must probe.
 
989
            raise NotImplementedError
 
990
        return BzrBranch(_format=self,
 
991
                         _control_files=a_bzrdir._control_files,
 
992
                         a_bzrdir=a_bzrdir,
 
993
                         _repository=a_bzrdir.open_repository())
 
994
 
 
995
    def __str__(self):
 
996
        return "Bazaar-NG branch format 4"
 
997
 
 
998
 
 
999
class BzrBranchFormat5(BranchFormat):
 
1000
    """Bzr branch format 5.
 
1001
 
 
1002
    This format has:
 
1003
     - a revision-history file.
 
1004
     - a format string
 
1005
     - a lock dir guarding the branch itself
 
1006
     - all of this stored in a branch/ subdirectory
 
1007
     - works with shared repositories.
 
1008
 
 
1009
    This format is new in bzr 0.8.
 
1010
    """
 
1011
 
 
1012
    def get_format_string(self):
 
1013
        """See BranchFormat.get_format_string()."""
 
1014
        return "Bazaar-NG branch format 5\n"
 
1015
 
 
1016
    def get_format_description(self):
 
1017
        """See BranchFormat.get_format_description()."""
 
1018
        return "Branch format 5"
 
1019
        
 
1020
    def initialize(self, a_bzrdir):
 
1021
        """Create a branch of this format in a_bzrdir."""
 
1022
        utf8_files = [('revision-history', ''),
 
1023
                      ('branch-name', ''),
 
1024
                      ]
 
1025
        return self._initialize_helper(a_bzrdir, utf8_files)
 
1026
 
 
1027
    def __init__(self):
 
1028
        super(BzrBranchFormat5, self).__init__()
 
1029
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
1030
 
 
1031
    def open(self, a_bzrdir, _found=False):
 
1032
        """Return the branch object for a_bzrdir
 
1033
 
 
1034
        _found is a private parameter, do not use it. It is used to indicate
 
1035
               if format probing has already be done.
 
1036
        """
 
1037
        if not _found:
 
1038
            format = BranchFormat.find_format(a_bzrdir)
 
1039
            assert format.__class__ == self.__class__
 
1040
        transport = a_bzrdir.get_branch_transport(None)
 
1041
        control_files = lockable_files.LockableFiles(transport, 'lock',
 
1042
                                                     lockdir.LockDir)
 
1043
        return BzrBranch5(_format=self,
 
1044
                          _control_files=control_files,
 
1045
                          a_bzrdir=a_bzrdir,
 
1046
                          _repository=a_bzrdir.find_repository())
 
1047
 
 
1048
 
 
1049
class BzrBranchFormat6(BzrBranchFormat5):
 
1050
    """Branch format with last-revision
 
1051
 
 
1052
    Unlike previous formats, this has no explicit revision history. Instead,
 
1053
    this just stores the last-revision, and the left-hand history leading
 
1054
    up to there is the history.
 
1055
 
 
1056
    This format was introduced in bzr 0.15
 
1057
    """
 
1058
 
 
1059
    def get_format_string(self):
 
1060
        """See BranchFormat.get_format_string()."""
 
1061
        return "Bazaar Branch Format 6 (bzr 0.15)\n"
 
1062
 
 
1063
    def get_format_description(self):
 
1064
        """See BranchFormat.get_format_description()."""
 
1065
        return "Branch format 6"
 
1066
 
 
1067
    def initialize(self, a_bzrdir):
 
1068
        """Create a branch of this format in a_bzrdir."""
 
1069
        utf8_files = [('last-revision', '0 null:\n'),
 
1070
                      ('branch-name', ''),
 
1071
                      ('branch.conf', ''),
 
1072
                      ('tags', ''),
 
1073
                      ]
 
1074
        return self._initialize_helper(a_bzrdir, utf8_files)
 
1075
 
 
1076
    def open(self, a_bzrdir, _found=False):
 
1077
        """Return the branch object for a_bzrdir
 
1078
 
 
1079
        _found is a private parameter, do not use it. It is used to indicate
 
1080
               if format probing has already be done.
 
1081
        """
 
1082
        if not _found:
 
1083
            format = BranchFormat.find_format(a_bzrdir)
 
1084
            assert format.__class__ == self.__class__
 
1085
        transport = a_bzrdir.get_branch_transport(None)
 
1086
        control_files = lockable_files.LockableFiles(transport, 'lock',
 
1087
                                                     lockdir.LockDir)
 
1088
        return BzrBranch6(_format=self,
 
1089
                          _control_files=control_files,
 
1090
                          a_bzrdir=a_bzrdir,
 
1091
                          _repository=a_bzrdir.find_repository())
 
1092
 
 
1093
    def supports_tags(self):
 
1094
        return True
 
1095
 
 
1096
 
 
1097
class BranchReferenceFormat(BranchFormat):
 
1098
    """Bzr branch reference format.
 
1099
 
 
1100
    Branch references are used in implementing checkouts, they
 
1101
    act as an alias to the real branch which is at some other url.
 
1102
 
 
1103
    This format has:
 
1104
     - A location file
 
1105
     - a format string
 
1106
    """
 
1107
 
 
1108
    def get_format_string(self):
 
1109
        """See BranchFormat.get_format_string()."""
 
1110
        return "Bazaar-NG Branch Reference Format 1\n"
 
1111
 
 
1112
    def get_format_description(self):
 
1113
        """See BranchFormat.get_format_description()."""
 
1114
        return "Checkout reference format 1"
 
1115
        
 
1116
    def initialize(self, a_bzrdir, target_branch=None):
 
1117
        """Create a branch of this format in a_bzrdir."""
 
1118
        if target_branch is None:
 
1119
            # this format does not implement branch itself, thus the implicit
 
1120
            # creation contract must see it as uninitializable
 
1121
            raise errors.UninitializableFormat(self)
 
1122
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
 
1123
        branch_transport = a_bzrdir.get_branch_transport(self)
 
1124
        branch_transport.put_bytes('location',
 
1125
            target_branch.bzrdir.root_transport.base)
 
1126
        branch_transport.put_bytes('format', self.get_format_string())
 
1127
        return self.open(a_bzrdir, _found=True)
 
1128
 
 
1129
    def __init__(self):
 
1130
        super(BranchReferenceFormat, self).__init__()
 
1131
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
1132
 
 
1133
    def _make_reference_clone_function(format, a_branch):
 
1134
        """Create a clone() routine for a branch dynamically."""
 
1135
        def clone(to_bzrdir, revision_id=None):
 
1136
            """See Branch.clone()."""
 
1137
            return format.initialize(to_bzrdir, a_branch)
 
1138
            # cannot obey revision_id limits when cloning a reference ...
 
1139
            # FIXME RBC 20060210 either nuke revision_id for clone, or
 
1140
            # emit some sort of warning/error to the caller ?!
 
1141
        return clone
 
1142
 
 
1143
    def open(self, a_bzrdir, _found=False):
 
1144
        """Return the branch that the branch reference in a_bzrdir points at.
 
1145
 
 
1146
        _found is a private parameter, do not use it. It is used to indicate
 
1147
               if format probing has already be done.
 
1148
        """
 
1149
        if not _found:
 
1150
            format = BranchFormat.find_format(a_bzrdir)
 
1151
            assert format.__class__ == self.__class__
 
1152
        transport = a_bzrdir.get_branch_transport(None)
 
1153
        real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
 
1154
        result = real_bzrdir.open_branch()
 
1155
        # this changes the behaviour of result.clone to create a new reference
 
1156
        # rather than a copy of the content of the branch.
 
1157
        # I did not use a proxy object because that needs much more extensive
 
1158
        # testing, and we are only changing one behaviour at the moment.
 
1159
        # If we decide to alter more behaviours - i.e. the implicit nickname
 
1160
        # then this should be refactored to introduce a tested proxy branch
 
1161
        # and a subclass of that for use in overriding clone() and ....
 
1162
        # - RBC 20060210
 
1163
        result.clone = self._make_reference_clone_function(result)
 
1164
        return result
 
1165
 
 
1166
 
 
1167
# formats which have no format string are not discoverable
 
1168
# and not independently creatable, so are not registered.
 
1169
__default_format = BzrBranchFormat5()
 
1170
BranchFormat.register_format(__default_format)
 
1171
BranchFormat.register_format(BranchReferenceFormat())
 
1172
BranchFormat.register_format(BzrBranchFormat6())
 
1173
BranchFormat.set_default_format(__default_format)
 
1174
_legacy_formats = [BzrBranchFormat4(),
 
1175
                   ]
 
1176
 
 
1177
class BzrBranch(Branch):
 
1178
    """A branch stored in the actual filesystem.
 
1179
 
 
1180
    Note that it's "local" in the context of the filesystem; it doesn't
 
1181
    really matter if it's on an nfs/smb/afs/coda/... share, as long as
 
1182
    it's writable, and can be accessed via the normal filesystem API.
 
1183
    """
 
1184
    
 
1185
    def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
 
1186
                 relax_version_check=DEPRECATED_PARAMETER, _format=None,
 
1187
                 _control_files=None, a_bzrdir=None, _repository=None):
 
1188
        """Create new branch object at a particular location.
 
1189
 
 
1190
        transport -- A Transport object, defining how to access files.
 
1191
        
 
1192
        init -- If True, create new control files in a previously
 
1193
             unversioned directory.  If False, the branch must already
 
1194
             be versioned.
 
1195
 
 
1196
        relax_version_check -- If true, the usual check for the branch
 
1197
            version is not applied.  This is intended only for
 
1198
            upgrade/recovery type use; it's not guaranteed that
 
1199
            all operations will work on old format branches.
 
1200
        """
 
1201
        Branch.__init__(self)
 
1202
        if a_bzrdir is None:
 
1203
            self.bzrdir = bzrdir.BzrDir.open(transport.base)
 
1204
        else:
 
1205
            self.bzrdir = a_bzrdir
 
1206
        # self._transport used to point to the directory containing the
 
1207
        # control directory, but was not used - now it's just the transport
 
1208
        # for the branch control files.  mbp 20070212
 
1209
        self._base = self.bzrdir.transport.clone('..').base
 
1210
        self._format = _format
 
1211
        if _control_files is None:
 
1212
            raise ValueError('BzrBranch _control_files is None')
 
1213
        self.control_files = _control_files
 
1214
        self._transport = _control_files._transport
 
1215
        if deprecated_passed(init):
 
1216
            warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
 
1217
                 "deprecated as of bzr 0.8. Please use Branch.create().",
 
1218
                 DeprecationWarning,
 
1219
                 stacklevel=2)
 
1220
            if init:
 
1221
                # this is slower than before deprecation, oh well never mind.
 
1222
                # -> its deprecated.
 
1223
                self._initialize(transport.base)
 
1224
        self._check_format(_format)
 
1225
        if deprecated_passed(relax_version_check):
 
1226
            warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
 
1227
                 "relax_version_check parameter is deprecated as of bzr 0.8. "
 
1228
                 "Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
 
1229
                 "open() method.",
 
1230
                 DeprecationWarning,
 
1231
                 stacklevel=2)
 
1232
            if (not relax_version_check
 
1233
                and not self._format.is_supported()):
 
1234
                raise errors.UnsupportedFormatError(format=fmt)
 
1235
        if deprecated_passed(transport):
 
1236
            warn("BzrBranch.__init__(transport=XXX...): The transport "
 
1237
                 "parameter is deprecated as of bzr 0.8. "
 
1238
                 "Please use Branch.open, or bzrdir.open_branch().",
 
1239
                 DeprecationWarning,
 
1240
                 stacklevel=2)
 
1241
        self.repository = _repository
 
1242
 
 
1243
    def __str__(self):
 
1244
        return '%s(%r)' % (self.__class__.__name__, self.base)
 
1245
 
 
1246
    __repr__ = __str__
 
1247
 
 
1248
    def _get_base(self):
 
1249
        """Returns the directory containing the control directory."""
 
1250
        return self._base
 
1251
 
 
1252
    base = property(_get_base, doc="The URL for the root of this branch.")
 
1253
 
 
1254
    def _finish_transaction(self):
 
1255
        """Exit the current transaction."""
 
1256
        return self.control_files._finish_transaction()
 
1257
 
 
1258
    def get_transaction(self):
 
1259
        """Return the current active transaction.
 
1260
 
 
1261
        If no transaction is active, this returns a passthrough object
 
1262
        for which all data is immediately flushed and no caching happens.
 
1263
        """
 
1264
        # this is an explicit function so that we can do tricky stuff
 
1265
        # when the storage in rev_storage is elsewhere.
 
1266
        # we probably need to hook the two 'lock a location' and 
 
1267
        # 'have a transaction' together more delicately, so that
 
1268
        # we can have two locks (branch and storage) and one transaction
 
1269
        # ... and finishing the transaction unlocks both, but unlocking
 
1270
        # does not. - RBC 20051121
 
1271
        return self.control_files.get_transaction()
 
1272
 
 
1273
    def _set_transaction(self, transaction):
 
1274
        """Set a new active transaction."""
 
1275
        return self.control_files._set_transaction(transaction)
 
1276
 
 
1277
    def abspath(self, name):
 
1278
        """See Branch.abspath."""
 
1279
        return self.control_files._transport.abspath(name)
 
1280
 
 
1281
    def _check_format(self, format):
 
1282
        """Identify the branch format if needed.
 
1283
 
 
1284
        The format is stored as a reference to the format object in
 
1285
        self._format for code that needs to check it later.
 
1286
 
 
1287
        The format parameter is either None or the branch format class
 
1288
        used to open this branch.
 
1289
 
 
1290
        FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
 
1291
        """
 
1292
        if format is None:
 
1293
            format = BranchFormat.find_format(self.bzrdir)
 
1294
        self._format = format
 
1295
        mutter("got branch format %s", self._format)
 
1296
 
 
1297
    @needs_read_lock
 
1298
    def get_root_id(self):
 
1299
        """See Branch.get_root_id."""
 
1300
        tree = self.repository.revision_tree(self.last_revision())
 
1301
        return tree.inventory.root.file_id
 
1302
 
 
1303
    def is_locked(self):
 
1304
        return self.control_files.is_locked()
 
1305
 
 
1306
    def lock_write(self):
 
1307
        self.repository.lock_write()
 
1308
        try:
 
1309
            self.control_files.lock_write()
 
1310
        except:
 
1311
            self.repository.unlock()
 
1312
            raise
 
1313
 
 
1314
    def lock_read(self):
 
1315
        self.repository.lock_read()
 
1316
        try:
 
1317
            self.control_files.lock_read()
 
1318
        except:
 
1319
            self.repository.unlock()
 
1320
            raise
 
1321
 
 
1322
    def unlock(self):
 
1323
        # TODO: test for failed two phase locks. This is known broken.
 
1324
        try:
 
1325
            self.control_files.unlock()
 
1326
        finally:
 
1327
            self.repository.unlock()
 
1328
        
 
1329
    def peek_lock_mode(self):
 
1330
        if self.control_files._lock_count == 0:
 
1331
            return None
 
1332
        else:
 
1333
            return self.control_files._lock_mode
 
1334
 
 
1335
    def get_physical_lock_status(self):
 
1336
        return self.control_files.get_physical_lock_status()
 
1337
 
 
1338
    @needs_read_lock
 
1339
    def print_file(self, file, revision_id):
 
1340
        """See Branch.print_file."""
 
1341
        return self.repository.print_file(file, revision_id)
 
1342
 
 
1343
    @needs_write_lock
 
1344
    def append_revision(self, *revision_ids):
 
1345
        """See Branch.append_revision."""
 
1346
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
 
1347
        for revision_id in revision_ids:
 
1348
            _mod_revision.check_not_reserved_id(revision_id)
 
1349
            mutter("add {%s} to revision-history" % revision_id)
 
1350
        rev_history = self.revision_history()
 
1351
        rev_history.extend(revision_ids)
 
1352
        self.set_revision_history(rev_history)
 
1353
 
 
1354
    def _write_revision_history(self, history):
 
1355
        """Factored out of set_revision_history.
 
1356
 
 
1357
        This performs the actual writing to disk.
 
1358
        It is intended to be called by BzrBranch5.set_revision_history."""
 
1359
        self.control_files.put_bytes(
 
1360
            'revision-history', '\n'.join(history))
 
1361
 
 
1362
    @needs_write_lock
 
1363
    def set_revision_history(self, rev_history):
 
1364
        """See Branch.set_revision_history."""
 
1365
        rev_history = [osutils.safe_revision_id(r) for r in rev_history]
 
1366
        self._write_revision_history(rev_history)
 
1367
        transaction = self.get_transaction()
 
1368
        history = transaction.map.find_revision_history()
 
1369
        if history is not None:
 
1370
            # update the revision history in the identity map.
 
1371
            history[:] = list(rev_history)
 
1372
            # this call is disabled because revision_history is 
 
1373
            # not really an object yet, and the transaction is for objects.
 
1374
            # transaction.register_dirty(history)
 
1375
        else:
 
1376
            transaction.map.add_revision_history(rev_history)
 
1377
            # this call is disabled because revision_history is 
 
1378
            # not really an object yet, and the transaction is for objects.
 
1379
            # transaction.register_clean(history)
 
1380
        for hook in Branch.hooks['set_rh']:
 
1381
            hook(self, rev_history)
 
1382
 
 
1383
    @needs_write_lock
 
1384
    def set_last_revision_info(self, revno, revision_id):
 
1385
        revision_id = osutils.safe_revision_id(revision_id)
 
1386
        history = self._lefthand_history(revision_id)
 
1387
        assert len(history) == revno, '%d != %d' % (len(history), revno)
 
1388
        self.set_revision_history(history)
 
1389
 
 
1390
    def _gen_revision_history(self):
 
1391
        history = self.control_files.get('revision-history').read().split('\n')
 
1392
        if history[-1:] == ['']:
 
1393
            # There shouldn't be a trailing newline, but just in case.
 
1394
            history.pop()
 
1395
        return history
 
1396
 
 
1397
    @needs_read_lock
 
1398
    def revision_history(self):
 
1399
        """See Branch.revision_history."""
 
1400
        transaction = self.get_transaction()
 
1401
        history = transaction.map.find_revision_history()
 
1402
        if history is not None:
 
1403
            # mutter("cache hit for revision-history in %s", self)
 
1404
            return list(history)
 
1405
        history = self._gen_revision_history()
 
1406
        transaction.map.add_revision_history(history)
 
1407
        # this call is disabled because revision_history is 
 
1408
        # not really an object yet, and the transaction is for objects.
 
1409
        # transaction.register_clean(history, precious=True)
 
1410
        return list(history)
 
1411
 
 
1412
    def _lefthand_history(self, revision_id, last_rev=None,
 
1413
                          other_branch=None):
 
1414
        # stop_revision must be a descendant of last_revision
 
1415
        stop_graph = self.repository.get_revision_graph(revision_id)
 
1416
        if last_rev is not None and last_rev not in stop_graph:
 
1417
            # our previous tip is not merged into stop_revision
 
1418
            raise errors.DivergedBranches(self, other_branch)
 
1419
        # make a new revision history from the graph
 
1420
        current_rev_id = revision_id
 
1421
        new_history = []
 
1422
        while current_rev_id not in (None, _mod_revision.NULL_REVISION):
 
1423
            new_history.append(current_rev_id)
 
1424
            current_rev_id_parents = stop_graph[current_rev_id]
 
1425
            try:
 
1426
                current_rev_id = current_rev_id_parents[0]
 
1427
            except IndexError:
 
1428
                current_rev_id = None
 
1429
        new_history.reverse()
 
1430
        return new_history
 
1431
 
 
1432
    @needs_write_lock
 
1433
    def generate_revision_history(self, revision_id, last_rev=None,
 
1434
        other_branch=None):
 
1435
        """Create a new revision history that will finish with revision_id.
 
1436
 
 
1437
        :param revision_id: the new tip to use.
 
1438
        :param last_rev: The previous last_revision. If not None, then this
 
1439
            must be a ancestory of revision_id, or DivergedBranches is raised.
 
1440
        :param other_branch: The other branch that DivergedBranches should
 
1441
            raise with respect to.
 
1442
        """
 
1443
        revision_id = osutils.safe_revision_id(revision_id)
 
1444
        self.set_revision_history(self._lefthand_history(revision_id,
 
1445
            last_rev, other_branch))
 
1446
 
 
1447
    @needs_write_lock
 
1448
    def update_revisions(self, other, stop_revision=None):
 
1449
        """See Branch.update_revisions."""
 
1450
        other.lock_read()
 
1451
        try:
 
1452
            if stop_revision is None:
 
1453
                stop_revision = other.last_revision()
 
1454
                if stop_revision is None:
 
1455
                    # if there are no commits, we're done.
 
1456
                    return
 
1457
            else:
 
1458
                stop_revision = osutils.safe_revision_id(stop_revision)
 
1459
            # whats the current last revision, before we fetch [and change it
 
1460
            # possibly]
 
1461
            last_rev = self.last_revision()
 
1462
            # we fetch here regardless of whether we need to so that we pickup
 
1463
            # filled in ghosts.
 
1464
            self.fetch(other, stop_revision)
 
1465
            my_ancestry = self.repository.get_ancestry(last_rev)
 
1466
            if stop_revision in my_ancestry:
 
1467
                # last_revision is a descendant of stop_revision
 
1468
                return
 
1469
            self.generate_revision_history(stop_revision, last_rev=last_rev,
 
1470
                other_branch=other)
 
1471
        finally:
 
1472
            other.unlock()
 
1473
 
 
1474
    def basis_tree(self):
 
1475
        """See Branch.basis_tree."""
 
1476
        return self.repository.revision_tree(self.last_revision())
 
1477
 
 
1478
    @deprecated_method(zero_eight)
 
1479
    def working_tree(self):
 
1480
        """Create a Working tree object for this branch."""
 
1481
 
 
1482
        from bzrlib.transport.local import LocalTransport
 
1483
        if (self.base.find('://') != -1 or 
 
1484
            not isinstance(self._transport, LocalTransport)):
 
1485
            raise NoWorkingTree(self.base)
 
1486
        return self.bzrdir.open_workingtree()
 
1487
 
 
1488
    @needs_write_lock
 
1489
    def pull(self, source, overwrite=False, stop_revision=None,
 
1490
        _hook_master=None, _run_hooks=True):
 
1491
        """See Branch.pull.
 
1492
 
 
1493
        :param _hook_master: Private parameter - set the branch to 
 
1494
            be supplied as the master to push hooks.
 
1495
        :param _run_hooks: Private parameter - allow disabling of
 
1496
            hooks, used when pushing to a master branch.
 
1497
        """
 
1498
        result = PullResult()
 
1499
        result.source_branch = source
 
1500
        result.target_branch = self
 
1501
        source.lock_read()
 
1502
        try:
 
1503
            result.old_revno, result.old_revid = self.last_revision_info()
 
1504
            try:
 
1505
                self.update_revisions(source, stop_revision)
 
1506
            except DivergedBranches:
 
1507
                if not overwrite:
 
1508
                    raise
 
1509
            if overwrite:
 
1510
                if stop_revision is None:
 
1511
                    stop_revision = source.last_revision()
 
1512
                self.generate_revision_history(stop_revision)
 
1513
            result.tag_conflicts = source.tags.merge_to(self.tags)
 
1514
            result.new_revno, result.new_revid = self.last_revision_info()
 
1515
            if _hook_master:
 
1516
                result.master_branch = _hook_master
 
1517
                result.local_branch = self
 
1518
            else:
 
1519
                result.master_branch = self
 
1520
                result.local_branch = None
 
1521
            if _run_hooks:
 
1522
                for hook in Branch.hooks['post_pull']:
 
1523
                    hook(result)
 
1524
        finally:
 
1525
            source.unlock()
 
1526
        return result
 
1527
 
 
1528
    def _get_parent_location(self):
 
1529
        _locs = ['parent', 'pull', 'x-pull']
 
1530
        for l in _locs:
 
1531
            try:
 
1532
                return self.control_files.get(l).read().strip('\n')
 
1533
            except NoSuchFile:
 
1534
                pass
 
1535
        return None
 
1536
 
 
1537
    @needs_read_lock
 
1538
    def push(self, target, overwrite=False, stop_revision=None,
 
1539
        _hook_master=None, _run_hooks=True):
 
1540
        """See Branch.push.
 
1541
        
 
1542
        :param _hook_master: Private parameter - set the branch to 
 
1543
            be supplied as the master to push hooks.
 
1544
        :param _run_hooks: Private parameter - allow disabling of
 
1545
            hooks, used when pushing to a master branch.
 
1546
        """
 
1547
        result = PushResult()
 
1548
        result.source_branch = self
 
1549
        result.target_branch = target
 
1550
        target.lock_write()
 
1551
        try:
 
1552
            result.old_revno, result.old_revid = target.last_revision_info()
 
1553
            try:
 
1554
                target.update_revisions(self, stop_revision)
 
1555
            except DivergedBranches:
 
1556
                if not overwrite:
 
1557
                    raise
 
1558
            if overwrite:
 
1559
                target.set_revision_history(self.revision_history())
 
1560
            result.tag_conflicts = self.tags.merge_to(target.tags)
 
1561
            result.new_revno, result.new_revid = target.last_revision_info()
 
1562
            if _hook_master:
 
1563
                result.master_branch = _hook_master
 
1564
                result.local_branch = target
 
1565
            else:
 
1566
                result.master_branch = target
 
1567
                result.local_branch = None
 
1568
            if _run_hooks:
 
1569
                for hook in Branch.hooks['post_push']:
 
1570
                    hook(result)
 
1571
        finally:
 
1572
            target.unlock()
 
1573
        return result
 
1574
 
 
1575
    def get_parent(self):
 
1576
        """See Branch.get_parent."""
 
1577
 
 
1578
        assert self.base[-1] == '/'
 
1579
        parent = self._get_parent_location()
 
1580
        if parent is None:
 
1581
            return parent
 
1582
        # This is an old-format absolute path to a local branch
 
1583
        # turn it into a url
 
1584
        if parent.startswith('/'):
 
1585
            parent = urlutils.local_path_to_url(parent.decode('utf8'))
 
1586
        try:
 
1587
            return urlutils.join(self.base[:-1], parent)
 
1588
        except errors.InvalidURLJoin, e:
 
1589
            raise errors.InaccessibleParent(parent, self.base)
 
1590
 
 
1591
    def get_push_location(self):
 
1592
        """See Branch.get_push_location."""
 
1593
        push_loc = self.get_config().get_user_option('push_location')
 
1594
        return push_loc
 
1595
 
 
1596
    def set_push_location(self, location):
 
1597
        """See Branch.set_push_location."""
 
1598
        self.get_config().set_user_option(
 
1599
            'push_location', location,
 
1600
            store=_mod_config.STORE_LOCATION_NORECURSE)
 
1601
 
 
1602
    @needs_write_lock
 
1603
    def set_parent(self, url):
 
1604
        """See Branch.set_parent."""
 
1605
        # TODO: Maybe delete old location files?
 
1606
        # URLs should never be unicode, even on the local fs,
 
1607
        # FIXUP this and get_parent in a future branch format bump:
 
1608
        # read and rewrite the file, and have the new format code read
 
1609
        # using .get not .get_utf8. RBC 20060125
 
1610
        if url is not None:
 
1611
            if isinstance(url, unicode):
 
1612
                try: 
 
1613
                    url = url.encode('ascii')
 
1614
                except UnicodeEncodeError:
 
1615
                    raise bzrlib.errors.InvalidURL(url,
 
1616
                        "Urls must be 7-bit ascii, "
 
1617
                        "use bzrlib.urlutils.escape")
 
1618
            url = urlutils.relative_url(self.base, url)
 
1619
        self._set_parent_location(url)
 
1620
 
 
1621
    def _set_parent_location(self, url):
 
1622
        if url is None:
 
1623
            self.control_files._transport.delete('parent')
 
1624
        else:
 
1625
            assert isinstance(url, str)
 
1626
            self.control_files.put_bytes('parent', url + '\n')
 
1627
 
 
1628
    @deprecated_function(zero_nine)
 
1629
    def tree_config(self):
 
1630
        """DEPRECATED; call get_config instead.  
 
1631
        TreeConfig has become part of BranchConfig."""
 
1632
        return TreeConfig(self)
 
1633
 
 
1634
 
 
1635
class BzrBranch5(BzrBranch):
 
1636
    """A format 5 branch. This supports new features over plan branches.
 
1637
 
 
1638
    It has support for a master_branch which is the data for bound branches.
 
1639
    """
 
1640
 
 
1641
    def __init__(self,
 
1642
                 _format,
 
1643
                 _control_files,
 
1644
                 a_bzrdir,
 
1645
                 _repository):
 
1646
        super(BzrBranch5, self).__init__(_format=_format,
 
1647
                                         _control_files=_control_files,
 
1648
                                         a_bzrdir=a_bzrdir,
 
1649
                                         _repository=_repository)
 
1650
        
 
1651
    @needs_write_lock
 
1652
    def pull(self, source, overwrite=False, stop_revision=None,
 
1653
        _run_hooks=True):
 
1654
        """Extends branch.pull to be bound branch aware.
 
1655
        
 
1656
        :param _run_hooks: Private parameter used to force hook running
 
1657
            off during bound branch double-pushing.
 
1658
        """
 
1659
        bound_location = self.get_bound_location()
 
1660
        master_branch = None
 
1661
        if bound_location and source.base != bound_location:
 
1662
            # not pulling from master, so we need to update master.
 
1663
            master_branch = self.get_master_branch()
 
1664
            master_branch.lock_write()
 
1665
        try:
 
1666
            if master_branch:
 
1667
                # pull from source into master.
 
1668
                master_branch.pull(source, overwrite, stop_revision,
 
1669
                    _run_hooks=False)
 
1670
            return super(BzrBranch5, self).pull(source, overwrite,
 
1671
                stop_revision, _hook_master=master_branch,
 
1672
                _run_hooks=_run_hooks)
 
1673
        finally:
 
1674
            if master_branch:
 
1675
                master_branch.unlock()
 
1676
 
 
1677
    @needs_read_lock
 
1678
    def push(self, target, overwrite=False, stop_revision=None):
 
1679
        """Updates branch.push to be bound branch aware."""
 
1680
        bound_location = target.get_bound_location()
 
1681
        master_branch = None
 
1682
        if bound_location and target.base != bound_location:
 
1683
            # not pushing to master, so we need to update master.
 
1684
            master_branch = target.get_master_branch()
 
1685
            master_branch.lock_write()
 
1686
        try:
 
1687
            if master_branch:
 
1688
                # push into the master from this branch.
 
1689
                super(BzrBranch5, self).push(master_branch, overwrite,
 
1690
                    stop_revision, _run_hooks=False)
 
1691
            # and push into the target branch from this. Note that we push from
 
1692
            # this branch again, because its considered the highest bandwidth
 
1693
            # repository.
 
1694
            return super(BzrBranch5, self).push(target, overwrite,
 
1695
                stop_revision, _hook_master=master_branch)
 
1696
        finally:
 
1697
            if master_branch:
 
1698
                master_branch.unlock()
 
1699
 
 
1700
    def get_bound_location(self):
 
1701
        try:
 
1702
            return self.control_files.get_utf8('bound').read()[:-1]
 
1703
        except errors.NoSuchFile:
 
1704
            return None
 
1705
 
 
1706
    @needs_read_lock
 
1707
    def get_master_branch(self):
 
1708
        """Return the branch we are bound to.
 
1709
        
 
1710
        :return: Either a Branch, or None
 
1711
 
 
1712
        This could memoise the branch, but if thats done
 
1713
        it must be revalidated on each new lock.
 
1714
        So for now we just don't memoise it.
 
1715
        # RBC 20060304 review this decision.
 
1716
        """
 
1717
        bound_loc = self.get_bound_location()
 
1718
        if not bound_loc:
 
1719
            return None
 
1720
        try:
 
1721
            return Branch.open(bound_loc)
 
1722
        except (errors.NotBranchError, errors.ConnectionError), e:
 
1723
            raise errors.BoundBranchConnectionFailure(
 
1724
                    self, bound_loc, e)
 
1725
 
 
1726
    @needs_write_lock
 
1727
    def set_bound_location(self, location):
 
1728
        """Set the target where this branch is bound to.
 
1729
 
 
1730
        :param location: URL to the target branch
 
1731
        """
 
1732
        if location:
 
1733
            self.control_files.put_utf8('bound', location+'\n')
 
1734
        else:
 
1735
            try:
 
1736
                self.control_files._transport.delete('bound')
 
1737
            except NoSuchFile:
 
1738
                return False
1333
1739
            return True
1334
 
        if filename == head:
1335
 
            break
1336
 
        filename = head
1337
 
    return False
1338
 
 
1339
 
 
1340
 
 
1341
 
def gen_file_id(name):
1342
 
    """Return new file id.
1343
 
 
1344
 
    This should probably generate proper UUIDs, but for the moment we
1345
 
    cope with just randomness because running uuidgen every time is
1346
 
    slow."""
1347
 
    import re
1348
 
    from binascii import hexlify
1349
 
    from time import time
1350
 
 
1351
 
    # get last component
1352
 
    idx = name.rfind('/')
1353
 
    if idx != -1:
1354
 
        name = name[idx+1 : ]
1355
 
    idx = name.rfind('\\')
1356
 
    if idx != -1:
1357
 
        name = name[idx+1 : ]
1358
 
 
1359
 
    # make it not a hidden file
1360
 
    name = name.lstrip('.')
1361
 
 
1362
 
    # remove any wierd characters; we don't escape them but rather
1363
 
    # just pull them out
1364
 
    name = re.sub(r'[^\w.]', '', name)
1365
 
 
1366
 
    s = hexlify(rand_bytes(8))
1367
 
    return '-'.join((name, compact_date(time()), s))
1368
 
 
1369
 
 
1370
 
def gen_root_id():
1371
 
    """Return a new tree-root file id."""
1372
 
    return gen_file_id('TREE_ROOT')
1373
 
 
 
1740
 
 
1741
    @needs_write_lock
 
1742
    def bind(self, other):
 
1743
        """Bind this branch to the branch other.
 
1744
 
 
1745
        This does not push or pull data between the branches, though it does
 
1746
        check for divergence to raise an error when the branches are not
 
1747
        either the same, or one a prefix of the other. That behaviour may not
 
1748
        be useful, so that check may be removed in future.
 
1749
        
 
1750
        :param other: The branch to bind to
 
1751
        :type other: Branch
 
1752
        """
 
1753
        # TODO: jam 20051230 Consider checking if the target is bound
 
1754
        #       It is debatable whether you should be able to bind to
 
1755
        #       a branch which is itself bound.
 
1756
        #       Committing is obviously forbidden,
 
1757
        #       but binding itself may not be.
 
1758
        #       Since we *have* to check at commit time, we don't
 
1759
        #       *need* to check here
 
1760
 
 
1761
        # we want to raise diverged if:
 
1762
        # last_rev is not in the other_last_rev history, AND
 
1763
        # other_last_rev is not in our history, and do it without pulling
 
1764
        # history around
 
1765
        last_rev = self.last_revision()
 
1766
        if last_rev is not None:
 
1767
            other.lock_read()
 
1768
            try:
 
1769
                other_last_rev = other.last_revision()
 
1770
                if other_last_rev is not None:
 
1771
                    # neither branch is new, we have to do some work to
 
1772
                    # ascertain diversion.
 
1773
                    remote_graph = other.repository.get_revision_graph(
 
1774
                        other_last_rev)
 
1775
                    local_graph = self.repository.get_revision_graph(last_rev)
 
1776
                    if (last_rev not in remote_graph and
 
1777
                        other_last_rev not in local_graph):
 
1778
                        raise errors.DivergedBranches(self, other)
 
1779
            finally:
 
1780
                other.unlock()
 
1781
        self.set_bound_location(other.base)
 
1782
 
 
1783
    @needs_write_lock
 
1784
    def unbind(self):
 
1785
        """If bound, unbind"""
 
1786
        return self.set_bound_location(None)
 
1787
 
 
1788
    @needs_write_lock
 
1789
    def update(self):
 
1790
        """Synchronise this branch with the master branch if any. 
 
1791
 
 
1792
        :return: None or the last_revision that was pivoted out during the
 
1793
                 update.
 
1794
        """
 
1795
        master = self.get_master_branch()
 
1796
        if master is not None:
 
1797
            old_tip = self.last_revision()
 
1798
            self.pull(master, overwrite=True)
 
1799
            if old_tip in self.repository.get_ancestry(self.last_revision()):
 
1800
                return None
 
1801
            return old_tip
 
1802
        return None
 
1803
 
 
1804
 
 
1805
class BzrBranchExperimental(BzrBranch5):
 
1806
    """Bzr experimental branch format
 
1807
 
 
1808
    This format has:
 
1809
     - a revision-history file.
 
1810
     - a format string
 
1811
     - a lock dir guarding the branch itself
 
1812
     - all of this stored in a branch/ subdirectory
 
1813
     - works with shared repositories.
 
1814
     - a tag dictionary in the branch
 
1815
 
 
1816
    This format is new in bzr 0.15, but shouldn't be used for real data, 
 
1817
    only for testing.
 
1818
 
 
1819
    This class acts as it's own BranchFormat.
 
1820
    """
 
1821
 
 
1822
    _matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
1823
 
 
1824
    @classmethod
 
1825
    def get_format_string(cls):
 
1826
        """See BranchFormat.get_format_string()."""
 
1827
        return "Bazaar-NG branch format experimental\n"
 
1828
 
 
1829
    @classmethod
 
1830
    def get_format_description(cls):
 
1831
        """See BranchFormat.get_format_description()."""
 
1832
        return "Experimental branch format"
 
1833
 
 
1834
    @classmethod
 
1835
    def _initialize_control_files(cls, a_bzrdir, utf8_files, lock_filename,
 
1836
            lock_class):
 
1837
        branch_transport = a_bzrdir.get_branch_transport(cls)
 
1838
        control_files = lockable_files.LockableFiles(branch_transport,
 
1839
            lock_filename, lock_class)
 
1840
        control_files.create_lock()
 
1841
        control_files.lock_write()
 
1842
        try:
 
1843
            for filename, content in utf8_files:
 
1844
                control_files.put_utf8(filename, content)
 
1845
        finally:
 
1846
            control_files.unlock()
 
1847
        
 
1848
    @classmethod
 
1849
    def initialize(cls, a_bzrdir):
 
1850
        """Create a branch of this format in a_bzrdir."""
 
1851
        utf8_files = [('format', cls.get_format_string()),
 
1852
                      ('revision-history', ''),
 
1853
                      ('branch-name', ''),
 
1854
                      ('tags', ''),
 
1855
                      ]
 
1856
        cls._initialize_control_files(a_bzrdir, utf8_files,
 
1857
            'lock', lockdir.LockDir)
 
1858
        return cls.open(a_bzrdir, _found=True)
 
1859
 
 
1860
    @classmethod
 
1861
    def open(cls, a_bzrdir, _found=False):
 
1862
        """Return the branch object for a_bzrdir
 
1863
 
 
1864
        _found is a private parameter, do not use it. It is used to indicate
 
1865
               if format probing has already be done.
 
1866
        """
 
1867
        if not _found:
 
1868
            format = BranchFormat.find_format(a_bzrdir)
 
1869
            assert format.__class__ == cls
 
1870
        transport = a_bzrdir.get_branch_transport(None)
 
1871
        control_files = lockable_files.LockableFiles(transport, 'lock',
 
1872
                                                     lockdir.LockDir)
 
1873
        return cls(_format=cls,
 
1874
            _control_files=control_files,
 
1875
            a_bzrdir=a_bzrdir,
 
1876
            _repository=a_bzrdir.find_repository())
 
1877
 
 
1878
    @classmethod
 
1879
    def is_supported(cls):
 
1880
        return True
 
1881
 
 
1882
    def _make_tags(self):
 
1883
        return BasicTags(self)
 
1884
 
 
1885
    @classmethod
 
1886
    def supports_tags(cls):
 
1887
        return True
 
1888
 
 
1889
 
 
1890
BranchFormat.register_format(BzrBranchExperimental)
 
1891
 
 
1892
 
 
1893
class BzrBranch6(BzrBranch5):
 
1894
 
 
1895
    @needs_read_lock
 
1896
    def last_revision_info(self):
 
1897
        revision_string = self.control_files.get('last-revision').read()
 
1898
        revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
 
1899
        revision_id = cache_utf8.get_cached_utf8(revision_id)
 
1900
        revno = int(revno)
 
1901
        return revno, revision_id
 
1902
 
 
1903
    def last_revision(self):
 
1904
        """Return last revision id, or None"""
 
1905
        revision_id = self.last_revision_info()[1]
 
1906
        if revision_id == _mod_revision.NULL_REVISION:
 
1907
            revision_id = None
 
1908
        return revision_id
 
1909
 
 
1910
    def _write_last_revision_info(self, revno, revision_id):
 
1911
        """Simply write out the revision id, with no checks.
 
1912
 
 
1913
        Use set_last_revision_info to perform this safely.
 
1914
 
 
1915
        Does not update the revision_history cache.
 
1916
        Intended to be called by set_last_revision_info and
 
1917
        _write_revision_history.
 
1918
        """
 
1919
        if revision_id is None:
 
1920
            revision_id = 'null:'
 
1921
        out_string = '%d %s\n' % (revno, revision_id)
 
1922
        self.control_files.put_bytes('last-revision', out_string)
 
1923
 
 
1924
    @needs_write_lock
 
1925
    def set_last_revision_info(self, revno, revision_id):
 
1926
        revision_id = osutils.safe_revision_id(revision_id)
 
1927
        if self._get_append_revisions_only():
 
1928
            self._check_history_violation(revision_id)
 
1929
        self._write_last_revision_info(revno, revision_id)
 
1930
        transaction = self.get_transaction()
 
1931
        cached_history = transaction.map.find_revision_history()
 
1932
        if cached_history is not None:
 
1933
            transaction.map.remove_object(cached_history)
 
1934
 
 
1935
    def _check_history_violation(self, revision_id):
 
1936
        last_revision = self.last_revision()
 
1937
        if last_revision is None:
 
1938
            return
 
1939
        if last_revision not in self._lefthand_history(revision_id):
 
1940
            raise errors.AppendRevisionsOnlyViolation(self.base)
 
1941
 
 
1942
    def _gen_revision_history(self):
 
1943
        """Generate the revision history from last revision
 
1944
        """
 
1945
        history = list(self.repository.iter_reverse_revision_history(
 
1946
            self.last_revision()))
 
1947
        history.reverse()
 
1948
        return history
 
1949
 
 
1950
    def _write_revision_history(self, history):
 
1951
        """Factored out of set_revision_history.
 
1952
 
 
1953
        This performs the actual writing to disk, with format-specific checks.
 
1954
        It is intended to be called by BzrBranch5.set_revision_history.
 
1955
        """
 
1956
        if len(history) == 0:
 
1957
            last_revision = 'null:'
 
1958
        else:
 
1959
            if history != self._lefthand_history(history[-1]):
 
1960
                raise errors.NotLefthandHistory(history)
 
1961
            last_revision = history[-1]
 
1962
        if self._get_append_revisions_only():
 
1963
            self._check_history_violation(last_revision)
 
1964
        self._write_last_revision_info(len(history), last_revision)
 
1965
 
 
1966
    @needs_write_lock
 
1967
    def append_revision(self, *revision_ids):
 
1968
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
 
1969
        if len(revision_ids) == 0:
 
1970
            return
 
1971
        prev_revno, prev_revision = self.last_revision_info()
 
1972
        for revision in self.repository.get_revisions(revision_ids):
 
1973
            if prev_revision == _mod_revision.NULL_REVISION:
 
1974
                if revision.parent_ids != []:
 
1975
                    raise errors.NotLeftParentDescendant(self, prev_revision,
 
1976
                                                         revision.revision_id)
 
1977
            else:
 
1978
                if revision.parent_ids[0] != prev_revision:
 
1979
                    raise errors.NotLeftParentDescendant(self, prev_revision,
 
1980
                                                         revision.revision_id)
 
1981
            prev_revision = revision.revision_id
 
1982
        self.set_last_revision_info(prev_revno + len(revision_ids),
 
1983
                                    revision_ids[-1])
 
1984
 
 
1985
    @needs_write_lock
 
1986
    def _set_parent_location(self, url):
 
1987
        """Set the parent branch"""
 
1988
        self._set_config_location('parent_location', url, make_relative=True)
 
1989
 
 
1990
    @needs_read_lock
 
1991
    def _get_parent_location(self):
 
1992
        """Set the parent branch"""
 
1993
        return self._get_config_location('parent_location')
 
1994
 
 
1995
    def set_push_location(self, location):
 
1996
        """See Branch.set_push_location."""
 
1997
        self._set_config_location('push_location', location)
 
1998
 
 
1999
    def set_bound_location(self, location):
 
2000
        """See Branch.set_push_location."""
 
2001
        result = None
 
2002
        config = self.get_config()
 
2003
        if location is None:
 
2004
            if config.get_user_option('bound') != 'True':
 
2005
                return False
 
2006
            else:
 
2007
                config.set_user_option('bound', 'False')
 
2008
                return True
 
2009
        else:
 
2010
            self._set_config_location('bound_location', location,
 
2011
                                      config=config)
 
2012
            config.set_user_option('bound', 'True')
 
2013
        return True
 
2014
 
 
2015
    def _get_bound_location(self, bound):
 
2016
        """Return the bound location in the config file.
 
2017
 
 
2018
        Return None if the bound parameter does not match"""
 
2019
        config = self.get_config()
 
2020
        config_bound = (config.get_user_option('bound') == 'True')
 
2021
        if config_bound != bound:
 
2022
            return None
 
2023
        return self._get_config_location('bound_location', config=config)
 
2024
 
 
2025
    def get_bound_location(self):
 
2026
        """See Branch.set_push_location."""
 
2027
        return self._get_bound_location(True)
 
2028
 
 
2029
    def get_old_bound_location(self):
 
2030
        """See Branch.get_old_bound_location"""
 
2031
        return self._get_bound_location(False)
 
2032
 
 
2033
    def set_append_revisions_only(self, enabled):
 
2034
        if enabled:
 
2035
            value = 'True'
 
2036
        else:
 
2037
            value = 'False'
 
2038
        self.get_config().set_user_option('append_revisions_only', value)
 
2039
 
 
2040
    def _get_append_revisions_only(self):
 
2041
        value = self.get_config().get_user_option('append_revisions_only')
 
2042
        return value == 'True'
 
2043
 
 
2044
    def _synchronize_history(self, destination, revision_id):
 
2045
        """Synchronize last revision and revision history between branches.
 
2046
 
 
2047
        This version is most efficient when the destination is also a
 
2048
        BzrBranch6, but works for BzrBranch5, as long as the destination's
 
2049
        repository contains all the lefthand ancestors of the intended
 
2050
        last_revision.  If not, set_last_revision_info will fail.
 
2051
 
 
2052
        :param destination: The branch to copy the history into
 
2053
        :param revision_id: The revision-id to truncate history at.  May
 
2054
          be None to copy complete history.
 
2055
        """
 
2056
        if revision_id is None:
 
2057
            revno, revision_id = self.last_revision_info()
 
2058
        else:
 
2059
            revno = self.revision_id_to_revno(revision_id)
 
2060
        destination.set_last_revision_info(revno, revision_id)
 
2061
 
 
2062
    def _make_tags(self):
 
2063
        return BasicTags(self)
 
2064
 
 
2065
 
 
2066
class BranchTestProviderAdapter(object):
 
2067
    """A tool to generate a suite testing multiple branch formats at once.
 
2068
 
 
2069
    This is done by copying the test once for each transport and injecting
 
2070
    the transport_server, transport_readonly_server, and branch_format
 
2071
    classes into each copy. Each copy is also given a new id() to make it
 
2072
    easy to identify.
 
2073
    """
 
2074
 
 
2075
    def __init__(self, transport_server, transport_readonly_server, formats):
 
2076
        self._transport_server = transport_server
 
2077
        self._transport_readonly_server = transport_readonly_server
 
2078
        self._formats = formats
 
2079
    
 
2080
    def adapt(self, test):
 
2081
        result = TestSuite()
 
2082
        for branch_format, bzrdir_format in self._formats:
 
2083
            new_test = deepcopy(test)
 
2084
            new_test.transport_server = self._transport_server
 
2085
            new_test.transport_readonly_server = self._transport_readonly_server
 
2086
            new_test.bzrdir_format = bzrdir_format
 
2087
            new_test.branch_format = branch_format
 
2088
            def make_new_test_id():
 
2089
                # the format can be either a class or an instance
 
2090
                name = getattr(branch_format, '__name__',
 
2091
                        branch_format.__class__.__name__)
 
2092
                new_id = "%s(%s)" % (new_test.id(), name)
 
2093
                return lambda: new_id
 
2094
            new_test.id = make_new_test_id()
 
2095
            result.addTest(new_test)
 
2096
        return result
 
2097
 
 
2098
 
 
2099
######################################################################
 
2100
# results of operations
 
2101
 
 
2102
 
 
2103
class _Result(object):
 
2104
 
 
2105
    def _show_tag_conficts(self, to_file):
 
2106
        if not getattr(self, 'tag_conflicts', None):
 
2107
            return
 
2108
        to_file.write('Conflicting tags:\n')
 
2109
        for name, value1, value2 in self.tag_conflicts:
 
2110
            to_file.write('    %s\n' % (name, ))
 
2111
 
 
2112
 
 
2113
class PullResult(_Result):
 
2114
    """Result of a Branch.pull operation.
 
2115
 
 
2116
    :ivar old_revno: Revision number before pull.
 
2117
    :ivar new_revno: Revision number after pull.
 
2118
    :ivar old_revid: Tip revision id before pull.
 
2119
    :ivar new_revid: Tip revision id after pull.
 
2120
    :ivar source_branch: Source (local) branch object.
 
2121
    :ivar master_branch: Master branch of the target, or None.
 
2122
    :ivar target_branch: Target/destination branch object.
 
2123
    """
 
2124
 
 
2125
    def __int__(self):
 
2126
        # DEPRECATED: pull used to return the change in revno
 
2127
        return self.new_revno - self.old_revno
 
2128
 
 
2129
    def report(self, to_file):
 
2130
        if self.old_revid == self.new_revid:
 
2131
            to_file.write('No revisions to pull.\n')
 
2132
        else:
 
2133
            to_file.write('Now on revision %d.\n' % self.new_revno)
 
2134
        self._show_tag_conficts(to_file)
 
2135
 
 
2136
 
 
2137
class PushResult(_Result):
 
2138
    """Result of a Branch.push operation.
 
2139
 
 
2140
    :ivar old_revno: Revision number before push.
 
2141
    :ivar new_revno: Revision number after push.
 
2142
    :ivar old_revid: Tip revision id before push.
 
2143
    :ivar new_revid: Tip revision id after push.
 
2144
    :ivar source_branch: Source branch object.
 
2145
    :ivar master_branch: Master branch of the target, or None.
 
2146
    :ivar target_branch: Target/destination branch object.
 
2147
    """
 
2148
 
 
2149
    def __int__(self):
 
2150
        # DEPRECATED: push used to return the change in revno
 
2151
        return self.new_revno - self.old_revno
 
2152
 
 
2153
    def report(self, to_file):
 
2154
        """Write a human-readable description of the result."""
 
2155
        if self.old_revid == self.new_revid:
 
2156
            to_file.write('No new revisions to push.\n')
 
2157
        else:
 
2158
            to_file.write('Pushed up to revision %d.\n' % self.new_revno)
 
2159
        self._show_tag_conficts(to_file)
 
2160
 
 
2161
 
 
2162
class BranchCheckResult(object):
 
2163
    """Results of checking branch consistency.
 
2164
 
 
2165
    :see: Branch.check
 
2166
    """
 
2167
 
 
2168
    def __init__(self, branch):
 
2169
        self.branch = branch
 
2170
 
 
2171
    def report_results(self, verbose):
 
2172
        """Report the check results via trace.note.
 
2173
        
 
2174
        :param verbose: Requests more detailed display of what was checked,
 
2175
            if any.
 
2176
        """
 
2177
        note('checked branch %s format %s',
 
2178
             self.branch.base,
 
2179
             self.branch._format)
 
2180
 
 
2181
 
 
2182
class Converter5to6(object):
 
2183
    """Perform an in-place upgrade of format 5 to format 6"""
 
2184
 
 
2185
    def convert(self, branch):
 
2186
        # Data for 5 and 6 can peacefully coexist.
 
2187
        format = BzrBranchFormat6()
 
2188
        new_branch = format.open(branch.bzrdir, _found=True)
 
2189
 
 
2190
        # Copy source data into target
 
2191
        new_branch.set_last_revision_info(*branch.last_revision_info())
 
2192
        new_branch.set_parent(branch.get_parent())
 
2193
        new_branch.set_bound_location(branch.get_bound_location())
 
2194
        new_branch.set_push_location(branch.get_push_location())
 
2195
 
 
2196
        # New branch has no tags by default
 
2197
        new_branch.tags._set_tag_dict({})
 
2198
 
 
2199
        # Copying done; now update target format
 
2200
        new_branch.control_files.put_utf8('format',
 
2201
            format.get_format_string())
 
2202
 
 
2203
        # Clean up old files
 
2204
        new_branch.control_files._transport.delete('revision-history')
 
2205
        try:
 
2206
            branch.set_parent(None)
 
2207
        except NoSuchFile:
 
2208
            pass
 
2209
        branch.set_bound_location(None)