/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: Lalo Martins
  • Date: 2005-09-07 08:20:27 UTC
  • mto: (1185.1.5)
  • mto: This revision was merged to the branch mainline in revision 1390.
  • Revision ID: lalo@exoweb.net-20050907082026-401ea0f66d26dcca
moving DivergedBranches from bzrlib.branch to bzrlib.errors, obeying:
# XXX: move into bzrlib.errors; subclass BzrError

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
     DivergedBranches
 
29
import bzrlib.errors
 
30
from bzrlib.textui import show_status
 
31
from bzrlib.revision import Revision
 
32
from bzrlib.delta import compare_trees
 
33
from bzrlib.tree import EmptyTree, RevisionTree
 
34
import bzrlib.xml
 
35
import bzrlib.ui
 
36
 
 
37
 
 
38
 
 
39
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
 
40
## TODO: Maybe include checks for common corruption of newlines, etc?
 
41
 
 
42
 
 
43
# TODO: Some operations like log might retrieve the same revisions
 
44
# repeatedly to calculate deltas.  We could perhaps have a weakref
 
45
# cache in memory to make this faster.
 
46
 
 
47
# TODO: please move the revision-string syntax stuff out of the branch
 
48
# object; it's clutter
 
49
 
 
50
 
 
51
def find_branch(f, **args):
 
52
    if f and (f.startswith('http://') or f.startswith('https://')):
 
53
        import remotebranch 
 
54
        return remotebranch.RemoteBranch(f, **args)
 
55
    else:
 
56
        return Branch(f, **args)
 
57
 
 
58
 
 
59
def find_cached_branch(f, cache_root, **args):
 
60
    from remotebranch import RemoteBranch
 
61
    br = find_branch(f, **args)
 
62
    def cacheify(br, store_name):
 
63
        from meta_store import CachedStore
 
64
        cache_path = os.path.join(cache_root, store_name)
 
65
        os.mkdir(cache_path)
 
66
        new_store = CachedStore(getattr(br, store_name), cache_path)
 
67
        setattr(br, store_name, new_store)
 
68
 
 
69
    if isinstance(br, RemoteBranch):
 
70
        cacheify(br, 'inventory_store')
 
71
        cacheify(br, 'text_store')
 
72
        cacheify(br, 'revision_store')
 
73
    return br
 
74
 
 
75
 
 
76
def _relpath(base, path):
 
77
    """Return path relative to base, or raise exception.
 
78
 
 
79
    The path may be either an absolute path or a path relative to the
 
80
    current working directory.
 
81
 
 
82
    Lifted out of Branch.relpath for ease of testing.
 
83
 
 
84
    os.path.commonprefix (python2.4) has a bad bug that it works just
 
85
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
 
86
    avoids that problem."""
 
87
    rp = os.path.abspath(path)
 
88
 
 
89
    s = []
 
90
    head = rp
 
91
    while len(head) >= len(base):
 
92
        if head == base:
 
93
            break
 
94
        head, tail = os.path.split(head)
 
95
        if tail:
 
96
            s.insert(0, tail)
 
97
    else:
 
98
        from errors import NotBranchError
 
99
        raise NotBranchError("path %r is not within branch %r" % (rp, base))
 
100
 
 
101
    return os.sep.join(s)
 
102
        
 
103
 
 
104
def find_branch_root(f=None):
 
105
    """Find the branch root enclosing f, or pwd.
 
106
 
 
107
    f may be a filename or a URL.
 
108
 
 
109
    It is not necessary that f exists.
 
110
 
 
111
    Basically we keep looking up until we find the control directory or
 
112
    run into the root.  If there isn't one, raises NotBranchError.
 
113
    """
 
114
    if f == None:
 
115
        f = os.getcwd()
 
116
    elif hasattr(os.path, 'realpath'):
 
117
        f = os.path.realpath(f)
 
118
    else:
 
119
        f = os.path.abspath(f)
 
120
    if not os.path.exists(f):
 
121
        raise BzrError('%r does not exist' % f)
 
122
        
 
123
 
 
124
    orig_f = f
 
125
 
 
126
    while True:
 
127
        if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
 
128
            return f
 
129
        head, tail = os.path.split(f)
 
130
        if head == f:
 
131
            # reached the root, whatever that may be
 
