/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Jelmer Vernooij
  • Date: 2005-11-21 20:10:56 UTC
  • mto: (1185.33.40 bzr.dev)
  • mto: This revision was merged to the branch mainline in revision 1512.
  • Revision ID: jelmer@samba.org-20051121201056-b5b364b20cb58115
Don't clear Revision.parent_ids after it has been set from the arguments

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(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):
 
587
        """Create new branch object at a particular location.
 
588
 
 
589
        transport -- A Transport object, defining how to access files.
 
590
        
 
591
        init -- If True, create new control files in a previously
 
592
             unversioned directory.  If False, the branch must already
 
593
             be versioned.
 
594
 
 
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.
 
599
 
 
600
        In the test suite, creation of new trees is tested using the
 
601
        `ScratchBranch` class.
 
602
        """
 
603
        assert isinstance(transport, Transport), \
 
604
            "%r is not a Transport" % transport
 
605
        self._transport = transport
 
606
        if init:
 
607
            self._make_control()
 
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
 
646
 
 
647
    def __str__(self):
 
648
        return '%s(%r)' % (self.__class__.__name__, self._transport.base)
 
649
 
 
650
    __repr__ = __str__
 
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
 
745
 
 
746
    def abspath(self, name):
 
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)
 
756
 
 
757
    def controlfilename(self, file_or_path):
 
758
        """See Branch.controlfilename."""
 
759
        return self._transport.abspath(self._rel_controlfilename(file_or_path))
 
760
 
 
761
    def controlfile(self, file_or_path, mode='r'):
 
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")
 
780
        else:
 
781
            raise BzrError("invalid controlfile mode %r" % mode)
 
782
 
 
783
    def put_controlfile(self, path, f, encode=True):
 
784
        """See Branch.put_controlfile."""
 
785
        self.put_controlfiles([(path, f)], encode=encode)
 
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)
 
800
 
 
801
    def _make_control(self):
 
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', 
 
819
            "This is a Bazaar-NG control directory.\n"
 
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):
 
836
        """Check this branch format is supported.
 
837
 
 
838
        The format level is stored, as an integer, in
 
839
        self._branch_format for code that needs to check it later.
 
840
 
 
841
        In the future, we might need different in-memory Branch
 
842
        classes to support downlevel branches.  But not yet.
 
843
        """
 
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."""
 
886
        # TODO: Re-adding a file that is removed in the working copy
 
887
        # should probably put it back with the previous ID.
 
888
        if isinstance(files, basestring):
 
889
            assert(ids is None or isinstance(ids, basestring))
 
890
            files = [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):
 
901
            if is_control_file(f):
 
902
                raise BzrError("cannot add control file %s" % quotefn(f))
 
903
 
 
904
            fp = splitpath(f)
 
905
 
 
906
            if len(fp) == 0:
 
907
                raise BzrError("cannot add top-level %r" % f)
 
908
 
 
909
            fullpath = os.path.normpath(self.abspath(f))
 
910
 
 
911
            try:
 
912
                kind = file_kind(fullpath)
 
913
            except OSError:
 
914
                # maybe something better?
 
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)
 
923
            inv.add_path(f, kind=kind, file_id=file_id)
 
924
 
 
925
            mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
 
926
 
 
927
        self.working_tree()._write_inventory(inv)
 
928
 
 
929
    @needs_read_lock
 
930
    def print_file(self, file, revno):
 
931
        """See Branch.print_file."""
 
932
        tree = self.revision_tree(self.get_rev_id(revno))
 
933
        # use inventory as it was in that revision
 
934
        file_id = tree.inventory.path2id(file)
 
935
        if not file_id:
 
936
            raise BzrError("%r is not present in revision %s" % (file, revno))
 
937
        tree.print_file(file_id)
 
938
 
 
939
    def unknowns(self):
 
940
        """See Branch.unknowns."""
 
941
        return self.working_tree().unknowns()
 
942
 
 
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)
 
948
        rev_history = self.revision_history()
 
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()
 
974
 
 
975
    def get_revision(self, 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
            
 
986
        assert r.revision_id == revision_id
 
987
        return r
 
988
 
 
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."""
 
