← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

 * The internal storage of history, and logical branch identity have now
   been split into Branch, and Repository. The common locking and file 
   management routines are now in bzrlib.lockablefiles. 
   (Aaron Bentley, Robert Collins, Martin Pool)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/branch.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
 
18
import shutil
18
19
import sys
19
20
import os
20
21
import errno
21
22
from warnings import warn
 
23
import xml.sax.saxutils
22
24
from cStringIO import StringIO
23
25
 
24
26
 
25
27
import bzrlib
26
 
from bzrlib.inventory import InventoryEntry
27
 
import bzrlib.inventory as inventory
28
28
from bzrlib.trace import mutter, note
29
 
from bzrlib.osutils import (isdir, quotefn, compact_date, rand_bytes, 
30
 
                            rename, splitpath, sha_file, appendpath, 
31
 
                            file_kind)
 
29
from bzrlib.osutils import (isdir, quotefn,
 
30
                            rename, splitpath, sha_file,
 
31
                            file_kind, abspath, normpath, pathjoin)
 
32
import bzrlib.errors as errors
32
33
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
33
34
                           NoSuchRevision, HistoryMissing, NotBranchError,
34
35
                           DivergedBranches, LockError, UnlistableStore,
35
 
                           UnlistableBranch, NoSuchFile)
 
36
                           UnlistableBranch, NoSuchFile, NotVersionedError,
 
37
                           NoWorkingTree)
36
38
from bzrlib.textui import show_status
37
 
from bzrlib.revision import Revision
 
39
from bzrlib.config import TreeConfig
 
40
from bzrlib.decorators import needs_read_lock, needs_write_lock
38
41
from bzrlib.delta import compare_trees
39
 
from bzrlib.tree import EmptyTree, RevisionTree
 
42
import bzrlib.inventory as inventory
40
43
from bzrlib.inventory import Inventory
 
44
from bzrlib.lockable_files import LockableFiles
 
45
from bzrlib.revision import (Revision, is_ancestor, get_intervening_revisions)
 
46
from bzrlib.repository import Repository
41
47
from bzrlib.store import copy_all
42
 
from bzrlib.store.compressed_text import CompressedTextStore
43
 
from bzrlib.store.text import TextStore
44
 
from bzrlib.store.weave import WeaveStore
 
48
import bzrlib.transactions as transactions
45
49
from bzrlib.transport import Transport, get_transport
 
50
from bzrlib.tree import EmptyTree, RevisionTree
 
51
import bzrlib.ui
46
52
import bzrlib.xml5
47
 
import bzrlib.ui
48
53
 
49
54
 
50
55
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
51
56
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
52
 
## TODO: Maybe include checks for common corruption of newlines, etc?
53
 
 
 
57
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
 
58
 
 
59
 
 
60
# TODO: Maybe include checks for common corruption of newlines, etc?
54
61
 
55
62
# TODO: Some operations like log might retrieve the same revisions
56
63
# repeatedly to calculate deltas.  We could perhaps have a weakref
57
64
# cache in memory to make this faster.  In general anything can be
58
 
# cached in memory between lock and unlock operations.
59
 
 
60
 
def find_branch(*ignored, **ignored_too):
61
 
    # XXX: leave this here for about one release, then remove it
62
 
    raise NotImplementedError('find_branch() is not supported anymore, '
63
 
                              'please use one of the new branch constructors')
64
 
def _relpath(base, path):
65
 
    """Return path relative to base, or raise exception.
66
 
 
67
 
    The path may be either an absolute path or a path relative to the
68
 
    current working directory.
69
 
 
70
 
    Lifted out of Branch.relpath for ease of testing.
71
 
 
72
 
    os.path.commonprefix (python2.4) has a bad bug that it works just
73
 
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
74
 
    avoids that problem."""
75
 
    rp = os.path.abspath(path)
76
 
 
77
 
    s = []
78
 
    head = rp
79
 
    while len(head) >= len(base):
80
 
        if head == base:
81
 
            break
82
 
        head, tail = os.path.split(head)
83
 
        if tail:
84
 
            s.insert(0, tail)
85
 
    else:
86
 
        raise NotBranchError("path %r is not within branch %r" % (rp, base))
87
 
 
88
 
    return os.sep.join(s)
89
 
        
90
 
 
91
 
def find_branch_root(t):
92
 
    """Find the branch root enclosing the transport's base.
93
 
 
94
 
    t is a Transport object.
95
 
 
96
 
    It is not necessary that the base of t exists.
97
 
 
98
 
    Basically we keep looking up until we find the control directory or
99
 
    run into the root.  If there isn't one, raises NotBranchError.
100
 
    """
101
 
    orig_base = t.base
102
 
    while True:
103
 
        if t.has(bzrlib.BZRDIR):
104
 
            return t
105
 
        new_t = t.clone('..')
106
 
        if new_t.base == t.base:
107
 
            # reached the root, whatever that may be
108
 
            raise NotBranchError('%s is not in a branch' % orig_base)
109
 
        t = new_t
 
65
# cached in memory between lock and unlock operations. .. nb thats
 
66
# what the transaction identity map provides
110
67
 
111
68
 
112
69
######################################################################
128
85
        """Open a branch which may be of an old format.
129
86
        
130
87
        Only local branches are supported."""
131
 
        return _Branch(get_transport(base), relax_version_check=True)
 
88
        return BzrBranch(get_transport(base), relax_version_check=True)
132
89
        
133
90
    @staticmethod
134
91
    def open(base):
135
92
        """Open an existing branch, rooted at 'base' (url)"""
136
93
        t = get_transport(base)
137
94
        mutter("trying to open %r with transport %r", base, t)
138
 
        return _Branch(t)
 
95
        return BzrBranch(t)
139
96
 
140
97
    @staticmethod
141
98
    def open_containing(url):
142
99
        """Open an existing branch which contains url.
143
100
        
144
101
        This probes for a branch at url, and searches upwards from there.
 
102
 
 
103
        Basically we keep looking up until we find the control directory or
 
104
        run into the root.  If there isn't one, raises NotBranchError.
 
105
        If there is one, it is returned, along with the unused portion of url.
145
106
        """
146
107
        t = get_transport(url)
147
 
        t = find_branch_root(t)
148
 
        return _Branch(t)
 
108
        while True:
 
109
            try:
 
110
                return BzrBranch(t), t.relpath(url)
 
111
            except NotBranchError, e:
 
112
                mutter('not a branch in: %r %s', t.base, e)
 
113
            new_t = t.clone('..')
 
114
            if new_t.base == t.base:
 
115
                # reached the root, whatever that may be
 
116
                raise NotBranchError(path=url)
 
117
            t = new_t
149
118
 
150
119
    @staticmethod
151
120
    def initialize(base):
152
121
        """Create a new branch, rooted at 'base' (url)"""
153
 
        t = get_transport(base)
154
 
        return _Branch(t, init=True)
 
122
        t = get_transport(unicode(base))
 
123
        return BzrBranch(t, init=True)
155
124
 
156
125
    def setup_caching(self, cache_root):
157
126
        """Subclasses that care about caching should override this, and set
158
127
        up cached stores located under cache_root.
159
128
        """
 
129
        # seems to be unused, 2006-01-13 mbp
 
130
        warn('%s is deprecated' % self.setup_caching)
160
131
        self.cache_root = cache_root
161
132
 
162
 
 
163
 
class _Branch(Branch):
 
133
    def _get_nick(self):
 
134
        cfg = self.tree_config()
 
135
        return cfg.get_option(u"nickname", default=self.base.split('/')[-2])
 
136
 
 
137
    def _set_nick(self, nick):
 
138
        cfg = self.tree_config()
 
139
        cfg.set_option(nick, "nickname")
 
140
        assert cfg.get_option("nickname") == nick
 
141
 
 
142
    nick = property(_get_nick, _set_nick)
 
143
        
 
144
    def push_stores(self, branch_to):
 
145
        """Copy the content of this branches store to branch_to."""
 
146
        raise NotImplementedError('push_stores is abstract')
 
147
 
 
148
    def lock_write(self):
 
149
        raise NotImplementedError('lock_write is abstract')
 
150
        
 
151
    def lock_read(self):
 
152
        raise NotImplementedError('lock_read is abstract')
 
153
 
 
154
    def unlock(self):
 
155
        raise NotImplementedError('unlock is abstract')
 
156
 
 
157
    def peek_lock_mode(self):
 
158
        """Return lock mode for the Branch: 'r', 'w' or None"""
 
159
        raise NotImplementedError(self.peek_lock_mode)
 
160
 
 
161
    def abspath(self, name):
 
162
        """Return absolute filename for something in the branch
 
163
        
 
164
        XXX: Robert Collins 20051017 what is this used for? why is it a branch
 
165
        method and not a tree method.
 
166
        """
 
167
        raise NotImplementedError('abspath is abstract')
 
168
 
 
169
    def get_root_id(self):
 
170
        """Return the id of this branches root"""
 
171
        raise NotImplementedError('get_root_id is abstract')
 
172
 
 
173
    def print_file(self, file, revision_id):
 
174
        """Print `file` to stdout."""
 
175
        raise NotImplementedError('print_file is abstract')
 
176
 
 
177
    def append_revision(self, *revision_ids):
 
178
        raise NotImplementedError('append_revision is abstract')
 
179
 
 
180
    def set_revision_history(self, rev_history):
 
181
        raise NotImplementedError('set_revision_history is abstract')
 
182
 
 
183
    def revision_history(self):
 
184
        """Return sequence of revision hashes on to this branch."""
 
185
        raise NotImplementedError('revision_history is abstract')
 
186
 
 
187
    def revno(self):
 
188
        """Return current revision number for this branch.
 
189
 
 
190
        That is equivalent to the number of revisions committed to
 
191
        this branch.
 
192
        """
 
193
        return len(self.revision_history())
 
194
 
 
195
    def last_revision(self):
 
196
        """Return last patch hash, or None if no history."""
 
197
        ph = self.revision_history()
 
198
        if ph:
 
199
            return ph[-1]
 
200
        else:
 
201
            return None
 
202
 
 
203
    def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
 