132
            raise bzrlib.errors.NotBranchError('%s is not in a branch' % orig_f)
 
133
        f = head
 
134
 
 
135
 
 
136
 
 
137
 
 
138
######################################################################
 
139
# branch objects
 
140
 
 
141
class Branch(object):
 
142
    """Branch holding a history of revisions.
 
143
 
 
144
    base
 
145
        Base directory of the branch.
 
146
 
 
147
    _lock_mode
 
148
        None, or 'r' or 'w'
 
149
 
 
150
    _lock_count
 
151
        If _lock_mode is true, a positive count of the number of times the
 
152
        lock has been taken.
 
153
 
 
154
    _lock
 
155
        Lock object from bzrlib.lock.
 
156
    """
 
157
    base = None
 
158
    _lock_mode = None
 
159
    _lock_count = None
 
160
    _lock = None
 
161
    
 
162
    # Map some sort of prefix into a namespace
 
163
    # stuff like "revno:10", "revid:", etc.
 
164
    # This should match a prefix with a function which accepts
 
165
    REVISION_NAMESPACES = {}
 
166
 
 
167
    def __init__(self, base, init=False, find_root=True):
 
168
        """Create new branch object at a particular location.
 
169
 
 
170
        base -- Base directory for the branch.
 
171
        
 
172
        init -- If True, create new control files in a previously
 
173
             unversioned directory.  If False, the branch must already
 
174
             be versioned.
 
175
 
 
176
        find_root -- If true and init is false, find the root of the
 
177
             existing branch containing base.
 
178
 
 
179
        In the test suite, creation of new trees is tested using the
 
180
        `ScratchBranch` class.
 
181
        """
 
182
        from bzrlib.store import ImmutableStore
 
183
        if init:
 
184
            self.base = os.path.realpath(base)
 
185
            self._make_control()
 
186
        elif find_root:
 
187
            self.base = find_branch_root(base)
 
188
        else:
 
189
            self.base = os.path.realpath(base)
 
190
            if not isdir(self.controlfilename('.')):
 
191
                from errors import NotBranchError
 
192
                raise NotBranchError("not a bzr branch: %s" % quotefn(base),
 
193
                                     ['use "bzr init" to initialize a new working tree',
 
194
                                      'current bzr can only operate from top-of-tree'])
 
195
        self._check_format()
 
196
 
 
197
        self.text_store = ImmutableStore(self.controlfilename('text-store'))
 
198
        self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
 
199
        self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
 
200
 
 
201
 
 
202
    def __str__(self):
 
203
        return '%s(%r)' % (self.__class__.__name__, self.base)
 
204
 
 
205
 
 
206
    __repr__ = __str__
 
207
 
 
208
 
 
209
    def __del__(self):
 
210
        if self._lock_mode or self._lock:
 
211
            from warnings import warn
 
212
            warn("branch %r was not explicitly unlocked" % self)
 
213
            self._lock.unlock()
 
214
 
 
215
 
 
216
    def lock_write(self):
 
217
        if self._lock_mode:
 
218
            if self._lock_mode != 'w':
 
219
                from errors import LockError
 
220
                raise LockError("can't upgrade to a write lock from %r" %
 
221
                                self._lock_mode)
 
222
            self._lock_count += 1
 
223
        else:
 
224
            from bzrlib.lock import WriteLock
 
225
 
 
226
            self._lock = WriteLock(self.controlfilename('branch-lock'))
 
227
            self._lock_mode = 'w'
 
228
            self._lock_count = 1
 
229
 
 
230
 
 
231
    def lock_read(self):
 
232
        if self._lock_mode:
 
233
            assert self._lock_mode in ('r', 'w'), \
 
234
                   "invalid lock mode %r" % self._lock_mode
 
235
            self._lock_count += 1
 
236
        else:
 
237
            from bzrlib.lock import ReadLock
 
238
 
 
239
            self._lock = ReadLock(self.controlfilename('branch-lock'))
 
240
            self._lock_mode = 'r'
 
241
            self._lock_count = 1
 
242
                        
 
243
    def unlock(self):
 
244
        if not self._lock_mode:
 
245
            from errors import LockError
 
246
            raise LockError('branch %r is not locked' % (self))
 
247
 
 
248
        if self._lock_count > 1:
 
249
            self._lock_count -= 1
 
250
        else:
 
