/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Martin Pool
  • Date: 2005-08-04 22:07:31 UTC
  • Revision ID: mbp@sourcefrog.net-20050804220731-c356ad273bd1cd37
- fix up imports

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