204
        """Return a list of new revisions that would perfectly fit.
 
205
        
 
206
        If self and other have not diverged, return a list of the revisions
 
207
        present in other, but missing from self.
 
208
 
 
209
        >>> from bzrlib.commit import commit
 
210
        >>> bzrlib.trace.silent = True
 
211
        >>> br1 = ScratchBranch()
 
212
        >>> br2 = ScratchBranch()
 
213
        >>> br1.missing_revisions(br2)
 
214
        []
 
215
        >>> commit(br2, "lala!", rev_id="REVISION-ID-1")
 
216
        >>> br1.missing_revisions(br2)
 
217
        [u'REVISION-ID-1']
 
218
        >>> br2.missing_revisions(br1)
 
219
        []
 
220
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1")
 
221
        >>> br1.missing_revisions(br2)
 
222
        []
 
223
        >>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
 
224
        >>> br1.missing_revisions(br2)
 
225
        [u'REVISION-ID-2A']
 
226
        >>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
 
227
        >>> br1.missing_revisions(br2)
 
228
        Traceback (most recent call last):
 
229
        DivergedBranches: These branches have diverged.  Try merge.
 
230
        """
 
231
        self_history = self.revision_history()
 
232
        self_len = len(self_history)
 
233
        other_history = other.revision_history()
 
234
        other_len = len(other_history)
 
235
        common_index = min(self_len, other_len) -1
 
236
        if common_index >= 0 and \
 
237
            self_history[common_index] != other_history[common_index]:
 
238
            raise DivergedBranches(self, other)
 
239
 
 
240
        if stop_revision is None:
 
241
            stop_revision = other_len
 
242
        else:
 
243
            assert isinstance(stop_revision, int)
 
244
            if stop_revision > other_len:
 
245
                raise bzrlib.errors.NoSuchRevision(self, stop_revision)
 
246
        return other_history[self_len:stop_revision]
 
247
 
 
248
    def update_revisions(self, other, stop_revision=None):
 
249
        """Pull in new perfect-fit revisions."""
 
250
        raise NotImplementedError('update_revisions is abstract')
 
251
 
 
252
    def pullable_revisions(self, other, stop_revision):
 
253
        raise NotImplementedError('pullable_revisions is abstract')
 
254
        
 
255
    def revision_id_to_revno(self, revision_id):
 
256
        """Given a revision id, return its revno"""
 
257
        if revision_id is None:
 
258
            return 0
 
259
        history = self.revision_history()
 
260
        try:
 
261
            return history.index(revision_id) + 1
 
262
        except ValueError:
 
263
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
 
264
 
 
265
    def get_rev_id(self, revno, history=None):
 
266
        """Find the revision id of the specified revno."""
 
267
        if revno == 0:
 
268
            return None
 
269
        if history is None:
 
270
            history = self.revision_history()
 
271
        elif revno <= 0 or revno > len(history):
 
272
            raise bzrlib.errors.NoSuchRevision(self, revno)
 
273
        return history[revno - 1]
 
274
 
 
275
    def working_tree(self):
 
276
        """Return a `Tree` for the working copy if this is a local branch."""
 
277
        raise NotImplementedError('working_tree is abstract')
 
278
 
 
279
    def pull(self, source, overwrite=False):
 
280
        raise NotImplementedError('pull is abstract')
 
281
 
 
282
    def basis_tree(self):
 
283
        """Return `Tree` object for last revision.
 
284
 
 
285
        If there are no revisions yet, return an `EmptyTree`.
 
286
        """
 
287
        return self.repository.revision_tree(self.last_revision())
 
288
 
 
289
    def rename_one(self, from_rel, to_rel):
 
290
        """Rename one file.
 
291
 
 
292
        This can change the directory or the filename or both.
 
293
        """
 
294
        raise NotImplementedError('rename_one is abstract')
 
295
 
 
296
    def move(self, from_paths, to_name):
 
297
        """Rename files.
 
298
 
 
299
        to_name must exist as a versioned directory.
 
300
 
 
301
        If to_name exists and is a directory, the files are moved into
 
302
        it, keeping their old names.  If it is a directory, 
 
303
 
 
304
        Note that to_name is only the last component of the new name;
 
305
        this doesn't change the directory.
 
306
 
 
307
        This returns a list of (from_path, to_path) pairs for each
 
308
        entry that is moved.
 
309
        """
 
310
        raise NotImplementedError('move is abstract')
 
311
 
 
312
    def get_parent(self):
 
313
        """Return the parent location of the branch.
 
314
 
 
315
        This is the default location for push/pull/missing.  The usual
 
316
        pattern is that the user can override it by specifying a
 
317
        location.
 
318
        """
 
319
        raise NotImplementedError('get_parent is abstract')
 
320
 
 
321
    def get_push_location(self):
 
322
        """Return the None or the location to push this branch to."""
 
323
        raise NotImplementedError('get_push_location is abstract')
 
324
 
 
325
    def set_push_location(self, location):
 
326
        """Set a new push location for this branch."""
 
327
        raise NotImplementedError('set_push_location is abstract')
 
328
 
 
329
    def set_parent(self, url):
 
330
        raise NotImplementedError('set_parent is abstract')
 
331
 
 
332
    def check_revno(self, revno):
 
333
        """\
 
334
        Check whether a revno corresponds to any revision.
 
335
        Zero (the NULL revision) is considered valid.
 
336
        """
 
337
        if revno != 0:
 
338
            self.check_real_revno(revno)
 
339
            
 
340
    def check_real_revno(self, revno):
 
341
        """\
 
342
        Check whether a revno corresponds to a real revision.
 
343
        Zero (the NULL revision) is considered invalid
 
344
        """
 
345
        if revno < 1 or revno > self.revno():
 
346
            raise InvalidRevisionNumber(revno)
 
347
        
 
348
    def sign_revision(self, revision_id, gpg_strategy):
 
349
        raise NotImplementedError('sign_revision is abstract')
 
350
 
 
351
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
 
352
        raise NotImplementedError('store_revision_signature is abstract')
 
353
 
 
354
    def clone(self, to_location, revision=None, basis_branch=None, to_branch_type=None):
 
355
        """Copy this branch into the existing directory to_location.
 
356
 
 
357
        Returns the newly created branch object.
 
358
 
 
359
        revision
 
360
            If not None, only revisions up to this point will be copied.
 
361
            The head of the new branch will be that revision.  Must be a
 
362
            revid or None.
 
363
    
 
364
        to_location -- The destination directory; must either exist and be 
 
365
            empty, or not exist, in which case it is created.
 
366
    
 
367
        basis_branch
 
368
            A local branch to copy revisions from, related to this branch. 
 
369
            This is used when branching from a remote (slow) branch, and we have
 
370
            a local branch that might contain some relevant revisions.
 
371
    
 
372
        to_branch_type
 
373
            Branch type of destination branch
 
374
        """
 
375
        # circular import protection
 
376
        from bzrlib.merge import build_working_dir
 
377
 
 
378
        assert isinstance(to_location, basestring)
 
379
        if not bzrlib.osutils.lexists(to_location):
 
380
            os.mkdir(to_location)
 
381
        if to_branch_type is None:
 
382
            to_branch_type = BzrBranch
 
383
        br_to = to_branch_type.initialize(to_location)
 
384
        mutter("copy branch from %s to %s", self, br_to)
 
385
        if basis_branch is not None:
 
386
            basis_branch.push_stores(br_to)
 
387
        br_to.working_tree().set_root_id(self.get_root_id())
 
388
        if revision is None:
 
389
            revision = self.last_revision()
 
390
        br_to.update_revisions(self, stop_revision=revision)
 
391
        br_to.set_parent(self.base)
 
392
        build_working_dir(to_location)
 
393
        mutter("copied")
 
394
        return br_to
 
395
 
 
396
    def fileid_involved_between_revs(self, from_revid, to_revid):
 
397
        """ This function returns the file_id(s) involved in the
 
398
            changes between the from_revid revision and the to_revid
 
399
            revision
 
400
        """
 
401
        raise NotImplementedError('fileid_involved_between_revs is abstract')
 
402
 
 
403
    def fileid_involved(self, last_revid=None):
 
404
        """ This function returns the file_id(s) involved in the
 
405
            changes up to the revision last_revid
 
406
            If no parametr is passed, then all file_id[s] present in the
 
407
            repository are returned
 
408
        """
 
409
        raise NotImplementedError('fileid_involved is abstract')
 
410
 
 
411
    def fileid_involved_by_set(self, changes):
 
412
        """ This function returns the file_id(s) involved in the
 
413
            changes present in the set 'changes'
 
414
        """
 
415
        raise NotImplementedError('fileid_involved_by_set is abstract')
 
416
 
 
417
    def fileid_involved_between_revs(self, from_revid, to_revid):
 
418
        """ This function returns the file_id(s) involved in the
 
419
            changes between the from_revid revision and the to_revid
 
420
            revision
 
421
        """
 
422
        raise NotImplementedError('fileid_involved_between_revs is abstract')
 
423
 
 
424
    def fileid_involved(self, last_revid=None):
 
425
        """ This function returns the file_id(s) involved in the
 
426
            changes up to the revision last_revid
 
427
            If no parametr is passed, then all file_id[s] present in the
 
428
            repository are returned
 
429
        """
 
430
        raise NotImplementedError('fileid_involved is abstract')
 
431
 
 
432
    def fileid_involved_by_set(self, changes):
 
433
        """ This function returns the file_id(s) involved in the
 
434
            changes present in the set 'changes'
 
435
        """
 
436
        raise NotImplementedError('fileid_involved_by_set is abstract')
 
437
 
 
438
 
 
439
class BzrBranch(Branch):
164
440
    """A branch stored in the actual filesystem.
165
441
 
166
442
    Note that it's "local" in the context of the filesystem; it doesn't
167
443
    really matter if it's on an nfs/smb/afs/coda/... share, as long as
168
444
    it's writable, and can be accessed via the normal filesystem API.
169
445
 
170
 
    _lock_mode
171
 
        None, or 'r' or 'w'
172
 
 
173
 
    _lock_count
174
 
        If _lock_mode is true, a positive count of the number of times the
175
 
        lock has been taken.
176
 
 
177
 
    _lock
178
 
        Lock object from bzrlib.lock.
179
446
    """
180
447
    # We actually expect this class to be somewhat short-lived; part of its
181
448
    # purpose is to try to isolate what bits of the branch logic are tied to
182
449
    # filesystem access, so that in a later step, we can extricate them to
183
450
    # a separarte ("storage") class.
184
 
    _lock_mode = None
185
 
    _lock_count = None
186
 
    _lock = None
187
451
    _inventory_weave = None
188
452
    
189
453
    # Map some sort of prefix into a namespace
192
456
    REVISION_NAMESPACES = {}
193
457
 
194
458
    def push_stores(self, branch_to):
195
 
        """Copy the content of this branches store to branch_to."""
 
459
        """See Branch.push_stores."""
196
460
        if (self._branch_format != branch_to._branch_format
197
461
            or self._branch_format != 4):
198
462
            from bzrlib.fetch import greedy_fetch
