/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-05-31 08:10:44 UTC
  • Revision ID: mbp@sourcefrog.net-20050531081044-0f6d28e39b8e19de
- replace Branch.lock(mode) with separate lock_read and lock_write 
  methods

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/branch.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
 
import sys
19
 
import os
 
18
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
 
19
import traceback, socket, fnmatch, difflib, time
 
20
from binascii import hexlify
20
21
 
21
22
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
 
        
 
23
from inventory import Inventory
 
24
from trace import mutter, note
 
25
from tree import Tree, EmptyTree, RevisionTree
 
26
from inventory import InventoryEntry, Inventory
 
27
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
 
28
     format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
 
29
     joinpath, sha_string, file_kind, local_time_offset, appendpath
 
30
from store import ImmutableStore
 
31
from revision import Revision
 
32
from errors import BzrError
 
33
from textui import show_status
 
34
 
34
35
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
35
36
## TODO: Maybe include checks for common corruption of newlines, etc?
36
37
 
37
38
 
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
39
 
43
40
def find_branch(f, **args):
44
41
    if f and (f.startswith('http://') or f.startswith('https://')):
48
45
        return Branch(f, **args)
49
46
 
50
47
 
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
 
48
 
 
49
def with_writelock(method):
 
50
    """Method decorator for functions run with the branch locked."""
 
51
    def d(self, *a, **k):
 
52
        # called with self set to the branch
 
53
        self.lock_write()
 
54
        try:
 
55
            return method(self, *a, **k)
 
56
        finally:
 
57
            self.unlock()
 
58
    return d
 
59
 
 
60
 
 
61
def with_readlock(method):
 
62
    def d(self, *a, **k):
 
63
        self.lock_read()
 
64
        try:
 
65
            return method(self, *a, **k)
 
66
        finally:
 
67
            self.unlock()
 
68
    return d
66
69
 
67
70
 
68
71
def _relpath(base, path):
123
126
            raise BzrError('%r is not in a branch' % orig_f)
124
127
        f = head
125
128
    
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
129
 
132
130
 
133
131
######################################################################
146
144
        If _lock_mode is true, a positive count of the number of times the
147
145
        lock has been taken.
148
146
 
149
 
    _lock
150
 
        Lock object from bzrlib.lock.
 
147
    _lockfile
 
148
        Open file used for locking.
151
149
    """
152
150
    base = None
153
151
    _lock_mode = None
154
152
    _lock_count = None
155
 
    _lock = None
156
153
    
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
154
    def __init__(self, base, init=False, find_root=True):
163
155
        """Create new branch object at a particular location.
164
156
 
174
166
        In the test suite, creation of new trees is tested using the
175
167
        `ScratchBranch` class.
