/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 16:17:20 UTC
  • mto: (1092.3.1)
  • mto: This revision was merged to the branch mainline in revision 1397.
  • Revision ID: robertc@robertcollins.net-20050906161719-a1e89946ae641bce
improve a docstring

Show diffs side-by-side

added added

removed removed

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