216
480
        """Create new branch object at a particular location.
217
481
 
218
482
        transport -- A Transport object, defining how to access files.
219
 
                (If a string, transport.transport() will be used to
220
 
                create a Transport object)
221
483
        
222
484
        init -- If True, create new control files in a previously
223
485
             unversioned directory.  If False, the branch must already
233
495
        """
234
496
        assert isinstance(transport, Transport), \
235
497
            "%r is not a Transport" % transport
236
 
        self._transport = transport
 
498
        # TODO: jam 20060103 We create a clone of this transport at .bzr/
 
499
        #       and then we forget about it, should we keep a handle to it?
 
500
        self._base = transport.base
 
501
        self.control_files = LockableFiles(transport.clone(bzrlib.BZRDIR),
 
502
                                           'branch-lock')
237
503
        if init:
238
504
            self._make_control()
239
505
        self._check_format(relax_version_check)
240
 
 
241
 
        def get_store(name, compressed=True):
242
 
            # FIXME: This approach of assuming stores are all entirely compressed
243
 
            # or entirely uncompressed is tidy, but breaks upgrade from 
244
 
            # some existing branches where there's a mixture; we probably 
245
 
            # still want the option to look for both.
246
 
            relpath = self._rel_controlfilename(name)
247
 
            if compressed:
248
 
                store = CompressedTextStore(self._transport.clone(relpath))
249
 
            else:
250
 
                store = TextStore(self._transport.clone(relpath))
251
 
            #if self._transport.should_cache():
252
 
            #    cache_path = os.path.join(self.cache_root, name)
253
 
            #    os.mkdir(cache_path)
254
 
            #    store = bzrlib.store.CachedStore(store, cache_path)
255
 
            return store
256
 
        def get_weave(name):
257
 
            relpath = self._rel_controlfilename(name)
258
 
            ws = WeaveStore(self._transport.clone(relpath))
259
 
            if self._transport.should_cache():
260
 
                ws.enable_cache = True
261
 
            return ws
262
 
 
263
 
        if self._branch_format == 4:
264
 
            self.inventory_store = get_store('inventory-store')
265
 
            self.text_store = get_store('text-store')
266
 
            self.revision_store = get_store('revision-store')
267
 
        elif self._branch_format == 5:
268
 
            self.control_weaves = get_weave([])
269
 
            self.weave_store = get_weave('weaves')
270
 
            self.revision_store = get_store('revision-store', compressed=False)
 
506
        self.repository = Repository(transport, self._branch_format)
271
507
 
272
508
    def __str__(self):
273
 
        return '%s(%r)' % (self.__class__.__name__, self._transport.base)
274
 
 
 
509
        return '%s(%r)' % (self.__class__.__name__, self.base)
275
510
 
276
511
    __repr__ = __str__
277
512
 
278
 
 
279
513
    def __del__(self):
280
 
        if self._lock_mode or self._lock:
281
 
            # XXX: This should show something every time, and be suitable for
282
 
            # headless operation and embedding
283
 
            warn("branch %r was not explicitly unlocked" % self)
284
 
            self._lock.unlock()
285
 
 
286
514
        # TODO: It might be best to do this somewhere else,
287
515
        # but it is nice for a Branch object to automatically
288
516
        # cache it's information.
289
517
        # Alternatively, we could have the Transport objects cache requests
290
518
        # See the earlier discussion about how major objects (like Branch)
291
519
        # should never expect their __del__ function to run.
 
520
        # XXX: cache_root seems to be unused, 2006-01-13 mbp
292
521
        if hasattr(self, 'cache_root') and self.cache_root is not None:
293
522
            try:
294
 
                import shutil
295
523
                shutil.rmtree(self.cache_root)
296
524
            except:
297
525
                pass
298
526
            self.cache_root = None
299
527
 
300
528
    def _get_base(self):
301
 
        if self._transport:
302
 
            return self._transport.base
303
 
        return None
304
 
 
305
 
    base = property(_get_base)
306
 
 
307
 
 
308
 
    def lock_write(self):
309
 
        # TODO: Upgrade locking to support using a Transport,
310
 
        # and potentially a remote locking protocol
311
 
        if self._lock_mode:
312
 
            if self._lock_mode != 'w':
313
 
                raise LockError("can't upgrade to a write lock from %r" %
314
 
                                self._lock_mode)
315
 
            self._lock_count += 1
316
 
        else:
317
 
            self._lock = self._transport.lock_write(
318
 
                    self._rel_controlfilename('branch-lock'))
319
 
            self._lock_mode = 'w'
320
 
            self._lock_count = 1
321
 
 
322
 
 
323
 
    def lock_read(self):
324
 
        if self._lock_mode:
325
 
            assert self._lock_mode in ('r', 'w'), \
326
 
                   "invalid lock mode %r" % self._lock_mode
327
 
            self._lock_count += 1
328
 
        else:
329
 
            self._lock = self._transport.lock_read(
330
 
                    self._rel_controlfilename('branch-lock'))
331
 
            self._lock_mode = 'r'
332
 
            self._lock_count = 1
333
 
                        
334
 
    def unlock(self):
335
 
        if not self._lock_mode:
336
 
            raise LockError('branch %r is not locked' % (self))
337
 
 
338
 
        if self._lock_count > 1:
339
 
            self._lock_count -= 1
340
 
        else:
341
 
            self._lock.unlock()
342
 
            self._lock = None
343
 
            self._lock_mode = self._lock_count = None
 
529
        return self._base
 
530
 
 
531
    base = property(_get_base, doc="The URL for the root of this branch.")
 
532
 
 
533
    def _finish_transaction(self):
 
534
        """Exit the current transaction."""
 
535
        return self.control_files._finish_transaction()
 
536
 
 
537
    def get_transaction(self):
 
538
        """Return the current active transaction.
 
539
 
 
540
        If no transaction is active, this returns a passthrough object
 
541
        for which all data is immediately flushed and no caching happens.
 
542
        """
 
543
        # this is an explicit function so that we can do tricky stuff
 
544
        # when the storage in rev_storage is elsewhere.
 
545
        # we probably need to hook the two 'lock a location' and 
 
546
        # 'have a transaction' together more delicately, so that
 
547
        # we can have two locks (branch and storage) and one transaction
 
548
        # ... and finishing the transaction unlocks both, but unlocking
 
549
        # does not. - RBC 20051121
 
550
        return self.control_files.get_transaction()
 
551
 
 
552
    def _set_transaction(self, transaction):
 
553
        """Set a new active transaction."""
 
554
        return self.control_files._set_transaction(transaction)
344
555
 
345
556
    def abspath(self, name):
346
 
        """Return absolute filename for something in the branch"""
347
 
        return self._transport.abspath(name)
348
 
 
349
 
    def relpath(self, path):
350
 
        """Return path relative to this branch of something inside it.
351
 
 
352
 
        Raises an error if path is not in this branch."""
353
 
        return self._transport.relpath(path)
354
 
 
355
 
 
356
 
    def _rel_controlfilename(self, file_or_path):
357
 
        if isinstance(file_or_path, basestring):
358
 
            file_or_path = [file_or_path]
359
 
        return [bzrlib.BZRDIR] + file_or_path
360
 
 
361
 
    def controlfilename(self, file_or_path):
362
 
        """Return location relative to branch."""
363
 
        return self._transport.abspath(self._rel_controlfilename(file_or_path))
364
 
 
365
 
 
366
 
    def controlfile(self, file_or_path, mode='r'):
367
 
        """Open a control file for this branch.
368
 
 
369
 
        There are two classes of file in the control directory: text
370
 
        and binary.  binary files are untranslated byte streams.  Text
371
 
        control files are stored with Unix newlines and in UTF-8, even
372
 
        if the platform or locale defaults are different.
373
 
 
374
 
        Controlfiles should almost never be opened in write mode but
375
 
        rather should be atomically copied and replaced using atomicfile.
376
 
        """
377
 
        import codecs
378
 
 
379
 
        relpath = self._rel_controlfilename(file_or_path)
380
 
        #TODO: codecs.open() buffers linewise, so it was overloaded with
381
 
        # a much larger buffer, do we need to do the same for getreader/getwriter?
382
 
        if mode == 'rb': 
383
 
            return self._transport.get(relpath)
384
 
        elif mode == 'wb':
385
 
            raise BzrError("Branch.controlfile(mode='wb') is not supported, use put_controlfiles")
386
 
        elif mode == 'r':
387
 
            return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
388
 
        elif mode == 'w':
389
 
            raise BzrError("Branch.controlfile(mode='w') is not supported, use put_controlfiles")
390
 
        else:
391
 
            raise BzrError("invalid controlfile mode %r" % mode)
392
 
 
393
 
    def put_controlfile(self, path, f, encode=True):
394
 
        """Write an entry as a controlfile.
395
 
 
396
 
        :param path: The path to put the file, relative to the .bzr control
397
 
                     directory
398
 
        :param f: A file-like or string object whose contents should be copied.
399
 
        :param encode:  If true, encode the contents as utf-8
400
 
        """
401
 
        self.put_controlfiles([(path, f)], encode=encode)
402
 
 
403
 
    def put_controlfiles(self, files, encode=True):
404
 
        """Write several entries as controlfiles.
405
 
 
406
 
        :param files: A list of [(path, file)] pairs, where the path is the directory
407
 
                      underneath the bzr control directory
408
 
        :param encode:  If true, encode the contents as utf-8
409
 
        """
410
 
        import codecs
411
 
        ctrl_files = []
412
 
        for path, f in files:
413
 
            if encode:
414
 
                if isinstance(f, basestring):
415
 
                    f = f.encode('utf-8', 'replace')
416
 
                else:
417
 
                    f = codecs.getwriter('utf-8')(f, errors='replace')
418
 
            path = self._rel_controlfilename(path)
419
 
            ctrl_files.append((path, f))
420
 
        self._transport.put_multi(ctrl_files)
 
557
        """See Branch.abspath."""
 
558
        return self.control_files._transport.abspath(name)
421
559
 
422
560
    def _make_control(self):
423
561
        from bzrlib.inventory import Inventory
435
573
        bzrlib.weavefile.write_weave_v5(Weave(), sio)
436
574
        empty_weave = sio.getvalue()
437
575
 
438
 
        dirs = [[], 'revision-store', 'weaves']
 
576
        dirs = ['', 'revision-store', 'weaves']
