/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Robert Collins
  • Date: 2005-09-27 07:24:40 UTC
  • mfrom: (1185.1.41)
  • Revision ID: robertc@robertcollins.net-20050927072440-1bf4d99c3e1db5b3
pair programming worx... merge integration and weave

Show diffs side-by-side

added added

removed removed

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