/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 15:39:59 UTC
  • mto: (1092.3.1)
  • mto: This revision was merged to the branch mainline in revision 1397.
  • Revision ID: robertc@robertcollins.net-20050906153959-c79d671a510ca2fc
move RemoteStore to store.py

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
    def get_revision_xml(self, revision_id):
 
585
        """Return XML file object for revision object."""
 
586
        if not revision_id or not isinstance(revision_id, basestring):
 
587
            raise InvalidRevisionId(revision_id)
 
588
 
 
589
        self.lock_read()
 
590
        try:
 
591
            try:
 
592
                return self.revision_store[revision_id]
 
593
            except IndexError:
 
594
                raise bzrlib.errors.NoSuchRevision(self, revision_id)
 
595
        finally:
 
596
            self.unlock()
 
597
 
 
598
    def get_revision(self, revision_id):
 
599
        """Return the Revision object for a named revision"""
 
600
        xml_file = self.get_revision_xml(revision_id)
 
601
 
 
602
        try:
 
603
            r = unpack_xml(Revision, xml_file)
 
604
        except SyntaxError, e:
 
605
            raise bzrlib.errors.BzrError('failed to unpack revision_xml',
 
606
                                         [revision_id,
 
607
                                          str(e)])
 
608
            
 
609
        assert r.revision_id == revision_id
 
610
        return r
 
611
 
 
612
    def get_revision_delta(self, revno):
 
613
        """Return the delta for one revision.
 
614
 
 
615
        The delta is relative to its mainline predecessor, or the
 
616
        empty tree for revision 1.
 
617
        """
 
618
        assert isinstance(revno, int)
 
619
        rh = self.revision_history()
 
620
        if not (1 <= revno <= len(rh)):
 
621
            raise InvalidRevisionNumber(revno)
 
622
 
 
623
        # revno is 1-based; list is 0-based
 
624
 
 
625
        new_tree = self.revision_tree(rh[revno-1])
 
626
        if revno == 1:
 
627
            old_tree = EmptyTree()
 
628
        else:
 
629
            old_tree = self.revision_tree(rh[revno-2])
 
630
 
 
631
        return compare_trees(old_tree, new_tree)
 
632
 
 
633
        
 
634
 
 
635
    def get_revision_sha1(self, revision_id):
 
636
        """Hash the stored value of a revision, and return it."""
 
637
        # In the future, revision entries will be signed. At that
 
638
        # point, it is probably best *not* to include the signature
 
639
        # in the revision hash. Because that lets you re-sign
 
640
        # the revision, (add signatures/remove signatures) and still
 
641
        # have all hash pointers stay consistent.
 
642
        # But for now, just hash the contents.
 
643
        return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
 
644
 
 
645
 
 
646
    def get_inventory(self, inventory_id):
 
647
        """Get Inventory object by hash.
 
648
 
 
649
        TODO: Perhaps for this and similar methods, take a revision
 
650
               parameter which can be either an integer revno or a
 
651
               string hash."""
 
652
        from bzrlib.inventory import Inventory
 
653
        from bzrlib.xml import unpack_xml
 
654
 
 
655
        return unpack_xml(Inventory, self.get_inventory_xml(inventory_id))
 
656
 
 
657
 
 
658
    def get_inventory_xml(self, inventory_id):
 
659
        """Get inventory XML as a file object."""
 
660
        return self.inventory_store[inventory_id]
 
661
            
 
662
 
 
663
    def get_inventory_sha1(self, inventory_id):
 
664
        """Return the sha1 hash of the inventory entry
 
665
        """
 
666
        return sha_file(self.get_inventory_xml(inventory_id))
 
667
 
 
668
 
 
669
    def get_revision_inventory(self, revision_id):
 
670
        """Return inventory of a past revision."""
 
671
        # bzr 0.0.6 imposes the constraint that the inventory_id
 
672
        # must be the same as its revision, so this is trivial.
 
673
        if revision_id == None:
 
674
            from bzrlib.inventory import Inventory
 
675
            return Inventory(self.get_root_id())
 
676
        else:
 
677
            return self.get_inventory(revision_id)
 
678
 
 
679
 
 
680
    def revision_history(self):
 
681
        """Return sequence of revision hashes on to this branch.
 
682
 
 
683
        >>> ScratchBranch().revision_history()
 
684
        []
 
685
        """
 
686
        self.lock_read()
 
687
        try:
 
688
            return [l.rstrip('\r\n') for l in
 
689
                    self.controlfile('revision-history', 'r').readlines()]
 
690
        finally:
 
691
            self.unlock()
 
692
 
 
693
 
 
694
    def common_ancestor(self, other, self_revno=None, other_revno=None):
 