176
168
        """
177
 
        from bzrlib.store import ImmutableStore
178
169
        if init:
179
170
            self.base = os.path.realpath(base)
180
171
            self._make_control()
188
179
                                     ['use "bzr init" to initialize a new working tree',
189
180
                                      'current bzr can only operate from top-of-tree'])
190
181
        self._check_format()
 
182
        self._lockfile = self.controlfile('branch-lock', 'wb')
191
183
 
192
184
        self.text_store = ImmutableStore(self.controlfilename('text-store'))
193
185
        self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
202
194
 
203
195
 
204
196
    def __del__(self):
205
 
        if self._lock_mode or self._lock:
 
197
        if self._lock_mode:
206
198
            from warnings import warn
207
199
            warn("branch %r was not explicitly unlocked" % self)
208
 
            self._lock.unlock()
 
200
            self.unlock()
209
201
 
210
202
 
211
203
 
217
209
                                self._lock_mode)
218
210
            self._lock_count += 1
219
211
        else:
220
 
            from bzrlib.lock import WriteLock
 
212
            from bzrlib.lock import lock, LOCK_EX
221
213
 
222
 
            self._lock = WriteLock(self.controlfilename('branch-lock'))
 
214
            lock(self._lockfile, LOCK_EX)
223
215
            self._lock_mode = 'w'
224
216
            self._lock_count = 1
225
217
 
231
223
                   "invalid lock mode %r" % self._lock_mode
232
224
            self._lock_count += 1
233
225
        else:
234
 
            from bzrlib.lock import ReadLock
 
226
            from bzrlib.lock import lock, LOCK_SH
235
227
 
236
 
            self._lock = ReadLock(self.controlfilename('branch-lock'))
 
228
            lock(self._lockfile, LOCK_SH)
237
229
            self._lock_mode = 'r'
238
230
            self._lock_count = 1
239
231
                        
247
239
        if self._lock_count > 1:
248
240
            self._lock_count -= 1
249
241
        else:
250
 
            self._lock.unlock()
251
 
            self._lock = None
 
242
            assert self._lock_count == 1
 
243
            from bzrlib.lock import unlock
 
244
            unlock(self._lockfile)
252
245
            self._lock_mode = self._lock_count = None
253
246
 
254
247
 
266
259
 
267
260
    def controlfilename(self, file_or_path):
268
261
        """Return location relative to branch."""
269
 
        if isinstance(file_or_path, basestring):
 
262
        if isinstance(file_or_path, types.StringTypes):
270
263
            file_or_path = [file_or_path]
271
264
        return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
272
265
 
299
292
 
300
293
 
301
294
    def _make_control(self):
302
 
        from bzrlib.inventory import Inventory
303
 
        from bzrlib.xml import pack_xml
304
 
        
305
295
        os.mkdir(self.controlfilename([]))
306
296
        self.controlfile('README', 'w').write(
307
297
            "This is a Bazaar-NG control directory.\n"
308
 
            "Do not change any files in this directory.\n")
 
298
            "Do not change any files in this directory.")
309
299
        self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
310
300
        for d in ('text-store', 'inventory-store', 'revision-store'):
311
301
            os.mkdir(self.controlfilename(d))
312
302
        for f in ('revision-history', 'merged-patches',
313
303
                  'pending-merged-patches', 'branch-name',
314
 
                  'branch-lock',
315
 
                  'pending-merges'):
 
304
                  'branch-lock'):
316
305
            self.controlfile(f, 'w').write('')
317
306
        mutter('created control directory in ' + self.base)
318
 
 
319
 
        pack_xml(Inventory(gen_root_id()), self.controlfile('inventory','w'))
 
307
        Inventory().write_xml(self.controlfile('inventory','w'))
320
308
 
321
309
 
322
310
    def _check_format(self):
337
325
                           ['use a different bzr version',
338
326
                            'or remove the .bzr directory and "bzr init" again'])
339
327
 
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
 
 
 
328
 
 
329
 
 
330
    @with_readlock
357
331
    def read_working_inventory(self):
358
332
        """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()
 
333
        before = time.time()
 
334
        # ElementTree does its own conversion from UTF-8, so open in
 
335
        # binary.
 
336
        inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
 
337
        mutter("loaded inventory of %d items in %f"
 
338
               % (len(inv), time.time() - before))
 
339
        return inv
374
340
            
375
341
 
376
342
    def _write_inventory(self, inv):
379
345
        That is to say, the inventory describing changes underway, that
380
346
        will be committed to the next revision.
381
347
        """
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
 
        
 
348
        ## TODO: factor out to atomicfile?  is rename safe on windows?
 
349
        ## TODO: Maybe some kind of clean/dirty marker on inventory?
 
350
        tmpfname = self.controlfilename('inventory.tmp')
 
351
        tmpf = file(tmpfname, 'wb')
 
352
        inv.write_xml(tmpf)
 
353
        tmpf.close()
 
354
        inv_fname = self.controlfilename('inventory')
 
355
        if sys.platform == 'win32':
 
356
            os.remove(inv_fname)
 
357
        os.rename(tmpfname, inv_fname)
396
358
        mutter('wrote working inventory')
397
359
            
398
360
 
400
362
                         """Inventory for the working copy.""")
401
363
 
402
364
 
 
365
    @with_writelock
403
366
    def add(self, files, verbose=False, ids=None):
404
367
        """Make files versioned.
405
368
 
428
391
        """
429
392
        # TODO: Re-adding a file that is removed in the working copy
430
393
        # should probably put it back with the previous ID.
431
 
        if isinstance(files, basestring):
432
 
            assert(ids is None or isinstance(ids, basestring))
 
394
        if isinstance(files, types.StringTypes):
 
395
            assert(ids is None or isinstance(ids, types.StringTypes))
433
396
            files = [files]
434
397
            if ids is not None:
435
398
                ids = [ids]
439
402
        else:
440
403
            assert(len(ids) == len(files))
441
404
 
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()
 
405
        inv = self.read_working_inventory()
 
406
        for f,file_id in zip(files, ids):
 
407
            if is_control_file(f):
 
408
                raise BzrError("cannot add control file %s" % quotefn(f))
 
409
 
 
410
            fp = splitpath(f)
 
411
 
 
412
            if len(fp) == 0:
 
413
                raise BzrError("cannot add top-level %r" % f)
 
414
 
 
415
            fullpath = os.path.normpath(self.abspath(f))
 
416
 
 
417
            try:
 
418
                kind = file_kind(fullpath)
 
419
            except OSError:
 
420
                # maybe something better?
 
421
                raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
 
422
 
 
423
            if kind != 'file' and kind != 'directory':
 
424
                raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
 
425
 
 
426
            if file_id is None:
 
427
                file_id = gen_file_id(f)
 
428
            inv.add_path(f, kind=kind, file_id=file_id)
 
429
 
 
430
            if verbose:
 
431
                show_status('A', kind, quotefn(f))
 
432
 
 
433
            mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
 
434
 
 
435
        self._write_inventory(inv)
477
436
            
478
437
 
479
438
    def print_file(self, file, revno):
480
439
        """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
 
 
 
