/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

One more warn->warning typo from Robey Pointer.

Show diffs side-by-side

added added

removed removed

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