695
        """
 
696
        >>> import commit
 
697
        >>> sb = ScratchBranch(files=['foo', 'foo~'])
 
698
        >>> sb.common_ancestor(sb) == (None, None)
 
699
        True
 
700
        >>> commit.commit(sb, "Committing first revision", verbose=False)
 
701
        >>> sb.common_ancestor(sb)[0]
 
702
        1
 
703
        >>> clone = sb.clone()
 
704
        >>> commit.commit(sb, "Committing second revision", verbose=False)
 
705
        >>> sb.common_ancestor(sb)[0]
 
706
        2
 
707
        >>> sb.common_ancestor(clone)[0]
 
708
        1
 
709
        >>> commit.commit(clone, "Committing divergent second revision", 
 
710
        ...               verbose=False)
 
711
        >>> sb.common_ancestor(clone)[0]
 
712
        1
 
713
        >>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
 
714
        True
 
715
        >>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
 
716
        True
 
717
        >>> clone2 = sb.clone()
 
718
        >>> sb.common_ancestor(clone2)[0]
 
719
        2
 
720
        >>> sb.common_ancestor(clone2, self_revno=1)[0]
 
721
        1
 
722
        >>> sb.common_ancestor(clone2, other_revno=1)[0]
 
723
        1
 
724
        """
 
725
        my_history = self.revision_history()
 
726
        other_history = other.revision_history()
 
727
        if self_revno is None:
 
728
            self_revno = len(my_history)
 
729
        if other_revno is None:
 
730
            other_revno = len(other_history)
 
731
        indices = range(min((self_revno, other_revno)))
 
732
        indices.reverse()
 
733
        for r in indices:
 
734
            if my_history[r] == other_history[r]:
 
735
                return r+1, my_history[r]
 
736
        return None, None
 
737
 
 
738
 
 
739
    def revno(self):
 
740
        """Return current revision number for this branch.
 
741
 
 
742
        That is equivalent to the number of revisions committed to
 
743
        this branch.
 
744
        """
 
745
        return len(self.revision_history())
 
746
 
 
747
 
 
748
    def last_patch(self):
 
749
        """Return last patch hash, or None if no history.
 
750
        """
 
751
        ph = self.revision_history()
 
752
        if ph:
 
753
            return ph[-1]
 
754
        else:
 
755
            return None
 
756
 
 
757
 
 
758
    def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
 
759
        """
 
760
        If self and other have not diverged, return a list of the revisions
 
761
        present in other, but missing from self.
 
762
 
 
763
        >>> from bzrlib.commit import commit
 
764
        >>> bzrlib.trace.silent = True
 
765
        >>> br1 = ScratchBranch()
 
766
        >>> br2 = ScratchBranch()
 
767
        >>> br1.missing_revisions(br2)
 
768
        []
 
769
        >>> commit(br2, "lala!", rev_id="REVISION-ID-1")
 
770
        >>> br1.missing_revisions(br2)
 
771
        [u'REVISION-ID-1']
 
772
        >>> br2.missing_revisions(br1)
 
773
        []
 
774
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1")
 
775
        >>> br1.missing_revisions(br2)
 
776
        []
 
777
        >>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
 
778
        >>> br1.missing_revisions(br2)
 
779
        [u'REVISION-ID-2A']
 
780
        >>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
 
781
        >>> br1.missing_revisions(br2)
 
782
        Traceback (most recent call last):
 
783
        DivergedBranches: These branches have diverged.
 
784
        """
 
785
        self_history = self.revision_history()
 
786
        self_len = len(self_history)
 
787
        other_history = other.revision_history()
 
788
        other_len = len(other_history)
 
789
        common_index = min(self_len, other_len) -1
 
790
        if common_index >= 0 and \
 
791
            self_history[common_index] != other_history[common_index]:
 
792
            raise DivergedBranches(self, other)
 
793
 
 
794
        if stop_revision is None:
 
795
            stop_revision = other_len
 
796
        elif stop_revision > other_len:
 
797
            raise bzrlib.errors.NoSuchRevision(self, stop_revision)
 
798
        
 
799
        return other_history[self_len:stop_revision]
 
800
 
 
801
 
 
802
    def update_revisions(self, other, stop_revision=None):
 
803
        """Pull in all new revisions from other branch.
 
804
        """
 
805
        from bzrlib.fetch import greedy_fetch
 
806
 
 
807
        pb = bzrlib.ui.ui_factory.progress_bar()
 
808
        pb.update('comparing histories')
 
809
 
 
810
        revision_ids = self.missing_revisions(other, stop_revision)
 
811
 
 
812
        if len(revision_ids) > 0:
 
813
            count = greedy_fetch(self, other, revision_ids[-1], pb)[0]
 
814
        else:
 
815
            count = 0
 
816
        self.append_revision(*revision_ids)
 
817
        ## note("Added %d revisions." % count)
 
818
        pb.clear()
 
819
 
 
820
    def install_revisions(self, other, revision_ids, pb):
 
821
        if hasattr(other.revision_store, "prefetch"):
 