1018
        try:
 
1019
            assert isinstance(revision_id, basestring), type(revision_id)
 
1020
            iw = self._get_inventory_weave()
 
1021
            return iw.get_text(iw.lookup(revision_id))
 
1022
        except IndexError:
 
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
        
 
1092
    def revision_tree(self, revision_id):
 
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:
 
1097
            return EmptyTree()
 
1098
        else:
 
1099
            inv = self.get_revision_inventory(revision_id)
 
1100
            return RevisionTree(self.weave_store, inv, revision_id)
 
1101
 
 
1102
    def working_tree(self):
 
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
 
1129
    def rename_one(self, from_rel, to_rel):
 
1130
        """See Branch.rename_one."""
 
1131
        tree = self.working_tree()
 
1132
        inv = tree.inventory
 
1133
        if not tree.has_filename(from_rel):
 
1134
            raise BzrError("can't rename: old working file %r does not exist" % from_rel)
 
1135
        if tree.has_filename(to_rel):
 
1136
            raise BzrError("can't rename: new working file %r already exists" % to_rel)
 
1137
 
 
1138
        file_id = inv.path2id(from_rel)
 
1139
        if file_id == None:
 
1140
            raise BzrError("can't rename: old name %r is not versioned" % from_rel)
 
1141
 
 
1142
        if inv.path2id(to_rel):
 
1143
            raise BzrError("can't rename: new name %r is already versioned" % to_rel)
 
1144
 
 
1145
        to_dir, to_tail = os.path.split(to_rel)
 
1146
        to_dir_id = inv.path2id(to_dir)
 
1147
        if to_dir_id == None and to_dir != '':
 
1148
            raise BzrError("can't determine destination directory id for %r" % to_dir)
 
1149
 
 
1150
        mutter("rename_one:")
 
1151
        mutter("  file_id    {%s}" % file_id)
 
1152
        mutter("  from_rel   %r" % from_rel)
 
1153
        mutter("  to_rel     %r" % to_rel)
 
1154
        mutter("  to_dir     %r" % to_dir)
 
1155
        mutter("  to_dir_id  {%s}" % to_dir_id)
 
1156
 
 
1157
        inv.rename(file_id, to_dir_id, to_tail)
 
1158
 
 
1159
        from_abs = self.abspath(from_rel)
 
1160
        to_abs = self.abspath(to_rel)
 
1161
        try:
 
1162
            rename(from_abs, to_abs)
 
1163
        except OSError, e:
 
1164
            raise BzrError("failed to rename %r to %r: %s"
 
1165
                    % (from_abs, to_abs, e[1]),
 
1166
                    ["rename rolled back"])
 
1167
 
 
1168
        self.working_tree()._write_inventory(inv)
 
1169
 
 
1170
    @needs_write_lock
 
1171
    def move(self, from_paths, to_name):
 
1172
        """See Branch.move."""
 
1173
        result = []
 
1174
        ## TODO: Option to move IDs only
 
1175
        assert not isinstance(from_paths, basestring)
 
1176
        tree = self.working_tree()
 
1177
        inv = tree.inventory
 
1178
        to_abs = self.abspath(to_name)
 
1179
        if not isdir(to_abs):
 
1180
            raise BzrError("destination %r is not a directory" % to_abs)
 
1181
        if not tree.has_filename(to_name):
 
1182
            raise BzrError("destination %r not in working directory" % to_abs)
 
1183
        to_dir_id = inv.path2id(to_name)
 
1184
        if to_dir_id == None and to_name != '':
 
1185
            raise BzrError("destination %r is not a versioned directory" % to_name)
 
1186
        to_dir_ie = inv[to_dir_id]
 
1187
        if to_dir_ie.kind not in ('directory', 'root_directory'):
 