251
            self._lock.unlock()
 
252
            self._lock = None
 
253
            self._lock_mode = self._lock_count = None
 
254
 
 
255
    def abspath(self, name):
 
256
        """Return absolute filename for something in the branch"""
 
257
        return os.path.join(self.base, name)
 
258
 
 
259
    def relpath(self, path):
 
260
        """Return path relative to this branch of something inside it.
 
261
 
 
262
        Raises an error if path is not in this branch."""
 
263
        return _relpath(self.base, path)
 
264
 
 
265
    def controlfilename(self, file_or_path):
 
266
        """Return location relative to branch."""
 
267
        if isinstance(file_or_path, basestring):
 
268
            file_or_path = [file_or_path]
 
269
        return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
 
270
 
 
271
 
 
272
    def controlfile(self, file_or_path, mode='r'):
 
273
        """Open a control file for this branch.
 
274
 
 
275
        There are two classes of file in the control directory: text
 
276
        and binary.  binary files are untranslated byte streams.  Text
 
277
        control files are stored with Unix newlines and in UTF-8, even
 
278
        if the platform or locale defaults are different.
 
279
 
 
280
        Controlfiles should almost never be opened in write mode but
 
281
        rather should be atomically copied and replaced using atomicfile.
 
282
        """
 
283
 
 
284
        fn = self.controlfilename(file_or_path)
 
285
 
 
286
        if mode == 'rb' or mode == 'wb':
 
287
            return file(fn, mode)
 
288
        elif mode == 'r' or mode == 'w':
 
289
            # open in binary mode anyhow so there's no newline translation;
 
290
            # codecs uses line buffering by default; don't want that.
 
291
            import codecs
 
292
            return codecs.open(fn, mode + 'b', 'utf-8',
 
293
                               buffering=60000)
 
294
        else:
 
295
            raise BzrError("invalid controlfile mode %r" % mode)
 
296
 
 
297
    def _make_control(self):
 
298
        from bzrlib.inventory import Inventory
 
299
        
 
300
        os.mkdir(self.controlfilename([]))
 
301
        self.controlfile('README', 'w').write(
 
302
            "This is a Bazaar-NG control directory.\n"
 
303
            "Do not change any files in this directory.\n")
 
304
        self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
 
305
        for d in ('text-store', 'inventory-store', 'revision-store'):
 
306
            os.mkdir(self.controlfilename(d))
 
307
        for f in ('revision-history', 'merged-patches',
 
308
                  'pending-merged-patches', 'branch-name',
 
309
                  'branch-lock',
 
310
                  'pending-merges'):
 
311
            self.controlfile(f, 'w').write('')
 
312
        mutter('created control directory in ' + self.base)
 
313
 
 
314
        # if we want per-tree root ids then this is the place to set
 
315
        # them; they're not needed for now and so ommitted for
 
316
        # simplicity.
 
317
        f = self.controlfile('inventory','w')
 
318
        bzrlib.xml.serializer_v4.write_inventory(Inventory(), f)
 
319
 
 
320
 
 
321
    def _check_format(self):
 
322
        """Check this branch format is supported.
 
323
 
 
324
        The current tool only supports the current unstable format.
 
325
 
 
326
        In the future, we might need different in-memory Branch
 
327
        classes to support downlevel branches.  But not yet.
 
328
        """
 
329
        # This ignores newlines so that we can open branches created
 
330
        # on Windows from Linux and so on.  I think it might be better
 
331
        # to always make all internal files in unix format.
 
332
        fmt = self.controlfile('branch-format', 'r').read()
 
333
        fmt = fmt.replace('\r\n', '\n')
 
334
        if fmt != BZR_BRANCH_FORMAT:
 
335
            raise BzrError('sorry, branch format %r not supported' % fmt,
 
336
                           ['use a different bzr version',
 
337
                            'or remove the .bzr directory and "bzr init" again'])
 
338
 
 
339
    def get_root_id(self):
 
340
        """Return the id of this branches root"""
 
341
        inv = self.read_working_inventory()
 
342
        return inv.root.file_id
 
343
 
 
344
    def set_root_id(self, file_id):
 
345
        inv = self.read_working_inventory()
 
346
        orig_root_id = inv.root.file_id
 
347
        del inv._byid[inv.root.file_id]
 
348
        inv.root.file_id = file_id
 