822
            other.revision_store.prefetch(revision_ids)
 
823
        if hasattr(other.inventory_store, "prefetch"):
 
824
            inventory_ids = [other.get_revision(r).inventory_id
 
825
                             for r in revision_ids]
 
826
            other.inventory_store.prefetch(inventory_ids)
 
827
 
 
828
        if pb is None:
 
829
            pb = bzrlib.ui.ui_factory.progress_bar()
 
830
                
 
831
        revisions = []
 
832
        needed_texts = set()
 
833
        i = 0
 
834
 
 
835
        failures = set()
 
836
        for i, rev_id in enumerate(revision_ids):
 
837
            pb.update('fetching revision', i+1, len(revision_ids))
 
838
            try:
 
839
                rev = other.get_revision(rev_id)
 
840
            except bzrlib.errors.NoSuchRevision:
 
841
                failures.add(rev_id)
 
842
                continue
 
843
 
 
844
            revisions.append(rev)
 
845
            inv = other.get_inventory(str(rev.inventory_id))
 
846
            for key, entry in inv.iter_entries():
 
847
                if entry.text_id is None:
 
848
                    continue
 
849
                if entry.text_id not in self.text_store:
 
850
                    needed_texts.add(entry.text_id)
 
851
 
 
852
        pb.clear()
 
853
                    
 
854
        count, cp_fail = self.text_store.copy_multi(other.text_store, 
 
855
                                                    needed_texts)
 
856
        #print "Added %d texts." % count 
 
857
        inventory_ids = [ f.inventory_id for f in revisions ]
 
858
        count, cp_fail = self.inventory_store.copy_multi(other.inventory_store, 
 
859
                                                         inventory_ids)
 
860
        #print "Added %d inventories." % count 
 
861
        revision_ids = [ f.revision_id for f in revisions]
 
862
 
 
863
        count, cp_fail = self.revision_store.copy_multi(other.revision_store, 
 
864
                                                          revision_ids,
 
865
                                                          permit_failure=True)
 
866
        assert len(cp_fail) == 0 
 
867
        return count, failures
 
868
       
 
869
 
 
870
    def commit(self, *args, **kw):
 
871
        from bzrlib.commit import commit
 
872
        commit(self, *args, **kw)
 
873
        
 
874
 
 
875
    def lookup_revision(self, revision):
 
876
        """Return the revision identifier for a given revision information."""
 
877
        revno, info = self._get_revision_info(revision)
 
878
        return info
 
879
 
 
880
 
 
881
    def revision_id_to_revno(self, revision_id):
 
882
        """Given a revision id, return its revno"""
 
883
        history = self.revision_history()
 
884
        try:
 
885
            return history.index(revision_id) + 1
 
886
        except ValueError:
 
887
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
 
888
 
 
889
 
 
890
    def get_revision_info(self, revision):
 
891
        """Return (revno, revision id) for revision identifier.
 
892
 
 
893
        revision can be an integer, in which case it is assumed to be revno (though
 
894
            this will translate negative values into positive ones)
 
895
        revision can also be a string, in which case it is parsed for something like
 
896
            'date:' or 'revid:' etc.
 
897
        """
 
898
        revno, rev_id = self._get_revision_info(revision)
 
899
        if revno is None:
 
900
            raise bzrlib.errors.NoSuchRevision(self, revision)
 
901
        return revno, rev_id
 
902
 
 
903
    def get_rev_id(self, revno, history=None):
 
904
        """Find the revision id of the specified revno."""
 
905
        if revno == 0:
 
906
            return None
 
907
        if history is None:
 
908
            history = self.revision_history()
 
909
        elif revno <= 0 or revno > len(history):
 
910
            raise bzrlib.errors.NoSuchRevision(self, revno)
 
911
        return history[revno - 1]
 
912
 
 
913
    def _get_revision_info(self, revision):
 
914
        """Return (revno, revision id) for revision specifier.
 
915
 
 
916
        revision can be an integer, in which case it is assumed to be revno
 
917
        (though this will translate negative values into positive ones)
 
918
        revision can also be a string, in which case it is parsed for something
 
919
        like 'date:' or 'revid:' etc.
 
920
 
 
921
        A revid is always returned.  If it is None, the specifier referred to
 
922
        the null revision.  If the revid does not occur in the revision
 
923
        history, revno will be None.
 
924
        """
 
925
        
 
926
        if revision is None:
 
927
            return 0, None
 
928
        revno = None
 
929
        try:# Convert to int if possible
 
930
            revision = int(revision)
 
931
        except ValueError:
 
932
            pass
 
933
        revs = self.revision_history()
 
934
        if isinstance(revision, int):
 
935
            if revision < 0:
 
936
                revno = len(revs) + revision + 1
 
937
            else:
 
938
                revno = revision
 
939
            rev_id = self.get_rev_id(revno, revs)
 
940
        elif isinstance(revision, basestring):
 
