← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Lalo Martins
  • Date: 2005-09-14 05:22:13 UTC
  • mfrom: (1185.1.10)
  • mto: (1185.1.22)
  • mto: This revision was merged to the branch mainline in revision 1390.
  • Revision ID: lalo@exoweb.net-20050914052213-2aa5c1005959abdf
merging from Robert's integration branch

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