349
        inv._byid[inv.root.file_id] = inv.root
 
350
        for fid in inv:
 
351
            entry = inv[fid]
 
352
            if entry.parent_id in (None, orig_root_id):
 
353
                entry.parent_id = inv.root.file_id
 
354
        self._write_inventory(inv)
 
355
 
 
356
    def read_working_inventory(self):
 
357
        """Read the working inventory."""
 
358
        from bzrlib.inventory import Inventory
 
359
        self.lock_read()
 
360
        try:
 
361
            # ElementTree does its own conversion from UTF-8, so open in
 
362
            # binary.
 
363
            f = self.controlfile('inventory', 'rb')
 
364
            return bzrlib.xml.serializer_v4.read_inventory(f)
 
365
        finally:
 
366
            self.unlock()
 
367
            
 
368
 
 
369
    def _write_inventory(self, inv):
 
370
        """Update the working inventory.
 
371
 
 
372
        That is to say, the inventory describing changes underway, that
 
373
        will be committed to the next revision.
 
374
        """
 
375
        from bzrlib.atomicfile import AtomicFile
 
376
        
 
377
        self.lock_write()
 
378
        try:
 
379
            f = AtomicFile(self.controlfilename('inventory'), 'wb')
 
380
            try:
 
381
                bzrlib.xml.serializer_v4.write_inventory(inv, f)
 
382
                f.commit()
 
383
            finally:
 
384
                f.close()
 
385
        finally:
 
386
            self.unlock()
 
387
        
 
388
        mutter('wrote working inventory')
 
389
            
 
390
 
 
391
    inventory = property(read_working_inventory, _write_inventory, None,
 
392
                         """Inventory for the working copy.""")
 
393
 
 
394
 
 
395
    def add(self, files, ids=None):
 
396
        """Make files versioned.
 
397
 
 
398
        Note that the command line normally calls smart_add instead,
 
399
        which can automatically recurse.
 
400
 
 
401
        This puts the files in the Added state, so that they will be
 
402
        recorded by the next commit.
 
403
 
 
404
        files
 
405
            List of paths to add, relative to the base of the tree.
 
406
 
 
407
        ids
 
408
            If set, use these instead of automatically generated ids.
 
409
            Must be the same length as the list of files, but may
 
410
            contain None for ids that are to be autogenerated.
 
411
 
 
412
        TODO: Perhaps have an option to add the ids even if the files do
 
413
              not (yet) exist.
 
414
 
 
415
        TODO: Perhaps yield the ids and paths as they're added.
 
416
        """
 
417
        # TODO: Re-adding a file that is removed in the working copy
 
418
        # should probably put it back with the previous ID.
 
419
        if isinstance(files, basestring):
 
420
            assert(ids is None or isinstance(ids, basestring))
 
421
            files = [files]
 
422
            if ids is not None:
 
423
                ids = [ids]
 
424
 
 
425
        if ids is None:
 
426
            ids = [None] * len(files)
 
427
        else:
 
428
            assert(len(ids) == len(files))
 
429
 
 
430
        self.lock_write()
 
431
        try:
 
432
            inv = self.read_working_inventory()
 
433
            for f,file_id in zip(files, ids):
 
434
                if is_control_file(f):
 
435
                    raise BzrError("cannot add control file %s" % quotefn(f))
 
436
 
 
437
                fp = splitpath(f)
 
438
 
 
439
                if len(fp) == 0:
 
440
                    raise BzrError("cannot add top-level %r" % f)
 
441
 
 
442
                fullpath = os.path.normpath(self.abspath(f))
 
443
 
 
444
                try:
 
445
                    kind = file_kind(fullpath)
 
446
                except OSError:
 
447
                    # maybe something better?
 
448
                    raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
 
449
 
 
450
                if kind != 'file' and kind != 'directory':
 
451
                    raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
 
452
 
 
453
                if file_id is None:
 
454
                    file_id = gen_file_id(f)
 
455
                inv.add_path(f, kind=kind, file_id=file_id)
 
456
 
 
457
                mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
 
458
 
 
459
            self._write_inventory(inv)
 
460
        finally:
 
461
            self.unlock()
 
462
            
 
463
 
 
464
    def print_file(self, file, revno):
 
465
        """Print `file` to stdout."""
 