941
            for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
 
942
                if revision.startswith(prefix):
 
943
                    result = func(self, revs, revision)
 
944
                    if len(result) > 1:
 
945
                        revno, rev_id = result
 
946
                    else:
 
947
                        revno = result[0]
 
948
                        rev_id = self.get_rev_id(revno, revs)
 
949
                    break
 
950
            else:
 
951
                raise BzrError('No namespace registered for string: %r' %
 
952
                               revision)
 
953
        else:
 
954
            raise TypeError('Unhandled revision type %s' % revision)
 
955
 
 
956
        if revno is None:
 
957
            if rev_id is None:
 
958
                raise bzrlib.errors.NoSuchRevision(self, revision)
 
959
        return revno, rev_id
 
960
 
 
961
    def _namespace_revno(self, revs, revision):
 
962
        """Lookup a revision by revision number"""
 
963
        assert revision.startswith('revno:')
 
964
        try:
 
965
            return (int(revision[6:]),)
 
966
        except ValueError:
 
967
            return None
 
968
    REVISION_NAMESPACES['revno:'] = _namespace_revno
 
969
 
 
970
    def _namespace_revid(self, revs, revision):
 
971
        assert revision.startswith('revid:')
 
972
        rev_id = revision[len('revid:'):]
 
973
        try:
 
974
            return revs.index(rev_id) + 1, rev_id
 
975
        except ValueError:
 
976
            return None, rev_id
 
977
    REVISION_NAMESPACES['revid:'] = _namespace_revid
 
978
 
 
979
    def _namespace_last(self, revs, revision):
 
980
        assert revision.startswith('last:')
 
981
        try:
 
982
            offset = int(revision[5:])
 
983
        except ValueError:
 
984
            return (None,)
 
985
        else:
 
986
            if offset <= 0:
 
987
                raise BzrError('You must supply a positive value for --revision last:XXX')
 
988
            return (len(revs) - offset + 1,)
 
989
    REVISION_NAMESPACES['last:'] = _namespace_last
 
990
 
 
991
    def _namespace_tag(self, revs, revision):
 
992
        assert revision.startswith('tag:')
 
993
        raise BzrError('tag: namespace registered, but not implemented.')
 
994
    REVISION_NAMESPACES['tag:'] = _namespace_tag
 
995
 
 
996
    def _namespace_date(self, revs, revision):
 
997
        assert revision.startswith('date:')
 
998
        import datetime
 
999
        # Spec for date revisions:
 
1000
        #   date:value
 
1001
        #   value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
 
1002
        #   it can also start with a '+/-/='. '+' says match the first
 
1003
        #   entry after the given date. '-' is match the first entry before the date
 
1004
        #   '=' is match the first entry after, but still on the given date.
 
1005
        #
 
1006
        #   +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
 
1007
        #   -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
 
1008
        #   =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
 
1009
        #       May 13th, 2005 at 0:00
 
1010
        #
 
1011
        #   So the proper way of saying 'give me all entries for today' is:
 
1012
        #       -r {date:+today}:{date:-tomorrow}
 
1013
        #   The default is '=' when not supplied
 
1014
        val = revision[5:]
 
1015
        match_style = '='
 
1016
        if val[:1] in ('+', '-', '='):
 
1017
            match_style = val[:1]
 
1018
            val = val[1:]
 
1019
 
 
1020
        today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
 
1021
        if val.lower() == 'yesterday':
 
1022
            dt = today - datetime.timedelta(days=1)
 
1023
        elif val.lower() == 'today':
 
1024
            dt = today
 
1025
        elif val.lower() == 'tomorrow':
 
1026
            dt = today + datetime.timedelta(days=1)
 
1027
        else:
 
1028
            import re
 
1029
            # This should be done outside the function to avoid recompiling it.
 
1030
            _date_re = re.compile(
 
1031
                    r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
 
1032
                    r'(,|T)?\s*'
 
1033
                    r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
 
1034
                )
 
1035
            m = _date_re.match(val)
 
1036
            if not m or (not m.group('date') and not m.group('time')):
 
1037
                raise BzrError('Invalid revision date %r' % revision)
 
1038
 
 
1039
            if m.group('date'):
 
1040
                year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
 
1041
            else:
 
1042
                year, month, day = today.year, today.month, today.day
 
1043
            if m.group('time'):
 
1044
                hour = int(m.group('hour'))
 
1045
                minute = int(m.group('minute'))
 
1046
                if m.group('second'):
 
1047
                    second = int(m.group('second'))
 
1048
                else:
 
1049
                    second = 0
 
1050
            else:
 
1051
                hour, minute, second = 0,0,0
 
1052
 
 
1053
            dt = datetime.datetime(year=year, month=month, day=day,
 
1054
                    hour=hour, minute=minute, second=second)
 
1055
        first = dt
 
1056
        last = None
 
1057
        reversed = False
 