439
577
        files = [('README', 
440
578
            "This is a Bazaar-NG control directory.\n"
441
579
            "Do not change any files in this directory.\n"),
442
 
            ('branch-format', BZR_BRANCH_FORMAT_5),
 
580
            ('branch-format', BZR_BRANCH_FORMAT_6),
443
581
            ('revision-history', ''),
444
582
            ('branch-name', ''),
445
583
            ('branch-lock', ''),
446
584
            ('pending-merges', ''),
447
585
            ('inventory', empty_inv),
448
586
            ('inventory.weave', empty_weave),
449
 
            ('ancestry.weave', empty_weave)
450
587
        ]
451
 
        cfn = self._rel_controlfilename
452
 
        self._transport.mkdir_multi([cfn(d) for d in dirs])
453
 
        self.put_controlfiles(files)
454
 
        mutter('created control directory in ' + self._transport.base)
 
588
        cfe = self.control_files._escape
 
589
        # FIXME: RBC 20060125 dont peek under the covers
 
590
        self.control_files._transport.mkdir_multi([cfe(d) for d in dirs],
 
591
                mode=self.control_files._dir_mode)
 
592
        self.control_files.lock_write()
 
593
        try:
 
594
            for file, content in files:
 
595
                self.control_files.put_utf8(file, content)
 
596
            mutter('created control directory in ' + self.base)
 
597
        finally:
 
598
            self.control_files.unlock()
455
599
 
456
600
    def _check_format(self, relax_version_check):
457
601
        """Check this branch format is supported.
463
607
        classes to support downlevel branches.  But not yet.
464
608
        """
465
609
        try:
466
 
            fmt = self.controlfile('branch-format', 'r').read()
 
610
            fmt = self.control_files.get_utf8('branch-format').read()
467
611
        except NoSuchFile:
468
 
            raise NotBranchError(self.base)
 
612
            raise NotBranchError(path=self.base)
469
613
        mutter("got branch format %r", fmt)
470
 
        if fmt == BZR_BRANCH_FORMAT_5:
 
614
        if fmt == BZR_BRANCH_FORMAT_6:
 
615
            self._branch_format = 6
 
616
        elif fmt == BZR_BRANCH_FORMAT_5:
471
617
            self._branch_format = 5
472
618
        elif fmt == BZR_BRANCH_FORMAT_4:
473
619
            self._branch_format = 4
474
620
 
475
621
        if (not relax_version_check
476
 
            and self._branch_format != 5):
477
 
            raise BzrError('sorry, branch format %r not supported' % fmt,
 
622
            and self._branch_format not in (5, 6)):
 
623
            raise errors.UnsupportedFormatError(
 
624
                           'sorry, branch format %r not supported' % fmt,
478
625
                           ['use a different bzr version',
479
626
                            'or remove the .bzr directory'
480
627
                            ' and "bzr init" again'])
481
628
 
 
629
    @needs_read_lock
482
630
    def get_root_id(self):
483
 
        """Return the id of this branches root"""
484
 
        inv = self.read_working_inventory()
 
631
        """See Branch.get_root_id."""
 
632
        inv = self.repository.get_inventory(self.last_revision())
485
633
        return inv.root.file_id
486
634
 
487
 
    def set_root_id(self, file_id):
488
 
        inv = self.read_working_inventory()
489
 
        orig_root_id = inv.root.file_id
490
 
        del inv._byid[inv.root.file_id]
491
 
        inv.root.file_id = file_id
492
 
        inv._byid[inv.root.file_id] = inv.root
493
 
        for fid in inv:
494
 
            entry = inv[fid]
495
 
            if entry.parent_id in (None, orig_root_id):
496
 
                entry.parent_id = inv.root.file_id
497
 
        self._write_inventory(inv)
498
 
 
499
 
    def read_working_inventory(self):
500
 
        """Read the working inventory."""
501
 
        self.lock_read()
502
 
        try:
503
 
            # ElementTree does its own conversion from UTF-8, so open in
504
 
            # binary.
505
 
            f = self.controlfile('inventory', 'rb')
506
 
            return bzrlib.xml5.serializer_v5.read_inventory(f)
507
 
        finally:
508
 
            self.unlock()
509
 
            
510
 
 
511
 
    def _write_inventory(self, inv):
512
 
        """Update the working inventory.
513
 
 
514
 
        That is to say, the inventory describing changes underway, that
515
 
        will be committed to the next revision.
516
 
        """
517
 
        from cStringIO import StringIO
518
 
        self.lock_write()
519
 
        try:
520
 
            sio = StringIO()
521
 
            bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
522
 
            sio.seek(0)
523
 
            # Transport handles atomicity
524
 
            self.put_controlfile('inventory', sio)
525
 
        finally:
526
 
            self.unlock()
527
 
        
528
 
        mutter('wrote working inventory')
529
 
            
530
 
    inventory = property(read_working_inventory, _write_inventory, None,
531
 
                         """Inventory for the working copy.""")
532
 
 
533
 
    def add(self, files, ids=None):
534
 
        """Make files versioned.
535
 
 
536
 
        Note that the command line normally calls smart_add instead,
537
 
        which can automatically recurse.
538
 
 
539
 
        This puts the files in the Added state, so that they will be
540
 
        recorded by the next commit.
541
 
 
542
 
        files
543
 
            List of paths to add, relative to the base of the tree.
544
 
 
545
 
        ids
546
 
            If set, use these instead of automatically generated ids.
547
 
            Must be the same length as the list of files, but may
548
 
            contain None for ids that are to be autogenerated.
549
 
 
550
 
        TODO: Perhaps have an option to add the ids even if the files do
551
 
              not (yet) exist.
552
 
 
553
 
        TODO: Perhaps yield the ids and paths as they're added.
554
 
        """
555
 
        # TODO: Re-adding a file that is removed in the working copy
556
 
        # should probably put it back with the previous ID.
557
 
        if isinstance(files, basestring):
558
 
            assert(ids is None or isinstance(ids, basestring))
559
 
            files = [files]
560
 
            if ids is not None:
561
 
                ids = [ids]
562
 
 
563
 
        if ids is None:
564
 
            ids = [None] * len(files)
 
635
    def lock_write(self):
 
636
        # TODO: test for failed two phase locks. This is known broken.
 
637
        self.control_files.lock_write()
 
638
        self.repository.lock_write()
 
639
 
 
640
    def lock_read(self):
 
641
        # TODO: test for failed two phase locks. This is known broken.
 
642
        self.control_files.lock_read()
 
643
        self.repository.lock_read()
 
644
 
 
645
    def unlock(self):
 
646
        # TODO: test for failed two phase locks. This is known broken.
 
647
        self.repository.unlock()
 
648
        self.control_files.unlock()
 
649
 
 
650
    def peek_lock_mode(self):
 
651
        if self.control_files._lock_count == 0:
 
652
            return None
565
653
        else:
566
 
            assert(len(ids) == len(files))
567
 
 
568
 
        self.lock_write()
569
 
        try:
570
 
            inv = self.read_working_inventory()
571
 
            for f,file_id in zip(files, ids):
572
 
                if is_control_file(f):
573
 
                    raise BzrError("cannot add control file %s" % quotefn(f))
574
 
 
575
 
                fp = splitpath(f)
576
 
 
577
 
                if len(fp) == 0:
578
 
                    raise BzrError("cannot add top-level %r" % f)
579
 
 
580
 
                fullpath = os.path.normpath(self.abspath(f))
581
 
 
582
 
                try:
583
 
                    kind = file_kind(fullpath)
584
 
                except OSError:
585
 
                    # maybe something better?
586
 
                    raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
587
 
 
588
 
                if not InventoryEntry.versionable_kind(kind):
589
 
                    raise BzrError('cannot add: not a versionable file ('
590
 
                                   'i.e. regular file, symlink or directory): %s' % quotefn(f))
591
 
 
592
 
                if file_id is None:
593
 
                    file_id = gen_file_id(f)
594
 
                inv.add_path(f, kind=kind, file_id=file_id)
595
 
 
596
 
                mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
597
 
 
598
 
            self._write_inventory(inv)
599
 
        finally:
600
 
            self.unlock()
601
 
            
602
 
 
603
 
    def print_file(self, file, revno):
604
 
        """Print `file` to stdout."""
605
 
        self.lock_read()
606
 
        try:
607
 
            tree = self.revision_tree(self.get_rev_id(revno))
608
 
            # use inventory as it was in that revision
609
 
            file_id = tree.inventory.path2id(file)
610
 
            if not file_id:
611
 
                raise BzrError("%r is not present in revision %s" % (file, revno))
612
 
            tree.print_file(file_id)
613
 
        finally:
614
 
            self.unlock()
615
 
 
616
 
 
617
 
    def remove(self, files, verbose=False):
618
 
        """Mark nominated files for removal from the inventory.
619
 
 
620
 
        This does not remove their text.  This does not run on 
621
 
 
622
 
        TODO: Refuse to remove modified files unless --force is given?
623
 
 
624
 
        TODO: Do something useful with directories.
625
 
 
626
 
        TODO: Should this remove the text or not?  Tough call; not
627
 
        removing may be useful and the user can just use use rm, and
628
 
        is the opposite of add.  Removing it is consistent with most
629
 
        other tools.  Maybe an option.
630
 
        """
631
 
        ## TODO: Normalize names
632
 
        ## TODO: Remove nested loops; better scalability
633
 
        if isinstance(files, basestring):
634
 
            files = [files]
635
 
 
636
 
        self.lock_write()
637
 
 
638
 
        try:
639
 
            tree = self.working_tree()
640
 
            inv = tree.inventory
641
 
 
642
 
            # do this before any modifications
643
 
            for f in files:
644
 
                fid = inv.path2id(f)
645
 
                if not fid:
646
 
                    raise BzrError("cannot remove unversioned file %s" % quotefn(f))
647
 
                mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
648
 
                if verbose:
649
 
                    # having remove it, it must be either ignored or unknown
650
 
                    if tree.is_ignored(f):
651
 
                        new_status = 'I'
652
 
                    else:
653
 
                        new_status = '?'
654
 
                    show_status(new_status, inv[fid].kind, quotefn(f))
655
 
                del inv[fid]
656
 
 
657
 
            self._write_inventory(inv)
658
 
        finally:
659
 
            self.unlock()
660
 
 
661
 
    # FIXME: this doesn't need to be a branch method
662
 
    def set_inventory(self, new_inventory_list):
663
 
        from bzrlib.inventory import Inventory, InventoryEntry
664
 
        inv = Inventory(self.get_root_id())
665
 
        for path, file_id, parent, kind in new_inventory_list:
666
 
            name = os.path.basename(path)
667
 
            if name == "":
668
 
                continue
669
 
            # fixme, there should be a factory function inv,add_?? 
670
 
            if kind == 'directory':
671
 
                inv.add(inventory.InventoryDirectory(file_id, name, parent))