466
        self.lock_read()
 
467
        try:
 
468
            tree = self.revision_tree(self.lookup_revision(revno))
 
469
            # use inventory as it was in that revision
 
470
            file_id = tree.inventory.path2id(file)
 
471
            if not file_id:
 
472
                raise BzrError("%r is not present in revision %s" % (file, revno))
 
473
            tree.print_file(file_id)
 
474
        finally:
 
475
            self.unlock()
 
476
 
 
477
 
 
478
    def remove(self, files, verbose=False):
 
479
        """Mark nominated files for removal from the inventory.
 
480
 
 
481
        This does not remove their text.  This does not run on 
 
482
 
 
483
        TODO: Refuse to remove modified files unless --force is given?
 
484
 
 
485
        TODO: Do something useful with directories.
 
486
 
 
487
        TODO: Should this remove the text or not?  Tough call; not
 
488
        removing may be useful and the user can just use use rm, and
 
489
        is the opposite of add.  Removing it is consistent with most
 
490
        other tools.  Maybe an option.
 
491
        """
 
492
        ## TODO: Normalize names
 
493
        ## TODO: Remove nested loops; better scalability
 
494
        if isinstance(files, basestring):
 
495
            files = [files]
 
496
 
 
497
        self.lock_write()
 
498
 
 
499
        try:
 
500
            tree = self.working_tree()
 
501
            inv = tree.inventory
 
502
 
 
503
            # do this before any modifications
 
504
            for f in files:
 
505
                fid = inv.path2id(f)
 
506
                if not fid:
 
507
                    raise BzrError("cannot remove unversioned file %s" % quotefn(f))
 
508
                mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
 
509
                if verbose:
 
510
                    # having remove it, it must be either ignored or unknown
 
511
                    if tree.is_ignored(f):
 
512
                        new_status = 'I'
 
513
                    else:
 
514
                        new_status = '?'
 
515
                    show_status(new_status, inv[fid].kind, quotefn(f))
 
516
                del inv[fid]
 
517
 
 
518
            self._write_inventory(inv)
 
519
        finally:
 
520
            self.unlock()
 
521
 
 
522
 
 
523
    # FIXME: this doesn't need to be a branch method
 
524
    def set_inventory(self, new_inventory_list):
 
525
        from bzrlib.inventory import Inventory, InventoryEntry
 
526
        inv = Inventory(self.get_root_id())
 
527
        for path, file_id, parent, kind in new_inventory_list:
 
528
            name = os.path.basename(path)
 
529
            if name == "":
 
530
                continue
 
531
            inv.add(InventoryEntry(file_id, name, kind, parent))
 
532
        self._write_inventory(inv)
 
533
 
 
534
 
 
535
    def unknowns(self):
 
536
        """Return all unknown files.
 
537
 
 
538
        These are files in the working directory that are not versioned or
 
539
        control files or ignored.
 
540
        
 
541
        >>> b = ScratchBranch(files=['foo', 'foo~'])
 
542
        >>> list(b.unknowns())
 
543
        ['foo']
 
544
        >>> b.add('foo')
 
545
        >>> list(b.unknowns())
 
546
        []
 
547
        >>> b.remove('foo')
 
548
        >>> list(b.unknowns())
 
549
        ['foo']
 
550
        """
 
551
        return self.working_tree().unknowns()
 
552
 
 
553
 
 
554
    def append_revision(self, *revision_ids):
 
555
        from bzrlib.atomicfile import AtomicFile
 
556
 
 
557
        for revision_id in revision_ids:
 
558
            mutter("add {%s} to revision-history" % revision_id)
 
559
 
 
560
        rev_history = self.revision_history()
 
561
        rev_history.extend(revision_ids)
 
562
 
 
563
        f = AtomicFile(self.controlfilename('revision-history'))
 
564
        try:
 
565
            for rev_id in rev_history:
 
566
                print >>f, rev_id
 
567
            f.commit()
 
568
        finally:
 
569
            f.close()
 
570
 
 
571
 
 
572
    def get_revision_xml_file(self, revision_id):
 
573
        """Return XML file object for revision object."""
 
574
        if not revision_id or not isinstance(revision_id, basestring):
 
575
            raise InvalidRevisionId(revision_id)
 
576
 
 
577
        self.lock_read()
 
578
        try:
 