440
        tree = self.revision_tree(self.lookup_revision(revno))
 
441
        # use inventory as it was in that revision
 
442
        file_id = tree.inventory.path2id(file)
 
443
        if not file_id:
 
444
            raise BzrError("%r is not present in revision %d" % (file, revno))
 
445
        tree.print_file(file_id)
 
446
 
 
447
 
 
448
    @with_writelock
493
449
    def remove(self, files, verbose=False):
494
450
        """Mark nominated files for removal from the inventory.
495
451
 
506
462
        """
507
463
        ## TODO: Normalize names
508
464
        ## TODO: Remove nested loops; better scalability
509
 
        if isinstance(files, basestring):
 
465
        if isinstance(files, types.StringTypes):
510
466
            files = [files]
511
467
 
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
 
468
        tree = self.working_tree()
 
469
        inv = tree.inventory
 
470
 
 
471
        # do this before any modifications
 
472
        for f in files:
 
473
            fid = inv.path2id(f)
 
474
            if not fid:
 
475
                raise BzrError("cannot remove unversioned file %s" % quotefn(f))
 
476
            mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
 
477
            if verbose:
 
478
                # having remove it, it must be either ignored or unknown
 
479
                if tree.is_ignored(f):
 
480
                    new_status = 'I'
 
481
                else:
 
482
                    new_status = '?'
 
483
                show_status(new_status, inv[fid].kind, quotefn(f))
 
484
            del inv[fid]
 
485
 
 
486
        self._write_inventory(inv)
 
487
 
 
488
 
539
489
    def set_inventory(self, new_inventory_list):
540
 
        from bzrlib.inventory import Inventory, InventoryEntry
541
 
        inv = Inventory(self.get_root_id())
 
490
        inv = Inventory()
542
491
        for path, file_id, parent, kind in new_inventory_list:
543
492
            name = os.path.basename(path)
544
493
            if name == "":
566
515
        return self.working_tree().unknowns()
567
516
 
568
517
 
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
 
 
 
518
    def append_revision(self, revision_id):
 
519
        mutter("add {%s} to revision-history" % revision_id)
575
520
        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()
 
521
 
 
522
        tmprhname = self.controlfilename('revision-history.tmp')
 
523
        rhname = self.controlfilename('revision-history')
 
524
        
 
525
        f = file(tmprhname, 'wt')
 
526
        rev_history.append(revision_id)
 
527
        f.write('\n'.join(rev_history))
 
528
        f.write('\n')
 
529
        f.close()
 
530
 
 
531
        if sys.platform == 'win32':
 
532
            os.remove(rhname)
 
533
        os.rename(tmprhname, rhname)
 
534
        
600
535
 
601
536
 
602
537
    def get_revision(self, revision_id):
603
538
        """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
 
            
 
539
        r = Revision.read_xml(self.revision_store[revision_id])
613
540
        assert r.revision_id == revision_id
614
541
        return r
615
542
 
616
543
 
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
544
    def get_inventory(self, inventory_id):
652
545
        """Get Inventory object by hash.
653
546
 
654
547
        TODO: Perhaps for this and similar methods, take a revision
655
548
               parameter which can be either an integer revno or a
656
549
               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])
 
550
        i = Inventory.read_xml(self.inventory_store[inventory_id])
 
551
        return i
667
552
 
668
553
 
669
554
    def get_revision_inventory(self, revision_id):
670
555
        """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
556
        if revision_id == None:
674
 
            from bzrlib.inventory import Inventory
675
 
            return Inventory(self.get_root_id())
 
557
            return Inventory()
676
558
        else:
677
 
            return self.get_inventory(revision_id)
678
 
 
679
 
 
 
559
            return self.get_inventory(self.get_revision(revision_id).inventory_id)
 
560
 
 
561
 
 
562
    @with_readlock
680
563
    def revision_history(self):
681
564
        """Return sequence of revision hashes on to this branch.
