/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-06 11:09:03 UTC
  • mfrom: (1178)
  • mto: (1185.1.10) (1092.3.1)
  • mto: This revision was merged to the branch mainline in revision 1390.
  • Revision ID: robertc@robertcollins.net-20050906110903-b6be7bd6102403cb
really merge mpool

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