/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

  • Committer: Robert Collins
  • Date: 2005-10-16 22:31:25 UTC
  • mto: This revision was merged to the branch mainline in revision 1458.
  • Revision ID: robertc@lifelesslap.robertcollins.net-20051016223125-26d4401cb94b7b82
Branch.relpath has been moved to WorkingTree.relpath.

WorkingTree no no longer takes an inventory, rather it takes an optional branch
parameter, and if None is given will open the branch at basedir implicitly.

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