682
565
 
683
566
        >>> ScratchBranch().revision_history()
684
567
        []
685
568
        """
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
 
569
        return [l.rstrip('\r\n') for l in self.controlfile('revision-history', 'r').readlines()]
 
570
 
 
571
 
 
572
    def enum_history(self, direction):
 
573
        """Return (revno, revision_id) for history of branch.
 
574
 
 
575
        direction
 
576
            'forward' is from earliest to latest
 
577
            'reverse' is from latest to earliest
 
578
        """
 
579
        rh = self.revision_history()
 
580
        if direction == 'forward':
 
581
            i = 1
 
582
            for rid in rh:
 
583
                yield i, rid
 
584
                i += 1
 
585
        elif direction == 'reverse':
 
586
            i = len(rh)
 
587
            while i > 0:
 
588
                yield i, rh[i-1]
 
589
                i -= 1
 
590
        else:
 
591
            raise ValueError('invalid history direction', direction)
737
592
 
738
593
 
739
594
    def revno(self):
755
610
            return None
756
611
 
757
612
 
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
613
    def commit(self, *args, **kw):
 
614
        """Deprecated"""
871
615
        from bzrlib.commit import commit
872
616
        commit(self, *args, **kw)
873
617
        
874
618
 
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
 
619
    def lookup_revision(self, revno):
 
620
        """Return revision hash for revision number."""
 
621
        if revno == 0:
 
622
            return None
 
623
 
 
624
        try:
 
625
            # list is 0-based; revisions are 1-based
 
626
            return self.revision_history()[revno-1]
 
627
        except IndexError:
 
628
            raise BzrError("no such revision %s" % revno)
 
629
 
1032
630
 
1033
631
    def revision_tree(self, revision_id):
1034
632
        """Return Tree for a revision on this branch.
1063
661
 
1064
662
 
1065
663
 
 
664
    @with_writelock
1066
665
    def rename_one(self, from_rel, to_rel):
1067
666
        """Rename one file.
1068
667
 
1069
668
        This can change the directory or the filename or both.
1070
669
        """
1071
 
        self.lock_write()
 
670
        tree = self.working_tree()
 
671
        inv = tree.inventory
 
672
        if not tree.has_filename(from_rel):
 
673
            raise BzrError("can't rename: old working file %r does not exist" % from_rel)
 
674
        if tree.has_filename(to_rel):
 
675
            raise BzrError("can't rename: new working file %r already exists" % to_rel)
 
676
 
 
677
        file_id = inv.path2id(from_rel)
 
678
        if file_id == None:
 
679
            raise BzrError("can't rename: old name %r is not versioned" % from_rel)
 
680
 
 
681
        if inv.path2id(to_rel):
 
682
            raise BzrError("can't rename: new name %r is already versioned" % to_rel)
 
683
 
 
684
        to_dir, to_tail = os.path.split(to_rel)
 
685
        to_dir_id = inv.path2id(to_dir)
 
686
        if to_dir_id == None and to_dir != '':
 
687
            raise BzrError("can't determine destination directory id for %r" % to_dir)
 
688
 
 
689
        mutter("rename_one:")
 
690
        mutter("  file_id    {%s}" % file_id)
 
691
        mutter("  from_rel   %r" % from_rel)
 
692
        mutter("  to_rel     %r" % to_rel)
 
693
        mutter("  to_dir     %r" % to_dir)
 
694
        mutter("  to_dir_id  {%s}" % to_dir_id)
 
695
 
 
696
        inv.rename(file_id, to_dir_id, to_tail)
 
697
 
 
698
        print "%s => %s" % (from_rel, to_rel)
 
699
 
 
700
        from_abs = self.abspath(from_rel)
 
701
        to_abs = self.abspath(to_rel)
1072
702
        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
 
 
 
703
            os.rename(from_abs, to_abs)
 
704
        except OSError, e:
 
705
            raise BzrError("failed to rename %r to %r: %s"
 
706
                    % (from_abs, to_abs, e[1]),
 
707
                    ["rename rolled back"])
 
708
 
 
709
        self._write_inventory(inv)
 
710
 
 
711
 
 
712
 
 
713
    @with_writelock
1117
714
    def move(self, from_paths, to_name):
1118
715
        """Rename files.
1119
716
 
1125
722
        Note that to_name is only the last component of the new name;
1126
723
        this doesn't change the directory.
1127
724
        """
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()
 