1058
        if match_style == '-':
 
1059
            reversed = True
 
1060
        elif match_style == '=':
 
1061
            last = dt + datetime.timedelta(days=1)
 
1062
 
 
1063
        if reversed:
 
1064
            for i in range(len(revs)-1, -1, -1):
 
1065
                r = self.get_revision(revs[i])
 
1066
                # TODO: Handle timezone.
 
1067
                dt = datetime.datetime.fromtimestamp(r.timestamp)
 
1068
                if first >= dt and (last is None or dt >= last):
 
1069
                    return (i+1,)
 
1070
        else:
 
1071
            for i in range(len(revs)):
 
1072
                r = self.get_revision(revs[i])
 
1073
                # TODO: Handle timezone.
 
1074
                dt = datetime.datetime.fromtimestamp(r.timestamp)
 
1075
                if first <= dt and (last is None or dt <= last):
 
1076
                    return (i+1,)
 
1077
    REVISION_NAMESPACES['date:'] = _namespace_date
 
1078
 
 
1079
    def revision_tree(self, revision_id):
 
1080
        """Return Tree for a revision on this branch.
 
1081
 
 
1082
        `revision_id` may be None for the null revision, in which case
 
1083
        an `EmptyTree` is returned."""
 
1084
        # TODO: refactor this to use an existing revision object
 
1085
        # so we don't need to read it in twice.
 
1086
        if revision_id == None:
 
1087
            return EmptyTree()
 
1088
        else:
 
1089
            inv = self.get_revision_inventory(revision_id)
 
1090
            return RevisionTree(self.text_store, inv)
 
1091
 
 
1092
 
 
1093
    def working_tree(self):
 
1094
        """Return a `Tree` for the working copy."""
 
1095
        from workingtree import WorkingTree
 
1096
        return WorkingTree(self.base, self.read_working_inventory())
 
1097
 
 
1098
 
 
1099
    def basis_tree(self):
 
1100
        """Return `Tree` object for last revision.
 
1101
 
 
1102
        If there are no revisions yet, return an `EmptyTree`.
 
1103
        """
 
1104
        r = self.last_patch()
 
1105
        if r == None:
 
1106
            return EmptyTree()
 
1107
        else:
 
1108
            return RevisionTree(self.text_store, self.get_revision_inventory(r))
 
1109
 
 
1110
 
 
1111
 
 
1112
    def rename_one(self, from_rel, to_rel):
 
1113
        """Rename one file.
 
1114
 
 
1115
        This can change the directory or the filename or both.
 
1116
        """
 
1117
        self.lock_write()
 
1118
        try:
 
1119
            tree = self.working_tree()
 
1120
            inv = tree.inventory
 
1121
            if not tree.has_filename(from_rel):
 
1122
                raise BzrError("can't rename: old working file %r does not exist" % from_rel)
 
1123
            if tree.has_filename(to_rel):
 
1124
                raise BzrError("can't rename: new working file %r already exists" % to_rel)
 
1125
 
 
1126
            file_id = inv.path2id(from_rel)
 
1127
            if file_id == None:
 
1128
                raise BzrError("can't rename: old name %r is not versioned" % from_rel)
 
1129
 
 
1130
            if inv.path2id(to_rel):
 
1131
                raise BzrError("can't rename: new name %r is already versioned" % to_rel)
 
1132
 
 
1133
            to_dir, to_tail = os.path.split(to_rel)
 
1134
            to_dir_id = inv.path2id(to_dir)
 
1135
            if to_dir_id == None and to_dir != '':
 
1136
                raise BzrError("can't determine destination directory id for %r" % to_dir)
 
1137
 
 
1138
            mutter("rename_one:")
 
1139
            mutter("  file_id    {%s}" % file_id)
 
1140
            mutter("  from_rel   %r" % from_rel)
 
1141
            mutter("  to_rel     %r" % to_rel)
 
1142
            mutter("  to_dir     %r" % to_dir)
 
1143
            mutter("  to_dir_id  {%s}" % to_dir_id)
 
1144
 
 
1145
            inv.rename(file_id, to_dir_id, to_tail)
 
1146
 
 
1147
            from_abs = self.abspath(from_rel)
 
1148
            to_abs = self.abspath(to_rel)
 
1149
            try:
 
1150
                os.rename(from_abs, to_abs)
 
1151
            except OSError, e:
 
1152
                raise BzrError("failed to rename %r to %r: %s"
 
1153
                        % (from_abs, to_abs, e[1]),
 
1154
                        ["rename rolled back"])
 
1155
 
 
1156
            self._write_inventory(inv)
 
1157
        finally:
 
1158
            self.unlock()
 
1159
 
 
1160
 
 
1161
    def move(self, from_paths, to_name):
 