672
 
            elif kind == 'file':
673
 
                inv.add(inventory.InventoryFile(file_id, name, parent))
674
 
            elif kind == 'symlink':
675
 
                inv.add(inventory.InventoryLink(file_id, name, parent))
676
 
            else:
677
 
                raise BzrError("unknown kind %r" % kind)
678
 
        self._write_inventory(inv)
679
 
 
680
 
    def unknowns(self):
681
 
        """Return all unknown files.
682
 
 
683
 
        These are files in the working directory that are not versioned or
684
 
        control files or ignored.
685
 
        
686
 
        >>> b = ScratchBranch(files=['foo', 'foo~'])
687
 
        >>> list(b.unknowns())
688
 
        ['foo']
689
 
        >>> b.add('foo')
690
 
        >>> list(b.unknowns())
691
 
        []
692
 
        >>> b.remove('foo')
693
 
        >>> list(b.unknowns())
694
 
        ['foo']
695
 
        """
696
 
        return self.working_tree().unknowns()
697
 
 
698
 
 
 
654
            return self.control_files._lock_mode
 
655
 
 
656
    @needs_read_lock
 
657
    def print_file(self, file, revision_id):
 
658
        """See Branch.print_file."""
 
659
        return self.repository.print_file(file, revision_id)
 
660
 
 
661
    @needs_write_lock
699
662
    def append_revision(self, *revision_ids):
 
663
        """See Branch.append_revision."""
700
664
        for revision_id in revision_ids:
701
665
            mutter("add {%s} to revision-history" % revision_id)
702
 
        self.lock_write()
703
 
        try:
704
 
            rev_history = self.revision_history()
705
 
            rev_history.extend(revision_ids)
706
 
            self.put_controlfile('revision-history', '\n'.join(rev_history))
707
 
        finally:
708
 
            self.unlock()
709
 
 
710
 
    def has_revision(self, revision_id):
711
 
        """True if this branch has a copy of the revision.
712
 
 
713
 
        This does not necessarily imply the revision is merge
714
 
        or on the mainline."""
715
 
        return (revision_id is None
716
 
                or revision_id in self.revision_store)
717
 
 
718
 
    def get_revision_xml_file(self, revision_id):
719
 
        """Return XML file object for revision object."""
720
 
        if not revision_id or not isinstance(revision_id, basestring):
721
 
            raise InvalidRevisionId(revision_id)
722
 
 
723
 
        self.lock_read()
724
 
        try:
725
 
            try:
726
 
                return self.revision_store[revision_id]
727
 
            except (IndexError, KeyError):
728
 
                raise bzrlib.errors.NoSuchRevision(self, revision_id)
729
 
        finally:
730
 
            self.unlock()
731
 
 
732
 
    #deprecated
733
 
    get_revision_xml = get_revision_xml_file
734
 
 
735
 
    def get_revision_xml(self, revision_id):
736
 
        return self.get_revision_xml_file(revision_id).read()
737
 
 
738
 
 
739
 
    def get_revision(self, revision_id):
740
 
        """Return the Revision object for a named revision"""
741
 
        xml_file = self.get_revision_xml_file(revision_id)
742
 
 
743
 
        try:
744
 
            r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
745
 
        except SyntaxError, e:
746
 
            raise bzrlib.errors.BzrError('failed to unpack revision_xml',
747
 
                                         [revision_id,
748
 
                                          str(e)])
749
 
            
750
 
        assert r.revision_id == revision_id
751
 
        return r
 
666
        rev_history = self.revision_history()
 
667
        rev_history.extend(revision_ids)
 
668
        self.set_revision_history(rev_history)
 
669
 
 
670
    @needs_write_lock
 
671
    def set_revision_history(self, rev_history):
 
672
        """See Branch.set_revision_history."""
 
673
        old_revision = self.last_revision()
 
674
        new_revision = rev_history[-1]
 
675
        self.control_files.put_utf8(
 
676
            'revision-history', '\n'.join(rev_history))
 
677
        try:
 
678
            # FIXME: RBC 20051207 this smells wrong, last_revision in the 
 
679
            # working tree may be != to last_revision in the branch - so
 
680
            # why is this passing in the branches last_revision ?
 
681
            self.working_tree().set_last_revision(new_revision, old_revision)
 
682
        except NoWorkingTree:
 
683
            mutter('Unable to set_last_revision without a working tree.')
752
684
 
753
685
    def get_revision_delta(self, revno):
754
686
        """Return the delta for one revision.
763
695
 
764
696
        # revno is 1-based; list is 0-based
765
697
 
766
 
        new_tree = self.revision_tree(rh[revno-1])
 
698
        new_tree = self.repository.revision_tree(rh[revno-1])
767
699
        if revno == 1:
768
700
            old_tree = EmptyTree()
769
701
        else:
770
 
            old_tree = self.revision_tree(rh[revno-2])
771
 
 
 
702
            old_tree = self.repository.revision_tree(rh[revno-2])
772
703
        return compare_trees(old_tree, new_tree)
773
704
 
774
 
    def get_revision_sha1(self, revision_id):
775
 
        """Hash the stored value of a revision, and return it."""
776
 
        # In the future, revision entries will be signed. At that
777
 
        # point, it is probably best *not* to include the signature
778
 
        # in the revision hash. Because that lets you re-sign
779
 
        # the revision, (add signatures/remove signatures) and still
780
 
        # have all hash pointers stay consistent.
781
 
        # But for now, just hash the contents.
782
 
        return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
783
 
 
784
 
    def get_ancestry(self, revision_id):
785
 
        """Return a list of revision-ids integrated by a revision.
786
 
        
787
 
        This currently returns a list, but the ordering is not guaranteed:
788
 
        treat it as a set.
789
 
        """
790
 
        if revision_id is None:
791
 
            return [None]
792
 
        w = self.control_weaves.get_weave('inventory')
793
 
        return [None] + map(w.idx_to_name,
794
 
                            w.inclusions([w.lookup(revision_id)]))
795
 
 
796
 
    def get_inventory_weave(self):
797
 
        return self.control_weaves.get_weave('inventory')
798
 
 
799
 
    def get_inventory(self, revision_id):
800
 
        """Get Inventory object by hash."""
801
 
        xml = self.get_inventory_xml(revision_id)
802
 
        return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
803
 
 
804
 
    def get_inventory_xml(self, revision_id):
805
 
        """Get inventory XML as a file object."""
806
 
        try:
807
 
            assert isinstance(revision_id, basestring), type(revision_id)
808
 
            iw = self.get_inventory_weave()
809
 
            return iw.get_text(iw.lookup(revision_id))
810
 
        except IndexError:
811
 
            raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
812
 
 
813
 
    def get_inventory_sha1(self, revision_id):
814
 
        """Return the sha1 hash of the inventory entry
815
 
        """
816
 
        return self.get_revision(revision_id).inventory_sha1
817
 
 
818
 
    def get_revision_inventory(self, revision_id):
819
 
        """Return inventory of a past revision."""
820
 
        # TODO: Unify this with get_inventory()
821
 
        # bzr 0.0.6 and later imposes the constraint that the inventory_id
822
 
        # must be the same as its revision, so this is trivial.
823
 
        if revision_id == None:
824
 
            return Inventory(self.get_root_id())
825
 
        else:
826
 
            return self.get_inventory(revision_id)
827
 
 
 
705
    @needs_read_lock
828
706
    def revision_history(self):
829
 
        """Return sequence of revision hashes on to this branch."""
830
 
        self.lock_read()
831
 
        try:
832
 
            return [l.rstrip('\r\n') for l in
833
 
                    self.controlfile('revision-history', 'r').readlines()]
834
 
        finally:
835
 
            self.unlock()
836
 
 
837
 
    def common_ancestor(self, other, self_revno=None, other_revno=None):
838
 
        """
839
 
        >>> from bzrlib.commit import commit
840
 
        >>> sb = ScratchBranch(files=['foo', 'foo~'])
841
 
        >>> sb.common_ancestor(sb) == (None, None)
842
 
        True
843
 
        >>> commit(sb, "Committing first revision", verbose=False)
844
 
        >>> sb.common_ancestor(sb)[0]
845
 
        1
846
 
        >>> clone = sb.clone()
847
 
        >>> commit(sb, "Committing second revision", verbose=False)
848
 
        >>> sb.common_ancestor(sb)[0]
849
 
        2
850
 
        >>> sb.common_ancestor(clone)[0]
851
 
        1
852
 
        >>> commit(clone, "Committing divergent second revision", 
853
 
        ...               verbose=False)
854
 
        >>> sb.common_ancestor(clone)[0]
855
 
        1
856
 
        >>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
857
 
        True
858
 
        >>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
859
 
        True
860
 
        >>> clone2 = sb.clone()
861
 
        >>> sb.common_ancestor(clone2)[0]
862
 
        2
863
 
        >>> sb.common_ancestor(clone2, self_revno=1)[0]
864
 
        1
865
 
        >>> sb.common_ancestor(clone2, other_revno=1)[0]
866
 
        1
867
 
        """
868
 
        my_history = self.revision_history()
869
 
        other_history = other.revision_history()
870
 
        if self_revno is None:
871
 
            self_revno = len(my_history)
872
 
        if other_revno is None:
873
 
            other_revno = len(other_history)
874
 
        indices = range(min((self_revno, other_revno)))
875
 
        indices.reverse()
876
 
        for r in indices:
877
 
            if my_history[r] == other_history[r]:
878
 
                return r+1, my_history[r]
879
 
        return None, None
880
 
 
881
 
 
882
 
    def revno(self):
883
 
        """Return current revision number for this branch.
884
 
 
885
 
        That is equivalent to the number of revisions committed to
886
 
        this branch.
887
 
        """
888
 
        return len(self.revision_history())
889
 
 
890
 
 
891
 
    def last_revision(self):
892
 
        """Return last patch hash, or None if no history.
893
 
        """
894
 
        ph = self.revision_history()
895
 
        if ph:
896
 
            return ph[-1]
897
 
        else:
898
 
            return None
899
 
 
900
 
 
901
 
    def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
902
 
        """Return a list of new revisions that would perfectly fit.
903
 
        
904
 
        If self and other have not diverged, return a list of the revisions
905
 
        present in other, but missing from self.
906
 
 
907
 
        >>> from bzrlib.commit import commit
908
 
        >>> bzrlib.trace.silent = True
909
 
        >>> br1 = ScratchBranch()
910
 
        >>> br2 = ScratchBranch()
911
 
        >>> br1.missing_revisions(br2)
912
 
        []
913
 
        >>> commit(br2, "lala!", rev_id="REVISION-ID-1")
