/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: Martin Pool
  • Date: 2005-08-23 00:27:12 UTC
  • Revision ID: mbp@sourcefrog.net-20050823002712-2b0f5e12243a6116
- merge aaron's merge improvements 999..1008

abentley@panoramicfeedback.com-20050822154931-a0da28d30681e2c6

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