1188
            raise BzrError("destination %r is not a directory" % to_abs)
 
1189
 
 
1190
        to_idpath = inv.get_idpath(to_dir_id)
 
1191
 
 
1192
        for f in from_paths:
 
1193
            if not tree.has_filename(f):
 
1194
                raise BzrError("%r does not exist in working tree" % f)
 
1195
            f_id = inv.path2id(f)
 
1196
            if f_id == None:
 
1197
                raise BzrError("%r is not versioned" % f)
 
1198
            name_tail = splitpath(f)[-1]
 
1199
            dest_path = appendpath(to_name, name_tail)
 
1200
            if tree.has_filename(dest_path):
 
1201
                raise BzrError("destination %r already exists" % dest_path)
 
1202
            if f_id in to_idpath:
 
1203
                raise BzrError("can't move %r to a subdirectory of itself" % f)
 
1204
 
 
1205
        # OK, so there's a race here, it's possible that someone will
 
1206
        # create a file in this interval and then the rename might be
 
1207
        # left half-done.  But we should have caught most problems.
 
1208
 
 
1209
        for f in from_paths:
 
1210
            name_tail = splitpath(f)[-1]
 
1211
            dest_path = appendpath(to_name, name_tail)
 
1212
            result.append((f, dest_path))
 
1213
            inv.rename(inv.path2id(f), to_dir_id, name_tail)
 
1214
            try:
 
1215
                rename(self.abspath(f), self.abspath(dest_path))
 
1216
            except OSError, e:
 
1217
                raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
 
1218
                        ["rename rolled back"])
 
1219
 
 
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):
 
1274
    """Special test class: a branch that cleans up after itself.
 
1275
 
 
1276
    >>> b = ScratchBranch()
 
1277
    >>> isdir(b.base)
 
1278
    True
 
1279
    >>> bd = b.base
 
1280
    >>> b._transport.__del__()
 
1281
    >>> isdir(bd)
 
1282
    False
 
1283
    """
 
1284
 
 
1285
    def __init__(self, files=[], dirs=[], transport=None):
 
1286
        """Make a test branch.
 
1287
 
 
1288
        This creates a temporary directory and runs init-tree in it.
 
1289
 
 
1290
        If any files are listed, they are created in the working copy.
 
1291
        """
 
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
 
 
1298
        for d in dirs:
 
1299
            self._transport.mkdir(d)
 
1300
            
 
1301
        for f in files:
 
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))
 
1325
    
 
1326
 
 
1327
######################################################################
 
1328
# predicates
 
1329
 
 
1330
 
 
1331
def is_control_file(filename):
 
1332
    ## FIXME: better check
 
1333
    filename = os.path.normpath(filename)
 
1334
    while filename != '':
 
1335
        head, tail = os.path.split(filename)
 
1336
        ## mutter('check %r for control file' % ((head, tail), ))
 
1337
        if tail == bzrlib.BZRDIR:
 
1338
            return True
 
1339
        if filename == head:
 
1340
            break
 
1341
        filename = head
 
1342
    return False
 
1343
 
 
1344
 
 
1345
 
 
1346
def gen_file_id(name):
 
1347
    """Return new file id.
 
1348
 
 
1349
    This should probably generate proper UUIDs, but for the moment we
 
1350
    cope with just randomness because running uuidgen every time is
 
1351
    slow."""
 
1352
    import re
 
1353
    from binascii import hexlify
 
1354
    from time import time
 
1355
 
 
1356
    # get last component
 
1357
    idx = name.rfind('/')
 
1358
    if idx != -1:
 
1359
        name = name[idx+1 : ]
 
1360
    idx = name.rfind('\\')
 
1361
    if idx != -1:
 
1362
        name = name[idx+1 : ]
 
1363
 
 
1364
    # make it not a hidden file
 
1365
    name = name.lstrip('.')
 
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
 
 
1371
    s = hexlify(rand_bytes(8))
 
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