1162
        """Rename files.
 
1163
 
 
1164
        to_name must exist as a versioned directory.
 
1165
 
 
1166
        If to_name exists and is a directory, the files are moved into
 
1167
        it, keeping their old names.  If it is a directory, 
 
1168
 
 
1169
        Note that to_name is only the last component of the new name;
 
1170
        this doesn't change the directory.
 
1171
 
 
1172
        This returns a list of (from_path, to_path) pairs for each
 
1173
        entry that is moved.
 
1174
        """
 
1175
        result = []
 
1176
        self.lock_write()
 
1177
        try:
 
1178
            ## TODO: Option to move IDs only
 
1179
            assert not isinstance(from_paths, basestring)
 
1180
            tree = self.working_tree()
 
1181
            inv = tree.inventory
 
1182
            to_abs = self.abspath(to_name)
 
1183
            if not isdir(to_abs):
 
1184
                raise BzrError("destination %r is not a directory" % to_abs)
 
1185
            if not tree.has_filename(to_name):
 
1186
                raise BzrError("destination %r not in working directory" % to_abs)
 
1187
            to_dir_id = inv.path2id(to_name)
 
1188
            if to_dir_id == None and to_name != '':
 
1189
                raise BzrError("destination %r is not a versioned directory" % to_name)
 
1190
            to_dir_ie = inv[to_dir_id]
 
1191
            if to_dir_ie.kind not in ('directory', 'root_directory'):
 
1192
                raise BzrError("destination %r is not a directory" % to_abs)
 
1193
 
 
1194
            to_idpath = inv.get_idpath(to_dir_id)
 
1195
 
 
1196
            for f in from_paths:
 
1197
                if not tree.has_filename(f):
 
1198
                    raise BzrError("%r does not exist in working tree" % f)
 
1199
                f_id = inv.path2id(f)
 
1200
                if f_id == None:
 
1201
                    raise BzrError("%r is not versioned" % f)
 
1202
                name_tail = splitpath(f)[-1]
 
1203
                dest_path = appendpath(to_name, name_tail)
 
1204
                if tree.has_filename(dest_path):
 
1205
                    raise BzrError("destination %r already exists" % dest_path)
 
1206
                if f_id in to_idpath:
 
1207
                    raise BzrError("can't move %r to a subdirectory of itself" % f)
 
1208
 
 
1209
            # OK, so there's a race here, it's possible that someone will
 
1210
            # create a file in this interval and then the rename might be
 
1211
            # left half-done.  But we should have caught most problems.
 
1212
 
 
1213
            for f in from_paths:
 
1214
                name_tail = splitpath(f)[-1]
 
1215
                dest_path = appendpath(to_name, name_tail)
 
1216
                result.append((f, dest_path))
 
1217
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
 
1218
                try:
 
1219
                    os.rename(self.abspath(f), self.abspath(dest_path))
 
1220
                except OSError, e:
 
1221
                    raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
 
1222
                            ["rename rolled back"])
 
1223
 
 
1224
            self._write_inventory(inv)
 
1225
        finally:
 
1226
            self.unlock()
 
1227
 
 
1228
        return result
 
1229
 
 
1230
 
 
1231
    def revert(self, filenames, old_tree=None, backups=True):
 
1232
        """Restore selected files to the versions from a previous tree.
 
1233
 
 
1234
        backups
 
1235
            If true (default) backups are made of files before
 
1236
            they're renamed.
 
1237
        """
 
1238
        from bzrlib.errors import NotVersionedError, BzrError
 
1239
        from bzrlib.atomicfile import AtomicFile
 
1240
        from bzrlib.osutils import backup_file
 
1241
        
 
1242
        inv = self.read_working_inventory()
 
1243
        if old_tree is None:
 
1244
            old_tree = self.basis_tree()
 
1245
        old_inv = old_tree.inventory
 
1246
 
 
1247
        nids = []
 
1248
        for fn in filenames:
 
1249
            file_id = inv.path2id(fn)
 
1250
            if not file_id:
 
1251
                raise NotVersionedError("not a versioned file", fn)
 
1252
            if not old_inv.has_id(file_id):
 
1253
                raise BzrError("file not present in old tree", fn, file_id)
 
1254
            nids.append((fn, file_id))
 
1255
            
 
1256
        # TODO: Rename back if it was previously at a different location
 
1257
 
 
1258
        # TODO: If given a directory, restore the entire contents from
 
1259
        # the previous version.
 
1260
 
 
1261
        # TODO: Make a backup to a temporary file.
 
1262
 
 
1263
        # TODO: If the file previously didn't exist, delete it?
 
1264
        for fn, file_id in nids:
 
1265
            backup_file(fn)
 
1266
            
 
1267
            f = AtomicFile(fn, 'wb')
 
1268
            try:
 
1269
                f.write(old_tree.get_file(file_id).read())
 
1270
                f.commit()
 
1271
            finally:
 
1272
                f.close()
 
1273
 
 
1274
 
 
1275
    def pending_merges(self):
 
