← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

[merge] jelmer

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