579
            try:
 
580
                return self.revision_store[revision_id]
 
581
            except IndexError:
 
582
                raise bzrlib.errors.NoSuchRevision(self, revision_id)
 
583
        finally:
 
584
            self.unlock()
 
585
 
 
586
 
 
587
    #deprecated
 
588
    get_revision_xml = get_revision_xml_file
 
589
 
 
590
 
 
591
    def get_revision(self, revision_id):
 
592
        """Return the Revision object for a named revision"""
 
593
        xml_file = self.get_revision_xml_file(revision_id)
 
594
 
 
595
        try:
 
596
            r = bzrlib.xml.serializer_v4.read_revision(xml_file)
 
597
        except SyntaxError, e:
 
598
            raise bzrlib.errors.BzrError('failed to unpack revision_xml',
 
599
                                         [revision_id,
 
600
                                          str(e)])
 
601
            
 
602
        assert r.revision_id == revision_id
 
603
        return r
 
604
 
 
605
 
 
606
    def get_revision_delta(self, revno):
 
607
        """Return the delta for one revision.
 
608
 
 
609
        The delta is relative to its mainline predecessor, or the
 
610
        empty tree for revision 1.
 
611
        """
 
612
        assert isinstance(revno, int)
 
613
        rh = self.revision_history()
 
614
        if not (1 <= revno <= len(rh)):
 
615
            raise InvalidRevisionNumber(revno)
 
616
 
 
617
        # revno is 1-based; list is 0-based
 
618
 
 
619
        new_tree = self.revision_tree(rh[revno-1])
 
620
        if revno == 1:
 
621
            old_tree = EmptyTree()
 
622
        else:
 
623
            old_tree = self.revision_tree(rh[revno-2])
 
624
 
 
625
        return compare_trees(old_tree, new_tree)
 
626
 
 
627
        
 
628
 
 
629
    def get_revision_sha1(self, revision_id):
 
630
        """Hash the stored value of a revision, and return it."""
 
631
        # In the future, revision entries will be signed. At that
 
632
        # point, it is probably best *not* to include the signature
 
633
        # in the revision hash. Because that lets you re-sign
 
634
        # the revision, (add signatures/remove signatures) and still
 
635
        # have all hash pointers stay consistent.
 
636
        # But for now, just hash the contents.
 
637
        return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
 
638
 
 
639
 
 
640
    def get_inventory(self, inventory_id):
 
641
        """Get Inventory object by hash.
 
642
 
 
643
        TODO: Perhaps for this and similar methods, take a revision
 
644
               parameter which can be either an integer revno or a
 
645
               string hash."""
 
646
        from bzrlib.inventory import Inventory
 
647
 
 
648
        f = self.get_inventory_xml_file(inventory_id)
 
649
        return bzrlib.xml.serializer_v4.read_inventory(f)
 
650
 
 
651
 
 
652
    def get_inventory_xml(self, inventory_id):
 
653
        """Get inventory XML as a file object."""
 
654
        return self.inventory_store[inventory_id]
 
655
 
 
656
    get_inventory_xml_file = get_inventory_xml
 
657
            
 
658
 
 
659
    def get_inventory_sha1(self, inventory_id):
 
660
        """Return the sha1 hash of the inventory entry
 
661
        """
 
662
        return sha_file(self.get_inventory_xml(inventory_id))
 
663
 
 
664
 
 
665
    def get_revision_inventory(self, revision_id):
 
666
        """Return inventory of a past revision."""
 
667
        # bzr 0.0.6 imposes the constraint that the inventory_id
 
668
        # must be the same as its revision, so this is trivial.
 
669
        if revision_id == None:
 
670
            from bzrlib.inventory import Inventory
 
671
            return Inventory(self.get_root_id())
 
672
        else:
 
673
            return self.get_inventory(revision_id)
 
674
 
 
675
 
 
676
    def revision_history(self):
 
677
        """Return sequence of revision hashes on to this branch.
 
678
 
 
679
        >>> ScratchBranch().revision_history()
 
680
        []
 
681
        """
 
682
        self.lock_read()
 
683
        try:
 
684
            return [l.rstrip('\r\n') for l in
 
685
                    self.controlfile('revision-history', 'r').readlines()]
 
686
        finally:
 
687
            self.unlock()
 
688
 
 
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))
 
1525