914
 
        >>> br1.missing_revisions(br2)
915
 
        [u'REVISION-ID-1']
916
 
        >>> br2.missing_revisions(br1)
917
 
        []
918
 
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1")
919
 
        >>> br1.missing_revisions(br2)
920
 
        []
921
 
        >>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
922
 
        >>> br1.missing_revisions(br2)
923
 
        [u'REVISION-ID-2A']
924
 
        >>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
925
 
        >>> br1.missing_revisions(br2)
926
 
        Traceback (most recent call last):
927
 
        DivergedBranches: These branches have diverged.
928
 
        """
929
 
        # FIXME: If the branches have diverged, but the latest
930
 
        # revision in this branch is completely merged into the other,
931
 
        # then we should still be able to pull.
932
 
        self_history = self.revision_history()
933
 
        self_len = len(self_history)
934
 
        other_history = other.revision_history()
935
 
        other_len = len(other_history)
936
 
        common_index = min(self_len, other_len) -1
937
 
        if common_index >= 0 and \
938
 
            self_history[common_index] != other_history[common_index]:
939
 
            raise DivergedBranches(self, other)
940
 
 
941
 
        if stop_revision is None:
942
 
            stop_revision = other_len
943
 
        else:
944
 
            assert isinstance(stop_revision, int)
945
 
            if stop_revision > other_len:
946
 
                raise bzrlib.errors.NoSuchRevision(self, stop_revision)
947
 
        return other_history[self_len:stop_revision]
 
707
        """See Branch.revision_history."""
 
708
        # FIXME are transactions bound to control files ? RBC 20051121
 
709
        transaction = self.get_transaction()
 
710
        history = transaction.map.find_revision_history()
 
711
        if history is not None:
 
712
            mutter("cache hit for revision-history in %s", self)
 
713
            return list(history)
 
714
        history = [l.rstrip('\r\n') for l in
 
715
                self.control_files.get_utf8('revision-history').readlines()]
 
716
        transaction.map.add_revision_history(history)
 
717
        # this call is disabled because revision_history is 
 
718
        # not really an object yet, and the transaction is for objects.
 
719
        # transaction.register_clean(history, precious=True)
 
720
        return list(history)
948
721
 
949
722
    def update_revisions(self, other, stop_revision=None):
950
 
        """Pull in new perfect-fit revisions."""
 
723
        """See Branch.update_revisions."""
951
724
        from bzrlib.fetch import greedy_fetch
952
 
        from bzrlib.revision import get_intervening_revisions
953
725
        if stop_revision is None:
954
726
            stop_revision = other.last_revision()
 
727
        ### Should this be checking is_ancestor instead of revision_history?
 
728
        if (stop_revision is not None and 
 
729
            stop_revision in self.revision_history()):
 
730
            return
955
731
        greedy_fetch(to_branch=self, from_branch=other,
956
732
                     revision=stop_revision)
957
 
        pullable_revs = self.missing_revisions(
958
 
            other, other.revision_id_to_revno(stop_revision))
959
 
        if pullable_revs:
960
 
            greedy_fetch(to_branch=self,
961
 
                         from_branch=other,
962
 
                         revision=pullable_revs[-1])
 
733
        pullable_revs = self.pullable_revisions(other, stop_revision)
 
734
        if len(pullable_revs) > 0:
963
735
            self.append_revision(*pullable_revs)
964
 
    
965
 
 
966
 
    def commit(self, *args, **kw):
967
 
        from bzrlib.commit import Commit
968
 
        Commit().commit(self, *args, **kw)
969
 
    
970
 
    def revision_id_to_revno(self, revision_id):
971
 
        """Given a revision id, return its revno"""
972
 
        if revision_id is None:
973
 
            return 0
974
 
        history = self.revision_history()
975
 
        try:
976
 
            return history.index(revision_id) + 1
977
 
        except ValueError:
978
 
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
979
 
 
980
 
    def get_rev_id(self, revno, history=None):
981
 
        """Find the revision id of the specified revno."""
982
 
        if revno == 0:
983
 
            return None
984
 
        if history is None:
985
 
            history = self.revision_history()
986
 
        elif revno <= 0 or revno > len(history):
987
 
            raise bzrlib.errors.NoSuchRevision(self, revno)
988
 
        return history[revno - 1]
989
 
 
990
 
    def revision_tree(self, revision_id):
991
 
        """Return Tree for a revision on this branch.
992
 
 
993
 
        `revision_id` may be None for the null revision, in which case
994
 
        an `EmptyTree` is returned."""
995
 
        # TODO: refactor this to use an existing revision object
996
 
        # so we don't need to read it in twice.
997
 
        if revision_id == None:
998
 
            return EmptyTree()
999
 
        else:
1000
 
            inv = self.get_revision_inventory(revision_id)
1001
 
            return RevisionTree(self.weave_store, inv, revision_id)
1002
 
 
 
736
 
 
737
    def pullable_revisions(self, other, stop_revision):
 
738
        """See Branch.pullable_revisions."""
 
739
        other_revno = other.revision_id_to_revno(stop_revision)
 
740
        try:
 
741
            return self.missing_revisions(other, other_revno)
 
742
        except DivergedBranches, e:
 
743
            try:
 
744
                pullable_revs = get_intervening_revisions(self.last_revision(),
 
745
                                                          stop_revision, 
 
746
                                                          self.repository)
 
747
                assert self.last_revision() not in pullable_revs
 
748
                return pullable_revs
 
749
            except bzrlib.errors.NotAncestor:
 
750
                if is_ancestor(self.last_revision(), stop_revision, self):
 
751
                    return []
 
752
                else:
 
753
                    raise e
 
754
        
 
755
    def basis_tree(self):
 
756
        """See Branch.basis_tree."""
 
757
        try:
 
758
            revision_id = self.revision_history()[-1]
 
759
            # FIXME: This is an abstraction violation, the basis tree 
 
760
            # here as defined is on the working tree, the method should
 
761
            # be too. The basis tree for a branch can be different than
 
762
            # that for a working tree. RBC 20051207
 
763
            xml = self.working_tree().read_basis_inventory(revision_id)
 
764
            inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
 
765
            return RevisionTree(self.repository, inv, revision_id)
 
766
        except (IndexError, NoSuchFile, NoWorkingTree), e:
 
767
            return self.repository.revision_tree(self.last_revision())
1003
768
 
1004
769
    def working_tree(self):
1005
 
        """Return a `Tree` for the working copy."""
 
770
        """See Branch.working_tree."""
1006
771
        from bzrlib.workingtree import WorkingTree
1007
 
        # TODO: In the future, WorkingTree should utilize Transport
1008
 
        # RobertCollins 20051003 - I don't think it should - working trees are
1009
 
        # much more complex to keep consistent than our careful .bzr subset.
1010
 
        # instead, we should say that working trees are local only, and optimise
1011
 
        # for that.
1012
 
        return WorkingTree(self._transport.base, self.read_working_inventory())
1013
 
 
1014
 
 
1015
 
    def basis_tree(self):
1016
 
        """Return `Tree` object for last revision.
1017
 
 
1018
 
        If there are no revisions yet, return an `EmptyTree`.
1019
 
        """
1020
 
        return self.revision_tree(self.last_revision())
1021
 
 
1022
 
 
1023
 
    def rename_one(self, from_rel, to_rel):
1024
 
        """Rename one file.
1025
 
 
1026
 
        This can change the directory or the filename or both.
1027
 
        """
1028
 
        self.lock_write()
1029
 
        try:
1030
 
            tree = self.working_tree()
1031
 
            inv = tree.inventory
1032
 
            if not tree.has_filename(from_rel):
1033
 
                raise BzrError("can't rename: old working file %r does not exist" % from_rel)
1034
 
            if tree.has_filename(to_rel):
1035
 
                raise BzrError("can't rename: new working file %r already exists" % to_rel)
1036
 
 
1037
 
            file_id = inv.path2id(from_rel)
1038
 
            if file_id == None:
1039
 
                raise BzrError("can't rename: old name %r is not versioned" % from_rel)
1040
 
 
1041
 
            if inv.path2id(to_rel):
1042
 
                raise BzrError("can't rename: new name %r is already versioned" % to_rel)
1043
 
 
1044
 
            to_dir, to_tail = os.path.split(to_rel)
1045
 
            to_dir_id = inv.path2id(to_dir)
1046
 
            if to_dir_id == None and to_dir != '':
1047
 
                raise BzrError("can't determine destination directory id for %r" % to_dir)
1048
 
 
1049
 
            mutter("rename_one:")
1050
 
            mutter("  file_id    {%s}" % file_id)
1051
 
            mutter("  from_rel   %r" % from_rel)
1052
 
            mutter("  to_rel     %r" % to_rel)
1053
 
            mutter("  to_dir     %r" % to_dir)
1054
 
            mutter("  to_dir_id  {%s}" % to_dir_id)
1055
 
 
1056
 
            inv.rename(file_id, to_dir_id, to_tail)
1057
 
 
1058
 
            from_abs = self.abspath(from_rel)
1059
 
            to_abs = self.abspath(to_rel)
1060
 
            try:
1061
 
                rename(from_abs, to_abs)
1062
 
            except OSError, e:
1063
 
                raise BzrError("failed to rename %r to %r: %s"
1064
 
                        % (from_abs, to_abs, e[1]),
1065
 
                        ["rename rolled back"])
1066
 
 
1067
 
            self._write_inventory(inv)
1068
 
        finally:
1069
 
            self.unlock()
1070
 
 
1071
 
 
1072
 
    def move(self, from_paths, to_name):
1073
 
        """Rename files.
1074
 
 
1075
 
        to_name must exist as a versioned directory.
1076
 
 
1077
 
        If to_name exists and is a directory, the files are moved into
1078
 
        it, keeping their old names.  If it is a directory, 
1079
 
 
1080
 
        Note that to_name is only the last component of the new name;
1081
 
        this doesn't change the directory.
1082
 
 
1083
 
        This returns a list of (from_path, to_path) pairs for each
1084
 
        entry that is moved.