1276
        """Return a list of pending merges.
 
1277
 
 
1278
        These are revisions that have been merged into the working
 
1279
        directory but not yet committed.
 
1280
        """
 
1281
        cfn = self.controlfilename('pending-merges')
 
1282
        if not os.path.exists(cfn):
 
1283
            return []
 
1284
        p = []
 
1285
        for l in self.controlfile('pending-merges', 'r').readlines():
 
1286
            p.append(l.rstrip('\n'))
 
1287
        return p
 
1288
 
 
1289
 
 
1290
    def add_pending_merge(self, revision_id):
 
1291
        from bzrlib.revision import validate_revision_id
 
1292
 
 
1293
        validate_revision_id(revision_id)
 
1294
 
 
1295
        p = self.pending_merges()
 
1296
        if revision_id in p:
 
1297
            return
 
1298
        p.append(revision_id)
 
1299
        self.set_pending_merges(p)
 
1300
 
 
1301
 
 
1302
    def set_pending_merges(self, rev_list):
 
1303
        from bzrlib.atomicfile import AtomicFile
 
1304
        self.lock_write()
 
1305
        try:
 
1306
            f = AtomicFile(self.controlfilename('pending-merges'))
 
1307
            try:
 
1308
                for l in rev_list:
 
1309
                    print >>f, l
 
1310
                f.commit()
 
1311
            finally:
 
1312
                f.close()
 
1313
        finally:
 
1314
            self.unlock()
 
1315
 
 
1316
 
 
1317
    def get_parent(self):
 
1318
        """Return the parent location of the branch.
 
1319
 
 
1320
        This is the default location for push/pull/missing.  The usual
 
1321
        pattern is that the user can override it by specifying a
 
1322
        location.
 
1323
        """
 
1324
        import errno
 
1325
        _locs = ['parent', 'pull', 'x-pull']
 
1326
        for l in _locs:
 
1327
            try:
 
1328
                return self.controlfile(l, 'r').read().strip('\n')
 
1329
            except IOError, e:
 
1330
                if e.errno != errno.ENOENT:
 
1331
                    raise
 
1332
        return None
 
1333
 
 
1334
 
 
1335
    def set_parent(self, url):
 
1336
        # TODO: Maybe delete old location files?
 
1337
        from bzrlib.atomicfile import AtomicFile
 
1338
        self.lock_write()
 
1339
        try:
 
1340
            f = AtomicFile(self.controlfilename('parent'))
 
1341
            try:
 
1342
                f.write(url + '\n')
 
1343
                f.commit()
 
1344
            finally:
 
1345
                f.close()
 
1346
        finally:
 
1347
            self.unlock()
 
1348
 
 
1349
    def check_revno(self, revno):
 
1350
        """\
 
1351
        Check whether a revno corresponds to any revision.
 
1352
        Zero (the NULL revision) is considered valid.
 
1353
        """
 
1354
        if revno != 0:
 
1355
            self.check_real_revno(revno)
 
1356
            
 
1357
    def check_real_revno(self, revno):
 
1358
        """\
 
1359
        Check whether a revno corresponds to a real revision.
 
1360
        Zero (the NULL revision) is considered invalid
 
1361
        """
 
1362
        if revno < 1 or revno > self.revno():
 
1363
            raise InvalidRevisionNumber(revno)
 
1364
        
 
1365
        
 
1366
 
 
1367
 
 
1368
class ScratchBranch(Branch):
 
1369
    """Special test class: a branch that cleans up after itself.
 
1370
 
 
1371
    >>> b = ScratchBranch()
 
1372
    >>> isdir(b.base)
 
1373
    True
 
1374
    >>> bd = b.base
 
1375
    >>> b.destroy()
 
1376
    >>> isdir(bd)
 
1377
    False
 
1378
    """
 
1379
    def __init__(self, files=[], dirs=[], base=None):
 
1380
        """Make a test branch.
 
1381
 
 
1382
        This creates a temporary directory and runs init-tree in it.
 
1383
 
 
1384
        If any files are listed, they are created in the working copy.
 
1385
        """
 
1386
        from tempfile import mkdtemp
 
1387
        init = False
 
1388
        if base is None:
 
1389
            base = mkdtemp()
 
1390
            init = True
 
1391
        Branch.__init__(self, base, init=init)
 
1392
        for d in dirs:
 
1393
            os.mkdir(self.abspath(d))
 
1394
            
 
1395
        for f in files:
 
1396
            file(os.path.join(self.base, f), 'w').write('content of %s' % f)
 
1397
 
 
1398
 
 
1399
    def clone(self):
 
1400
        """
 
1401
        >>> orig = ScratchBranch(files=["file1", "file2"])
 
1402
        >>> clone = orig.clone()
 
1403
        >>> os.path.samefile(orig.base, clone.base)
 
1404
        False
 
1405
        >>> os.path.isfile(os.path.join(clone.base, "file1"))
 
1406
        True
 
1407
        """
 
