/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

Remove already fixed items from TODO

Show diffs side-by-side

added added

removed removed

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