1085
 
        """
1086
 
        result = []
1087
 
        self.lock_write()
1088
 
        try:
1089
 
            ## TODO: Option to move IDs only
1090
 
            assert not isinstance(from_paths, basestring)
1091
 
            tree = self.working_tree()
1092
 
            inv = tree.inventory
1093
 
            to_abs = self.abspath(to_name)
1094
 
            if not isdir(to_abs):
1095
 
                raise BzrError("destination %r is not a directory" % to_abs)
1096
 
            if not tree.has_filename(to_name):
1097
 
                raise BzrError("destination %r not in working directory" % to_abs)
1098
 
            to_dir_id = inv.path2id(to_name)
1099
 
            if to_dir_id == None and to_name != '':
1100
 
                raise BzrError("destination %r is not a versioned directory" % to_name)
1101
 
            to_dir_ie = inv[to_dir_id]
1102
 
            if to_dir_ie.kind not in ('directory', 'root_directory'):
1103
 
                raise BzrError("destination %r is not a directory" % to_abs)
1104
 
 
1105
 
            to_idpath = inv.get_idpath(to_dir_id)
1106
 
 
1107
 
            for f in from_paths:
1108
 
                if not tree.has_filename(f):
1109
 
                    raise BzrError("%r does not exist in working tree" % f)
1110
 
                f_id = inv.path2id(f)
1111
 
                if f_id == None:
1112
 
                    raise BzrError("%r is not versioned" % f)
1113
 
                name_tail = splitpath(f)[-1]
1114
 
                dest_path = appendpath(to_name, name_tail)
1115
 
                if tree.has_filename(dest_path):
1116
 
                    raise BzrError("destination %r already exists" % dest_path)
1117
 
                if f_id in to_idpath:
1118
 
                    raise BzrError("can't move %r to a subdirectory of itself" % f)
1119
 
 
1120
 
            # OK, so there's a race here, it's possible that someone will
1121
 
            # create a file in this interval and then the rename might be
1122
 
            # left half-done.  But we should have caught most problems.
1123
 
 
1124
 
            for f in from_paths:
1125
 
                name_tail = splitpath(f)[-1]
1126
 
                dest_path = appendpath(to_name, name_tail)
1127
 
                result.append((f, dest_path))
1128
 
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
1129
 
                try:
1130
 
                    rename(self.abspath(f), self.abspath(dest_path))
1131
 
                except OSError, e:
1132
 
                    raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1133
 
                            ["rename rolled back"])
1134
 
 
1135
 
            self._write_inventory(inv)
1136
 
        finally:
1137
 
            self.unlock()
1138
 
 
1139
 
        return result
1140
 
 
1141
 
 
1142
 
    def revert(self, filenames, old_tree=None, backups=True):
1143
 
        """Restore selected files to the versions from a previous tree.
1144
 
 
1145
 
        backups
1146
 
            If true (default) backups are made of files before
1147
 
            they're renamed.
1148
 
        """
1149
 
        from bzrlib.errors import NotVersionedError, BzrError
1150
 
        from bzrlib.atomicfile import AtomicFile
1151
 
        from bzrlib.osutils import backup_file
1152
 
        
1153
 
        inv = self.read_working_inventory()
1154
 
        if old_tree is None:
1155
 
            old_tree = self.basis_tree()
1156
 
        old_inv = old_tree.inventory
1157
 
 
1158
 
        nids = []
1159
 
        for fn in filenames:
1160
 
            file_id = inv.path2id(fn)
1161
 
            if not file_id:
1162
 
                raise NotVersionedError("not a versioned file", fn)
1163
 
            if not old_inv.has_id(file_id):
1164
 
                raise BzrError("file not present in old tree", fn, file_id)
1165
 
            nids.append((fn, file_id))
1166
 
            
1167
 
        # TODO: Rename back if it was previously at a different location
1168
 
 
1169
 
        # TODO: If given a directory, restore the entire contents from
1170
 
        # the previous version.
1171
 
 
1172
 
        # TODO: Make a backup to a temporary file.
1173
 
 
1174
 
        # TODO: If the file previously didn't exist, delete it?
1175
 
        for fn, file_id in nids:
1176
 
            backup_file(fn)
1177
 
            
1178
 
            f = AtomicFile(fn, 'wb')
1179
 
            try:
1180
 
                f.write(old_tree.get_file(file_id).read())
1181
 
                f.commit()
1182
 
            finally:
1183
 
                f.close()
1184
 
 
1185
 
 
1186
 
    def pending_merges(self):
1187
 
        """Return a list of pending merges.
1188
 
 
1189
 
        These are revisions that have been merged into the working
1190
 
        directory but not yet committed.
1191
 
        """
1192
 
        cfn = self._rel_controlfilename('pending-merges')
1193
 
        if not self._transport.has(cfn):
1194
 
            return []
1195
 
        p = []
1196
 
        for l in self.controlfile('pending-merges', 'r').readlines():
1197
 
            p.append(l.rstrip('\n'))
1198
 
        return p
1199
 
 
1200
 
 
1201
 
    def add_pending_merge(self, *revision_ids):
1202
 
        # TODO: Perhaps should check at this point that the
1203
 
        # history of the revision is actually present?
1204
 
        p = self.pending_merges()
1205
 
        updated = False
1206
 
        for rev_id in revision_ids:
1207
 
            if rev_id in p:
1208
 
                continue
1209
 
            p.append(rev_id)
1210
 
            updated = True
1211
 
        if updated:
1212
 
            self.set_pending_merges(p)
1213
 
 
1214
 
    def set_pending_merges(self, rev_list):
1215
 
        self.lock_write()
1216
 
        try:
1217
 
            self.put_controlfile('pending-merges', '\n'.join(rev_list))
1218
 
        finally:
1219
 
            self.unlock()
1220
 
 
 
772
        if self.base.find('://') != -1:
 
773
            raise NoWorkingTree(self.base)
 
774
        return WorkingTree(self.base, branch=self)
 
775
 
 
776
    @needs_write_lock
 
777
    def pull(self, source, overwrite=False):
 
778
        """See Branch.pull."""
 
779
        source.lock_read()
 
780
        try:
 
781
            old_count = len(self.revision_history())
 
782
            try:
 
783
                self.update_revisions(source)
 
784
            except DivergedBranches:
 
785
                if not overwrite:
 
786
                    raise
 
787
            if overwrite:
 
788
                self.set_revision_history(source.revision_history())
 
789
            new_count = len(self.revision_history())
 
790
            return new_count - old_count
 
791
        finally:
 
792
            source.unlock()
1221
793
 
1222
794
    def get_parent(self):
1223
 
        """Return the parent location of the branch.
1224
 
 
1225
 
        This is the default location for push/pull/missing.  The usual
1226
 
        pattern is that the user can override it by specifying a
1227
 
        location.
1228
 
        """
 
795
        """See Branch.get_parent."""
1229
796
        import errno
1230
797
        _locs = ['parent', 'pull', 'x-pull']
1231
798
        for l in _locs:
1232
799
            try:
1233
 
                return self.controlfile(l, 'r').read().strip('\n')
1234
 
            except IOError, e:
1235
 
                if e.errno != errno.ENOENT:
1236
 
                    raise
 
800
                return self.control_files.get_utf8(l).read().strip('\n')
 
801
            except NoSuchFile:
 
802
                pass
1237
803
        return None
1238
804
 
1239
 
 
 
805
    def get_push_location(self):
 
806
        """See Branch.get_push_location."""
 
807
        config = bzrlib.config.BranchConfig(self)
 
808
        push_loc = config.get_user_option('push_location')
 
809
        return push_loc
 
810
 
 
811
    def set_push_location(self, location):
 
812
        """See Branch.set_push_location."""
 
813
        config = bzrlib.config.LocationConfig(self.base)
 
814
        config.set_user_option('push_location', location)
 
815
 
 
816
    @needs_write_lock
1240
817
    def set_parent(self, url):
 
818
        """See Branch.set_parent."""
1241
819
        # TODO: Maybe delete old location files?
1242
 
        from bzrlib.atomicfile import AtomicFile
1243
 
        self.lock_write()
 
820
        # URLs should never be unicode, even on the local fs,
 
821
        # FIXUP this and get_parent in a future branch format bump:
 
822
        # read and rewrite the file, and have the new format code read
 
823
        # using .get not .get_utf8. RBC 20060125
 
824
        self.control_files.put_utf8('parent', url + '\n')
 
825
 
 
826
    def tree_config(self):
 
827
        return TreeConfig(self)
 
828
 
 
829
    def _get_truncated_history(self, revision_id):
 
830
        history = self.revision_history()
 
831
        if revision_id is None:
 
832
            return history
1244
833
        try:
1245
 
            f = AtomicFile(self.controlfilename('parent'))
1246
 
            try:
1247
 
                f.write(url + '\n')
1248
 
                f.commit()
1249
 
            finally:
1250
 
                f.close()
1251
 
        finally:
1252
 
            self.unlock()
1253
 
 
1254
 
    def check_revno(self, revno):
1255
 
        """\
1256
 
        Check whether a revno corresponds to any revision.
1257
 
        Zero (the NULL revision) is considered valid.
1258
 
        """
1259
 
        if revno != 0:
1260
 
            self.check_real_revno(revno)
1261
 
            
1262
 
    def check_real_revno(self, revno):
1263
 
        """\
1264
 
        Check whether a revno corresponds to a real revision.
1265
 
        Zero (the NULL revision) is considered invalid
1266
 
        """
1267
 
        if revno < 1 or revno > self.revno():
1268
 
            raise InvalidRevisionNumber(revno)
1269
 
        
1270
 
        
1271
 
        
1272
 
 
1273
 
 
1274
 
class ScratchBranch(_Branch):
 
834
            idx = history.index(revision_id)
 
835
        except ValueError:
 
836
            raise InvalidRevisionId(revision_id=revision, branch=self)
 
837
        return history[:idx+1]
 
838
 
 
839
    @needs_read_lock
 
840
    def _clone_weave(self, to_location, revision=None, basis_branch=None):
 
841
        assert isinstance(to_location, basestring)
 
842
        if basis_branch is not None:
 
843
            note("basis_branch is not supported for fast weave copy yet.")
 
844
 
 
845
        history = self._get_truncated_history(revision)
 
846
        if not bzrlib.osutils.lexists(to_location):
 
847
            os.mkdir(to_location)
 
848
        branch_to = Branch.initialize(to_location)
 
849
        mutter("copy branch from %s to %s", self, branch_to)
 
850
        branch_to.working_tree().set_root_id(self.get_root_id())
 
851
 
 
852
        self.repository.copy(branch_to.repository)
 
853
        
 
854
        # must be done *after* history is copied across
 
855
        # FIXME duplicate code with base .clone().
 
856
        # .. would template method be useful here.  RBC 20051207
 
857
        branch_to.set_parent(self.base)
 
858
        branch_to.append_revision(*history)
 
859
        # circular import protection
 
860
        from bzrlib.merge import build_working_dir
 
861
        build_working_dir(to_location)
 
862
        mutter("copied")
 
863
        return branch_to
 
864
 
 
865
    def clone(self, to_location, revision=None, basis_branch=None, to_branch_type=None):
 
866
        if to_branch_type is None:
 
867
            to_branch_type = BzrBranch
 
868
 
 
869
        if to_branch_type == BzrBranch \
 
870
            and self.repository.weave_store.listable() \
 
871
            and self.repository.revision_store.listable():
 
872
            return self._clone_weave(to_location, revision, basis_branch)
 
873
 
 
874
        return Branch.clone(self, to_location, revision, basis_branch, to_branch_type)
 
875
 
 
876
    def fileid_involved_between_revs(self, from_revid, to_revid):
 
877
        """Find file_id(s) which are involved in the changes between revisions.
 
