/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-23 09:25:16 UTC
  • mto: (1092.3.4)
  • mto: This revision was merged to the branch mainline in revision 1390.
  • Revision ID: robertc@robertcollins.net-20050923092516-e2c3c0f31288669d
Merge what applied of Alexander Belchenko's win32 patch.

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