725
        ## TODO: Option to move IDs only
 
726
        assert not isinstance(from_paths, basestring)
 
727
        tree = self.working_tree()
 
728
        inv = tree.inventory
 
729
        to_abs = self.abspath(to_name)
 
730
        if not isdir(to_abs):
 
731
            raise BzrError("destination %r is not a directory" % to_abs)
 
732
        if not tree.has_filename(to_name):
 
733
            raise BzrError("destination %r not in working directory" % to_abs)
 
734
        to_dir_id = inv.path2id(to_name)
 
735
        if to_dir_id == None and to_name != '':
 
736
            raise BzrError("destination %r is not a versioned directory" % to_name)
 
737
        to_dir_ie = inv[to_dir_id]
 
738
        if to_dir_ie.kind not in ('directory', 'root_directory'):
 
739
            raise BzrError("destination %r is not a directory" % to_abs)
 
740
 
 
741
        to_idpath = inv.get_idpath(to_dir_id)
 
742
 
 
743
        for f in from_paths:
 
744
            if not tree.has_filename(f):
 
745
                raise BzrError("%r does not exist in working tree" % f)
 
746
            f_id = inv.path2id(f)
 
747
            if f_id == None:
 
748
                raise BzrError("%r is not versioned" % f)
 
749
            name_tail = splitpath(f)[-1]
 
750
            dest_path = appendpath(to_name, name_tail)
 
751
            if tree.has_filename(dest_path):
 
752
                raise BzrError("destination %r already exists" % dest_path)
 
753
            if f_id in to_idpath:
 
754
                raise BzrError("can't move %r to a subdirectory of itself" % f)
 
755
 
 
756
        # OK, so there's a race here, it's possible that someone will
 
757
        # create a file in this interval and then the rename might be
 
758
        # left half-done.  But we should have caught most problems.
 
759
 
 
760
        for f in from_paths:
 
761
            name_tail = splitpath(f)[-1]
 
762
            dest_path = appendpath(to_name, name_tail)
 
763
            print "%s => %s" % (f, dest_path)
 
764
            inv.rename(inv.path2id(f), to_dir_id, name_tail)
 
765
            try:
 
766
                os.rename(self.abspath(f), self.abspath(dest_path))
 
767
            except OSError, e:
 
768
                raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
 
769
                        ["rename rolled back"])
 
770
 
 
771
        self._write_inventory(inv)
 
772
 
1265
773
 
1266
774
 
1267
775
 
1276
784
    >>> isdir(bd)
1277
785
    False
1278
786
    """
1279
 
    def __init__(self, files=[], dirs=[], base=None):
 
787
    def __init__(self, files=[], dirs=[]):
1280
788
        """Make a test branch.
1281
789
 
1282
790
        This creates a temporary directory and runs init-tree in it.
1283
791
 
1284
792
        If any files are listed, they are created in the working copy.
1285
793
        """
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)
 
794
        Branch.__init__(self, tempfile.mkdtemp(), init=True)
1292
795
        for d in dirs:
1293
796
            os.mkdir(self.abspath(d))
1294
797
            
1296
799
            file(os.path.join(self.base, f), 'w').write('content of %s' % f)
1297
800
 
1298
801
 
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
802
    def __del__(self):
1316
803
        self.destroy()
1317
804
 
1318
805
    def destroy(self):
1319
806
        """Destroy the test branch, removing the scratch directory."""
1320
 
        from shutil import rmtree
1321
807
        try:
1322
808
            if self.base:
1323
809
                mutter("delete ScratchBranch %s" % self.base)
1324
 
                rmtree(self.base)
 
810
                shutil.rmtree(self.base)
1325
811
        except OSError, e:
1326
812
            # Work around for shutil.rmtree failing on Windows when
1327
813
            # readonly files are encountered
1329
815
            for root, dirs, files in os.walk(self.base, topdown=False):
1330
816
                for name in files:
1331
817
                    os.chmod(os.path.join(root, name), 0700)
1332
 
            rmtree(self.base)
 
818
            shutil.rmtree(self.base)
1333
819
        self.base = None
1334
820
 
1335
821
    
1360
846
    cope with just randomness because running uuidgen every time is
1361
847
    slow."""
1362
848
    import re
1363
 
    from binascii import hexlify
1364
 
    from time import time
1365
849
 
1366
850
    # get last component
1367
851
    idx = name.rfind('/')
1379
863
    name = re.sub(r'[^\w.]', '', name)
1380
864
 
1381
865
    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
 
 
 
866
    return '-'.join((name, compact_date(time.time()), s))