878
 
 
879
        This determines the set of revisions which are involved, and then
 
880
        finds all file ids affected by those revisions.
 
881
        """
 
882
        # TODO: jam 20060119 This code assumes that w.inclusions will
 
883
        #       always be correct. But because of the presence of ghosts
 
884
        #       it is possible to be wrong.
 
885
        #       One specific example from Robert Collins:
 
886
        #       Two branches, with revisions ABC, and AD
 
887
        #       C is a ghost merge of D.
 
888
        #       Inclusions doesn't recognize D as an ancestor.
 
889
        #       If D is ever merged in the future, the weave
 
890
        #       won't be fixed, because AD never saw revision C
 
891
        #       to cause a conflict which would force a reweave.
 
892
        w = self.repository.get_inventory_weave()
 
893
        from_set = set(w.inclusions([w.lookup(from_revid)]))
 
894
        to_set = set(w.inclusions([w.lookup(to_revid)]))
 
895
        included = to_set.difference(from_set)
 
896
        changed = map(w.idx_to_name, included)
 
897
        return self._fileid_involved_by_set(changed)
 
898
 
 
899
    def fileid_involved(self, last_revid=None):
 
900
        """Find all file_ids modified in the ancestry of last_revid.
 
901
 
 
902
        :param last_revid: If None, last_revision() will be used.
 
903
        """
 
904
        w = self.repository.get_inventory_weave()
 
905
        if not last_revid:
 
906
            changed = set(w._names)
 
907
        else:
 
908
            included = w.inclusions([w.lookup(last_revid)])
 
909
            changed = map(w.idx_to_name, included)
 
910
        return self._fileid_involved_by_set(changed)
 
911
 
 
912
    def fileid_involved_by_set(self, changes):
 
913
        """Find all file_ids modified by the set of revisions passed in.
 
914
 
 
915
        :param changes: A set() of revision ids
 
916
        """
 
917
        # TODO: jam 20060119 This line does *nothing*, remove it.
 
918
        #       or better yet, change _fileid_involved_by_set so
 
919
        #       that it takes the inventory weave, rather than
 
920
        #       pulling it out by itself.
 
921
        w = self.repository.get_inventory_weave()
 
922
        return self._fileid_involved_by_set(changes)
 
923
 
 
924
    def _fileid_involved_by_set(self, changes):
 
925
        """Find the set of file-ids affected by the set of revisions.
 
926
 
 
927
        :param changes: A set() of revision ids.
 
928
        :return: A set() of file ids.
 
929
        
 
930
        This peaks at the Weave, interpreting each line, looking to
 
931
        see if it mentions one of the revisions. And if so, includes
 
932
        the file id mentioned.
 
933
        This expects both the Weave format, and the serialization
 
934
        to have a single line per file/directory, and to have
 
935
        fileid="" and revision="" on that line.
 
936
        """
 
937
        assert self._branch_format in (5, 6), \
 
938
            "fileid_involved only supported for branches which store inventory as xml"
 
939
 
 
940
        w = self.repository.get_inventory_weave()
 
941
        file_ids = set()
 
942
        for line in w._weave:
 
943
 
 
944
            # it is ugly, but it is due to the weave structure
 
945
            if not isinstance(line, basestring): continue
 
946
 
 
947
            start = line.find('file_id="')+9
 
948
            if start < 9: continue
 
949
            end = line.find('"', start)
 
950
            assert end>= 0
 
951
            file_id = xml.sax.saxutils.unescape(line[start:end])
 
952
 
 
953
            # check if file_id is already present
 
954
            if file_id in file_ids: continue
 
955
 
 
956
            start = line.find('revision="')+10
 
957
            if start < 10: continue
 
958
            end = line.find('"', start)
 
959
            assert end>= 0
 
960
            revision_id = xml.sax.saxutils.unescape(line[start:end])
 
961
 
 
962
            if revision_id in changes:
 
963
                file_ids.add(file_id)
 
964
 
 
965
        return file_ids
 
966
 
 
967
 
 
968
class ScratchBranch(BzrBranch):
1275
969
    """Special test class: a branch that cleans up after itself.
1276
970
 
1277
971
    >>> b = ScratchBranch()
1278
972
    >>> isdir(b.base)
1279
973
    True
1280
974
    >>> bd = b.base
1281
 
    >>> b.destroy()
 
975
    >>> b._transport.__del__()
1282
976
    >>> isdir(bd)
1283
977
    False
1284
978
    """
1285
 
    def __init__(self, files=[], dirs=[], base=None):
 
979
 
 
980
    def __init__(self, files=[], dirs=[], transport=None):
1286
981
        """Make a test branch.
1287
982
 
1288
983
        This creates a temporary directory and runs init-tree in it.
1289
984
 
1290
985
        If any files are listed, they are created in the working copy.
1291
986
        """
1292
 
        from tempfile import mkdtemp
1293
 
        init = False
1294
 
        if base is None:
1295
 
            base = mkdtemp()
1296
 
            init = True
1297
 
        if isinstance(base, basestring):
1298
 
            base = get_transport(base)
1299
 
        _Branch.__init__(self, base, init=init)
 
987
        if transport is None:
 
988
            transport = bzrlib.transport.local.ScratchTransport()
 
989
            super(ScratchBranch, self).__init__(transport, init=True)
 
990
        else:
 
991
            super(ScratchBranch, self).__init__(transport)
 
992
 
 
993
        # BzrBranch creates a clone to .bzr and then forgets about the
 
994
        # original transport. A ScratchTransport() deletes itself and
 
995
        # everything underneath it when it goes away, so we need to
 
996
        # grab a local copy to prevent that from happening
 
997
        self._transport = transport
 
998
 
1300
999
        for d in dirs:
1301
1000
            self._transport.mkdir(d)
1302
1001
            
1303
1002
        for f in files:
1304
1003
            self._transport.put(f, 'content of %s' % f)
1305
1004
 
1306
 
 
1307
1005
    def clone(self):
1308
1006
        """
1309
1007
        >>> orig = ScratchBranch(files=["file1", "file2"])
 
1008
        >>> os.listdir(orig.base)
 
1009
        [u'.bzr', u'file1', u'file2']
1310
1010
        >>> clone = orig.clone()
1311
1011
        >>> if os.name != 'nt':
1312
1012
        ...   os.path.samefile(orig.base, clone.base)
1314
1014
        ...   orig.base == clone.base
1315
1015
        ...
1316
1016
        False
1317
 
        >>> os.path.isfile(os.path.join(clone.base, "file1"))
1318
 
        True
 
1017
        >>> os.listdir(clone.base)
 
1018
        [u'.bzr', u'file1', u'file2']
1319
1019
        """
1320
1020
        from shutil import copytree
1321
 
        from tempfile import mkdtemp
 
1021
        from bzrlib.osutils import mkdtemp
1322
1022
        base = mkdtemp()
1323
1023
        os.rmdir(base)
1324
1024
        copytree(self.base, base, symlinks=True)
1325
 
        return ScratchBranch(base=base)
1326
 
 
1327
 
    def __del__(self):
1328
 
        self.destroy()
1329
 
 
1330
 
    def destroy(self):
1331
 
        """Destroy the test branch, removing the scratch directory."""
1332
 
        from shutil import rmtree
1333
 
        try:
1334
 
            if self.base:
1335
 
                mutter("delete ScratchBranch %s" % self.base)
1336
 
                rmtree(self.base)
1337
 
        except OSError, e:
1338
 
            # Work around for shutil.rmtree failing on Windows when
1339
 
            # readonly files are encountered
1340
 
            mutter("hit exception in destroying ScratchBranch: %s" % e)
1341
 
            for root, dirs, files in os.walk(self.base, topdown=False):
1342
 
                for name in files:
1343
 
                    os.chmod(os.path.join(root, name), 0700)
1344
 
            rmtree(self.base)
1345
 
        self._transport = None
1346
 
 
 
1025
        return ScratchBranch(
 
1026
            transport=bzrlib.transport.local.ScratchTransport(base))
1347
1027
    
1348
1028
 
1349
1029
######################################################################
1352
1032
 
1353
1033
def is_control_file(filename):
1354
1034
    ## FIXME: better check
1355
 
    filename = os.path.normpath(filename)
 
1035
    filename = normpath(filename)
1356
1036
    while filename != '':
1357
1037
        head, tail = os.path.split(filename)
1358
 
        ## mutter('check %r for control file' % ((head, tail), ))
 
1038
        ## mutter('check %r for control file' % ((head, tail),))
1359
1039
        if tail == bzrlib.BZRDIR:
1360
1040
            return True
1361
1041
        if filename == head:
1362
1042
            break
1363
1043
        filename = head
1364
1044
    return False
1365
 
 
1366
 
 
1367
 
 
1368
 
def gen_file_id(name):
1369
 
    """Return new file id.
1370
 
 
1371
 
    This should probably generate proper UUIDs, but for the moment we
1372
 
    cope with just randomness because running uuidgen every time is
1373
 
    slow."""
1374
 
    import re
1375
 
    from binascii import hexlify
1376
 
    from time import time
1377
 
 
1378
 
    # get last component
1379
 
    idx = name.rfind('/')
1380
 
    if idx != -1:
1381
 
        name = name[idx+1 : ]
1382
 
    idx = name.rfind('\\')
1383
 
    if idx != -1:
1384
 
        name = name[idx+1 : ]
1385
 
 
1386
 
    # make it not a hidden file
1387
 
    name = name.lstrip('.')
1388
 
 
1389
 
    # remove any wierd characters; we don't escape them but rather
1390
 
    # just pull them out
1391
 
    name = re.sub(r'[^\w.]', '', name)
1392
 
 
1393
 
    s = hexlify(rand_bytes(8))
1394
 
    return '-'.join((name, compact_date(time()), s))
1395
 
 
1396
 
 
1397
 
def gen_root_id():
1398
 
    """Return a new tree-root file id."""
1399
 
    return gen_file_id('TREE_ROOT')
1400
 
 
1401