1408
        from shutil import copytree
 
1409
        from tempfile import mkdtemp
 
1410
        base = mkdtemp()
 
1411
        os.rmdir(base)
 
1412
        copytree(self.base, base, symlinks=True)
 
1413
        return ScratchBranch(base=base)
 
1414
 
 
1415
 
 
1416
        
 
1417
    def __del__(self):
 
1418
        self.destroy()
 
1419
 
 
1420
    def destroy(self):
 
1421
        """Destroy the test branch, removing the scratch directory."""
 
1422
        from shutil import rmtree
 
1423
        try:
 
1424
            if self.base:
 
1425
                mutter("delete ScratchBranch %s" % self.base)
 
1426
                rmtree(self.base)
 
1427
        except OSError, e:
 
1428
            # Work around for shutil.rmtree failing on Windows when
 
1429
            # readonly files are encountered
 
1430
            mutter("hit exception in destroying ScratchBranch: %s" % e)
 
1431
            for root, dirs, files in os.walk(self.base, topdown=False):
 
1432
                for name in files:
 
1433
                    os.chmod(os.path.join(root, name), 0700)
 
1434
            rmtree(self.base)
 
1435
        self.base = None
 
1436
 
 
1437
    
 
1438
 
 
1439
######################################################################
 
1440
# predicates
 
1441
 
 
1442
 
 
1443
def is_control_file(filename):
 
1444
    ## FIXME: better check
 
1445
    filename = os.path.normpath(filename)
 
1446
    while filename != '':
 
1447
        head, tail = os.path.split(filename)
 
1448
        ## mutter('check %r for control file' % ((head, tail), ))
 
1449
        if tail == bzrlib.BZRDIR:
 
1450
            return True
 
1451
        if filename == head:
 
1452
            break
 
1453
        filename = head
 
1454
    return False
 
1455
 
 
1456
 
 
1457
 
 
1458
def gen_file_id(name):
 
1459
    """Return new file id.
 
1460
 
 
1461
    This should probably generate proper UUIDs, but for the moment we
 
1462
    cope with just randomness because running uuidgen every time is
 
1463
    slow."""
 
1464
    import re
 
1465
    from binascii import hexlify
 
1466
    from time import time
 
1467
 
 
1468
    # get last component
 
1469
    idx = name.rfind('/')
 
1470
    if idx != -1:
 
1471
        name = name[idx+1 : ]
 
1472
    idx = name.rfind('\\')
 
1473
    if idx != -1:
 
1474
        name = name[idx+1 : ]
 
1475
 
 
1476
    # make it not a hidden file
 
1477
    name = name.lstrip('.')
 
1478
 
 
1479
    # remove any wierd characters; we don't escape them but rather
 
1480
    # just pull them out
 
1481
    name = re.sub(r'[^\w.]', '', name)
 
1482
 
 
1483
    s = hexlify(rand_bytes(8))
 
1484
    return '-'.join((name, compact_date(time()), s))
 
1485
 
 
1486
 
 
1487
def gen_root_id():
 
1488
    """Return a new tree-root file id."""
 
1489
    return gen_file_id('TREE_ROOT')
 
1490
 
 
1491
 
 
1492
def pull_loc(branch):
 
1493
    # TODO: Should perhaps just make attribute be 'base' in
 
1494
    # RemoteBranch and Branch?
 
1495
    if hasattr(branch, "baseurl"):
 
1496
        return branch.baseurl
 
1497
    else:
 
1498
        return branch.base
 
1499
 
 
1500
 
 
1501
def copy_branch(branch_from, to_location, revision=None):
 
1502
    """Copy branch_from into the existing directory to_location.
 
1503
 
 
1504
    revision
 
1505
        If not None, only revisions up to this point will be copied.
 
1506
        The head of the new branch will be that revision.
 
1507
 
 
1508
    to_location
 
1509
        The name of a local directory that exists but is empty.
 
1510
    """
 
1511
    from bzrlib.merge import merge
 
1512
    from bzrlib.branch import Branch
 
1513
 
 
1514
    assert isinstance(branch_from, Branch)
 
1515
    assert isinstance(to_location, basestring)
 
1516
    
 
1517
    br_to = Branch(to_location, init=True)
 
1518
    br_to.set_root_id(branch_from.get_root_id())
 
1519
    if revision is None:
 
1520
        revno = branch_from.revno()
 
1521
    else:
 
1522
        revno, rev_id = branch_from.get_revision_info(revision)
 
1523
    br_to.update_revisions(branch_from, stop_revision=revno)
 
1524
    merge((to_location, -1), (to_location, 0), this_dir=to_location,
 
1525
          check_clean=False, ignore_zero=True)
 
1526
    
 
1527
    from_location = pull_loc(branch_from)
 
1528
    br_to.set_parent(pull_loc(branch_from))