~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: aaron.bentley at utoronto
  • Date: 2005-08-27 04:42:41 UTC
  • mfrom: (1092.1.43)
  • mto: (1185.3.4)
  • mto: This revision was merged to the branch mainline in revision 1178.
  • Revision ID: aaron.bentley@utoronto.ca-20050827044241-23d676133b9fc981
Merge of robertc@robertcollins.net-20050826013321-52eee1f1da679ee9

Show diffs side-by-side

added added

removed removed

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