/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-06-27 01:26:11 UTC
  • Revision ID: mbp@sourcefrog.net-20050627012611-4effb7007553fde1
- tweak rsync upload script

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, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
 
19
import traceback, socket, fnmatch, difflib, time
 
20
from binascii import hexlify
 
21
 
 
22
import bzrlib
 
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_file, 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
 
 
35
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
 
36
## TODO: Maybe include checks for common corruption of newlines, etc?
 
37
 
 
38
 
 
39
 
 
40
def find_branch(f, **args):
 
41
    if f and (f.startswith('http://') or f.startswith('https://')):
 
42
        import remotebranch 
 
43
        return remotebranch.RemoteBranch(f, **args)
 
44
    else:
 
45
        return Branch(f, **args)
 
46
 
 
47
 
 
48
 
 
49
def _relpath(base, path):
 
50
    """Return path relative to base, or raise exception.
 
51
 
 
52
    The path may be either an absolute path or a path relative to the
 
53
    current working directory.
 
54
 
 
55
    Lifted out of Branch.relpath for ease of testing.
 
56
 
 
57
    os.path.commonprefix (python2.4) has a bad bug that it works just
 
58
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
 
59
    avoids that problem."""
 
60
    rp = os.path.abspath(path)
 
61
 
 
62
    s = []
 
63
    head = rp
 
64
    while len(head) >= len(base):
 
65
        if head == base:
 
66
            break
 
67
        head, tail = os.path.split(head)
 
68
        if tail:
 
69
            s.insert(0, tail)
 
70
    else:
 
71
        from errors import NotBranchError
 
72
        raise NotBranchError("path %r is not within branch %r" % (rp, base))
 
73
 
 
74
    return os.sep.join(s)
 
75
        
 
76
 
 
77
def find_branch_root(f=None):
 
78
    """Find the branch root enclosing f, or pwd.
 
79
 
 
80
    f may be a filename or a URL.
 
81
 
 
82
    It is not necessary that f exists.
 
83
 
 
84
    Basically we keep looking up until we find the control directory or
 
85
    run into the root."""
 
86
    if f == None:
 
87
        f = os.getcwd()
 
88
    elif hasattr(os.path, 'realpath'):
 
89
        f = os.path.realpath(f)
 
90
    else:
 
91
        f = os.path.abspath(f)
 
92
    if not os.path.exists(f):
 
93
        raise BzrError('%r does not exist' % f)
 
94
        
 
95
 
 
96
    orig_f = f
 
97
 
 
98
    while True:
 
99
        if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
 
100
            return f
 
101
        head, tail = os.path.split(f)
 
102
        if head == f:
 
103
            # reached the root, whatever that may be
 
104
            raise BzrError('%r is not in a branch' % orig_f)
 
105
        f = head
 
106
    
 
107
class DivergedBranches(Exception):
 
108
    def __init__(self, branch1, branch2):
 
109
        self.branch1 = branch1
 
110
        self.branch2 = branch2
 
111
        Exception.__init__(self, "These branches have diverged.")
 
112
 
 
113
 
 
114
class NoSuchRevision(BzrError):
 
115
    def __init__(self, branch, revision):
 
116
        self.branch = branch
 
117
        self.revision = revision
 
118
        msg = "Branch %s has no revision %d" % (branch, revision)
 
119
        BzrError.__init__(self, msg)
 
120
 
 
121
 
 
122
######################################################################
 
123
# branch objects
 
124
 
 
125
class Branch(object):
 
126
    """Branch holding a history of revisions.
 
127
 
 
128
    base
 
129
        Base directory of the branch.
 
130
 
 
131
    _lock_mode
 
132
        None, or 'r' or 'w'
 
133
 
 
134
    _lock_count
 
135
        If _lock_mode is true, a positive count of the number of times the
 
136
        lock has been taken.
 
137
 
 
138
    _lock
 
139
        Lock object from bzrlib.lock.
 
140
    """
 
141
    base = None
 
142
    _lock_mode = None
 
143
    _lock_count = None
 
144
    _lock = None
 
145
    
 
146
    def __init__(self, base, init=False, find_root=True):
 
147
        """Create new branch object at a particular location.
 
148
 
 
149
        base -- Base directory for the branch.
 
150
        
 
151
        init -- If True, create new control files in a previously
 
152
             unversioned directory.  If False, the branch must already
 
153
             be versioned.
 
154
 
 
155
        find_root -- If true and init is false, find the root of the
 
156
             existing branch containing base.
 
157
 
 
158
        In the test suite, creation of new trees is tested using the
 
159
        `ScratchBranch` class.
 
160
        """
 
161
        if init:
 
162
            self.base = os.path.realpath(base)
 
163
            self._make_control()
 
164
        elif find_root:
 
165
            self.base = find_branch_root(base)
 
166
        else:
 
167
            self.base = os.path.realpath(base)
 
168
            if not isdir(self.controlfilename('.')):
 
169
                from errors import NotBranchError
 
170
                raise NotBranchError("not a bzr branch: %s" % quotefn(base),
 
171
                                     ['use "bzr init" to initialize a new working tree',
 
172
                                      'current bzr can only operate from top-of-tree'])
 
173
        self._check_format()
 
174
 
 
175
        self.text_store = ImmutableStore(self.controlfilename('text-store'))
 
176
        self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
 
177
        self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
 
178
 
 
179
 
 
180
    def __str__(self):
 
181
        return '%s(%r)' % (self.__class__.__name__, self.base)
 
182
 
 
183
 
 
184
    __repr__ = __str__
 
185
 
 
186
 
 
187
    def __del__(self):
 
188
        if self._lock_mode or self._lock:
 
189
            from warnings import warn
 
190
            warn("branch %r was not explicitly unlocked" % self)
 
191
            self._lock.unlock()
 
192
 
 
193
 
 
194
 
 
195
    def lock_write(self):
 
196
        if self._lock_mode:
 
197
            if self._lock_mode != 'w':
 
198
                from errors import LockError
 
199
                raise LockError("can't upgrade to a write lock from %r" %
 
200
                                self._lock_mode)
 
201
            self._lock_count += 1
 
202
        else:
 
203
            from bzrlib.lock import WriteLock
 
204
 
 
205
            self._lock = WriteLock(self.controlfilename('branch-lock'))
 
206
            self._lock_mode = 'w'
 
207
            self._lock_count = 1
 
208
 
 
209
 
 
210
 
 
211
    def lock_read(self):
 
212
        if self._lock_mode:
 
213
            assert self._lock_mode in ('r', 'w'), \
 
214
                   "invalid lock mode %r" % self._lock_mode
 
215
            self._lock_count += 1
 
216
        else:
 
217
            from bzrlib.lock import ReadLock
 
218
 
 
219
            self._lock = ReadLock(self.controlfilename('branch-lock'))
 
220
            self._lock_mode = 'r'
 
221
            self._lock_count = 1
 
222
                        
 
223
 
 
224
            
 
225
    def unlock(self):
 
226
        if not self._lock_mode:
 
227
            from errors import LockError
 
228
            raise LockError('branch %r is not locked' % (self))
 
229
 
 
230
        if self._lock_count > 1:
 
231
            self._lock_count -= 1
 
232
        else:
 
233
            self._lock.unlock()
 
234
            self._lock = None
 
235
            self._lock_mode = self._lock_count = None
 
236
 
 
237
 
 
238
    def abspath(self, name):
 
239
        """Return absolute filename for something in the branch"""
 
240
        return os.path.join(self.base, name)
 
241
 
 
242
 
 
243
    def relpath(self, path):
 
244
        """Return path relative to this branch of something inside it.
 
245
 
 
246
        Raises an error if path is not in this branch."""
 
247
        return _relpath(self.base, path)
 
248
 
 
249
 
 
250
    def controlfilename(self, file_or_path):
 
251
        """Return location relative to branch."""
 
252
        if isinstance(file_or_path, types.StringTypes):
 
253
            file_or_path = [file_or_path]
 
254
        return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
 
255
 
 
256
 
 
257
    def controlfile(self, file_or_path, mode='r'):
 
258
        """Open a control file for this branch.
 
259
 
 
260
        There are two classes of file in the control directory: text
 
261
        and binary.  binary files are untranslated byte streams.  Text
 
262
        control files are stored with Unix newlines and in UTF-8, even
 
263
        if the platform or locale defaults are different.
 
264
 
 
265
        Controlfiles should almost never be opened in write mode but
 
266
        rather should be atomically copied and replaced using atomicfile.
 
267
        """
 
268
 
 
269
        fn = self.controlfilename(file_or_path)
 
270
 
 
271
        if mode == 'rb' or mode == 'wb':
 
272
            return file(fn, mode)
 
273
        elif mode == 'r' or mode == 'w':
 
274
            # open in binary mode anyhow so there's no newline translation;
 
275
            # codecs uses line buffering by default; don't want that.
 
276
            import codecs
 
277
            return codecs.open(fn, mode + 'b', 'utf-8',
 
278
                               buffering=60000)
 
279
        else:
 
280
            raise BzrError("invalid controlfile mode %r" % mode)
 
281
 
 
282
 
 
283
 
 
284
    def _make_control(self):
 
285
        os.mkdir(self.controlfilename([]))
 
286
        self.controlfile('README', 'w').write(
 
287
            "This is a Bazaar-NG control directory.\n"
 
288
            "Do not change any files in this directory.\n")
 
289
        self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
 
290
        for d in ('text-store', 'inventory-store', 'revision-store'):
 
291
            os.mkdir(self.controlfilename(d))
 
292
        for f in ('revision-history', 'merged-patches',
 
293
                  'pending-merged-patches', 'branch-name',
 
294
                  'branch-lock'):
 
295
            self.controlfile(f, 'w').write('')
 
296
        mutter('created control directory in ' + self.base)
 
297
        Inventory().write_xml(self.controlfile('inventory','w'))
 
298
 
 
299
 
 
300
    def _check_format(self):
 
301
        """Check this branch format is supported.
 
302
 
 
303
        The current tool only supports the current unstable format.
 
304
 
 
305
        In the future, we might need different in-memory Branch
 
306
        classes to support downlevel branches.  But not yet.
 
307
        """
 
308
        # This ignores newlines so that we can open branches created
 
309
        # on Windows from Linux and so on.  I think it might be better
 
310
        # to always make all internal files in unix format.
 
311
        fmt = self.controlfile('branch-format', 'r').read()
 
312
        fmt.replace('\r\n', '')
 
313
        if fmt != BZR_BRANCH_FORMAT:
 
314
            raise BzrError('sorry, branch format %r not supported' % fmt,
 
315
                           ['use a different bzr version',
 
316
                            'or remove the .bzr directory and "bzr init" again'])
 
317
 
 
318
 
 
319
 
 
320
    def read_working_inventory(self):
 
321
        """Read the working inventory."""
 
322
        before = time.time()
 
323
        # ElementTree does its own conversion from UTF-8, so open in
 
324
        # binary.
 
325
        self.lock_read()
 
326
        try:
 
327
            inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
 
328
            mutter("loaded inventory of %d items in %f"
 
329
                   % (len(inv), time.time() - before))
 
330
            return inv
 
331
        finally:
 
332
            self.unlock()
 
333
            
 
334
 
 
335
    def _write_inventory(self, inv):
 
336
        """Update the working inventory.
 
337
 
 
338
        That is to say, the inventory describing changes underway, that
 
339
        will be committed to the next revision.
 
340
        """
 
341
        self.lock_write()
 
342
        try:
 
343
            from bzrlib.atomicfile import AtomicFile
 
344
 
 
345
            f = AtomicFile(self.controlfilename('inventory'), 'wb')
 
346
            try:
 
347
                inv.write_xml(f)
 
348
                f.commit()
 
349
            finally:
 
350
                f.close()
 
351
        finally:
 
352
            self.unlock()
 
353
        
 
354
        mutter('wrote working inventory')
 
355
            
 
356
 
 
357
    inventory = property(read_working_inventory, _write_inventory, None,
 
358
                         """Inventory for the working copy.""")
 
359
 
 
360
 
 
361
    def add(self, files, verbose=False, ids=None):
 
362
        """Make files versioned.
 
363
 
 
364
        Note that the command line normally calls smart_add instead.
 
365
 
 
366
        This puts the files in the Added state, so that they will be
 
367
        recorded by the next commit.
 
368
 
 
369
        files
 
370
            List of paths to add, relative to the base of the tree.
 
371
 
 
372
        ids
 
373
            If set, use these instead of automatically generated ids.
 
374
            Must be the same length as the list of files, but may
 
375
            contain None for ids that are to be autogenerated.
 
376
 
 
377
        TODO: Perhaps have an option to add the ids even if the files do
 
378
              not (yet) exist.
 
379
 
 
380
        TODO: Perhaps return the ids of the files?  But then again it
 
381
              is easy to retrieve them if they're needed.
 
382
 
 
383
        TODO: Adding a directory should optionally recurse down and
 
384
              add all non-ignored children.  Perhaps do that in a
 
385
              higher-level method.
 
386
        """
 
387
        # TODO: Re-adding a file that is removed in the working copy
 
388
        # should probably put it back with the previous ID.
 
389
        if isinstance(files, types.StringTypes):
 
390
            assert(ids is None or isinstance(ids, types.StringTypes))
 
391
            files = [files]
 
392
            if ids is not None:
 
393
                ids = [ids]
 
394
 
 
395
        if ids is None:
 
396
            ids = [None] * len(files)
 
397
        else:
 
398
            assert(len(ids) == len(files))
 
399
 
 
400
        self.lock_write()
 
401
        try:
 
402
            inv = self.read_working_inventory()
 
403
            for f,file_id in zip(files, ids):
 
404
                if is_control_file(f):
 
405
                    raise BzrError("cannot add control file %s" % quotefn(f))
 
406
 
 
407
                fp = splitpath(f)
 
408
 
 
409
                if len(fp) == 0:
 
410
                    raise BzrError("cannot add top-level %r" % f)
 
411
 
 
412
                fullpath = os.path.normpath(self.abspath(f))
 
413
 
 
414
                try:
 
415
                    kind = file_kind(fullpath)
 
416
                except OSError:
 
417
                    # maybe something better?
 
418
                    raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
 
419
 
 
420
                if kind != 'file' and kind != 'directory':
 
421
                    raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
 
422
 
 
423
                if file_id is None:
 
424
                    file_id = gen_file_id(f)
 
425
                inv.add_path(f, kind=kind, file_id=file_id)
 
426
 
 
427
                if verbose:
 
428
                    print 'added', quotefn(f)
 
429
 
 
430
                mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
 
431
 
 
432
            self._write_inventory(inv)
 
433
        finally:
 
434
            self.unlock()
 
435
            
 
436
 
 
437
    def print_file(self, file, revno):
 
438
        """Print `file` to stdout."""
 
439
        self.lock_read()
 
440
        try:
 
441
            tree = self.revision_tree(self.lookup_revision(revno))
 
442
            # use inventory as it was in that revision
 
443
            file_id = tree.inventory.path2id(file)
 
444
            if not file_id:
 
445
                raise BzrError("%r is not present in revision %d" % (file, revno))
 
446
            tree.print_file(file_id)
 
447
        finally:
 
448
            self.unlock()
 
449
 
 
450
 
 
451
    def remove(self, files, verbose=False):
 
452
        """Mark nominated files for removal from the inventory.
 
453
 
 
454
        This does not remove their text.  This does not run on 
 
455
 
 
456
        TODO: Refuse to remove modified files unless --force is given?
 
457
 
 
458
        TODO: Do something useful with directories.
 
459
 
 
460
        TODO: Should this remove the text or not?  Tough call; not
 
461
        removing may be useful and the user can just use use rm, and
 
462
        is the opposite of add.  Removing it is consistent with most
 
463
        other tools.  Maybe an option.
 
464
        """
 
465
        ## TODO: Normalize names
 
466
        ## TODO: Remove nested loops; better scalability
 
467
        if isinstance(files, types.StringTypes):
 
468
            files = [files]
 
469
 
 
470
        self.lock_write()
 
471
 
 
472
        try:
 
473
            tree = self.working_tree()
 
474
            inv = tree.inventory
 
475
 
 
476
            # do this before any modifications
 
477
            for f in files:
 
478
                fid = inv.path2id(f)
 
479
                if not fid:
 
480
                    raise BzrError("cannot remove unversioned file %s" % quotefn(f))
 
481
                mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
 
482
                if verbose:
 
483
                    # having remove it, it must be either ignored or unknown
 
484
                    if tree.is_ignored(f):
 
485
                        new_status = 'I'
 
486
                    else:
 
487
                        new_status = '?'
 
488
                    show_status(new_status, inv[fid].kind, quotefn(f))
 
489
                del inv[fid]
 
490
 
 
491
            self._write_inventory(inv)
 
492
        finally:
 
493
            self.unlock()
 
494
 
 
495
 
 
496
    # FIXME: this doesn't need to be a branch method
 
497
    def set_inventory(self, new_inventory_list):
 
498
        inv = Inventory()
 
499
        for path, file_id, parent, kind in new_inventory_list:
 
500
            name = os.path.basename(path)
 
501
            if name == "":
 
502
                continue
 
503
            inv.add(InventoryEntry(file_id, name, kind, parent))
 
504
        self._write_inventory(inv)
 
505
 
 
506
 
 
507
    def unknowns(self):
 
508
        """Return all unknown files.
 
509
 
 
510
        These are files in the working directory that are not versioned or
 
511
        control files or ignored.
 
512
        
 
513
        >>> b = ScratchBranch(files=['foo', 'foo~'])
 
514
        >>> list(b.unknowns())
 
515
        ['foo']
 
516
        >>> b.add('foo')
 
517
        >>> list(b.unknowns())
 
518
        []
 
519
        >>> b.remove('foo')
 
520
        >>> list(b.unknowns())
 
521
        ['foo']
 
522
        """
 
523
        return self.working_tree().unknowns()
 
524
 
 
525
 
 
526
    def append_revision(self, revision_id):
 
527
        from bzrlib.atomicfile import AtomicFile
 
528
 
 
529
        mutter("add {%s} to revision-history" % revision_id)
 
530
        rev_history = self.revision_history() + [revision_id]
 
531
 
 
532
        f = AtomicFile(self.controlfilename('revision-history'))
 
533
        try:
 
534
            for rev_id in rev_history:
 
535
                print >>f, rev_id
 
536
            f.commit()
 
537
        finally:
 
538
            f.close()
 
539
 
 
540
 
 
541
    def get_revision(self, revision_id):
 
542
        """Return the Revision object for a named revision"""
 
543
        if not revision_id or not isinstance(revision_id, basestring):
 
544
            raise ValueError('invalid revision-id: %r' % revision_id)
 
545
        r = Revision.read_xml(self.revision_store[revision_id])
 
546
        assert r.revision_id == revision_id
 
547
        return r
 
548
 
 
549
    def get_revision_sha1(self, revision_id):
 
550
        """Hash the stored value of a revision, and return it."""
 
551
        # In the future, revision entries will be signed. At that
 
552
        # point, it is probably best *not* to include the signature
 
553
        # in the revision hash. Because that lets you re-sign
 
554
        # the revision, (add signatures/remove signatures) and still
 
555
        # have all hash pointers stay consistent.
 
556
        # But for now, just hash the contents.
 
557
        return sha_file(self.revision_store[revision_id])
 
558
 
 
559
 
 
560
    def get_inventory(self, inventory_id):
 
561
        """Get Inventory object by hash.
 
562
 
 
563
        TODO: Perhaps for this and similar methods, take a revision
 
564
               parameter which can be either an integer revno or a
 
565
               string hash."""
 
566
        i = Inventory.read_xml(self.inventory_store[inventory_id])
 
567
        return i
 
568
 
 
569
    def get_inventory_sha1(self, inventory_id):
 
570
        """Return the sha1 hash of the inventory entry
 
571
        """
 
572
        return sha_file(self.inventory_store[inventory_id])
 
573
 
 
574
 
 
575
    def get_revision_inventory(self, revision_id):
 
576
        """Return inventory of a past revision."""
 
577
        if revision_id == None:
 
578
            return Inventory()
 
579
        else:
 
580
            return self.get_inventory(self.get_revision(revision_id).inventory_id)
 
581
 
 
582
 
 
583
    def revision_history(self):
 
584
        """Return sequence of revision hashes on to this branch.
 
585
 
 
586
        >>> ScratchBranch().revision_history()
 
587
        []
 
588
        """
 
589
        self.lock_read()
 
590
        try:
 
591
            return [l.rstrip('\r\n') for l in
 
592
                    self.controlfile('revision-history', 'r').readlines()]
 
593
        finally:
 
594
            self.unlock()
 
595
 
 
596
 
 
597
    def common_ancestor(self, other, self_revno=None, other_revno=None):
 
598
        """
 
599
        >>> import commit
 
600
        >>> sb = ScratchBranch(files=['foo', 'foo~'])
 
601
        >>> sb.common_ancestor(sb) == (None, None)
 
602
        True
 
603
        >>> commit.commit(sb, "Committing first revision", verbose=False)
 
604
        >>> sb.common_ancestor(sb)[0]
 
605
        1
 
606
        >>> clone = sb.clone()
 
607
        >>> commit.commit(sb, "Committing second revision", verbose=False)
 
608
        >>> sb.common_ancestor(sb)[0]
 
609
        2
 
610
        >>> sb.common_ancestor(clone)[0]
 
611
        1
 
612
        >>> commit.commit(clone, "Committing divergent second revision", 
 
613
        ...               verbose=False)
 
614
        >>> sb.common_ancestor(clone)[0]
 
615
        1
 
616
        >>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
 
617
        True
 
618
        >>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
 
619
        True
 
620
        >>> clone2 = sb.clone()
 
621
        >>> sb.common_ancestor(clone2)[0]
 
622
        2
 
623
        >>> sb.common_ancestor(clone2, self_revno=1)[0]
 
624
        1
 
625
        >>> sb.common_ancestor(clone2, other_revno=1)[0]
 
626
        1
 
627
        """
 
628
        my_history = self.revision_history()
 
629
        other_history = other.revision_history()
 
630
        if self_revno is None:
 
631
            self_revno = len(my_history)
 
632
        if other_revno is None:
 
633
            other_revno = len(other_history)
 
634
        indices = range(min((self_revno, other_revno)))
 
635
        indices.reverse()
 
636
        for r in indices:
 
637
            if my_history[r] == other_history[r]:
 
638
                return r+1, my_history[r]
 
639
        return None, None
 
640
 
 
641
    def enum_history(self, direction):
 
642
        """Return (revno, revision_id) for history of branch.
 
643
 
 
644
        direction
 
645
            'forward' is from earliest to latest
 
646
            'reverse' is from latest to earliest
 
647
        """
 
648
        rh = self.revision_history()
 
649
        if direction == 'forward':
 
650
            i = 1
 
651
            for rid in rh:
 
652
                yield i, rid
 
653
                i += 1
 
654
        elif direction == 'reverse':
 
655
            i = len(rh)
 
656
            while i > 0:
 
657
                yield i, rh[i-1]
 
658
                i -= 1
 
659
        else:
 
660
            raise ValueError('invalid history direction', direction)
 
661
 
 
662
 
 
663
    def revno(self):
 
664
        """Return current revision number for this branch.
 
665
 
 
666
        That is equivalent to the number of revisions committed to
 
667
        this branch.
 
668
        """
 
669
        return len(self.revision_history())
 
670
 
 
671
 
 
672
    def last_patch(self):
 
673
        """Return last patch hash, or None if no history.
 
674
        """
 
675
        ph = self.revision_history()
 
676
        if ph:
 
677
            return ph[-1]
 
678
        else:
 
679
            return None
 
680
 
 
681
 
 
682
    def missing_revisions(self, other, stop_revision=None):
 
683
        """
 
684
        If self and other have not diverged, return a list of the revisions
 
685
        present in other, but missing from self.
 
686
 
 
687
        >>> from bzrlib.commit import commit
 
688
        >>> bzrlib.trace.silent = True
 
689
        >>> br1 = ScratchBranch()
 
690
        >>> br2 = ScratchBranch()
 
691
        >>> br1.missing_revisions(br2)
 
692
        []
 
693
        >>> commit(br2, "lala!", rev_id="REVISION-ID-1")
 
694
        >>> br1.missing_revisions(br2)
 
695
        [u'REVISION-ID-1']
 
696
        >>> br2.missing_revisions(br1)
 
697
        []
 
698
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1")
 
699
        >>> br1.missing_revisions(br2)
 
700
        []
 
701
        >>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
 
702
        >>> br1.missing_revisions(br2)
 
703
        [u'REVISION-ID-2A']
 
704
        >>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
 
705
        >>> br1.missing_revisions(br2)
 
706
        Traceback (most recent call last):
 
707
        DivergedBranches: These branches have diverged.
 
708
        """
 
709
        self_history = self.revision_history()
 
710
        self_len = len(self_history)
 
711
        other_history = other.revision_history()
 
712
        other_len = len(other_history)
 
713
        common_index = min(self_len, other_len) -1
 
714
        if common_index >= 0 and \
 
715
            self_history[common_index] != other_history[common_index]:
 
716
            raise DivergedBranches(self, other)
 
717
 
 
718
        if stop_revision is None:
 
719
            stop_revision = other_len
 
720
        elif stop_revision > other_len:
 
721
            raise NoSuchRevision(self, stop_revision)
 
722
        
 
723
        return other_history[self_len:stop_revision]
 
724
 
 
725
 
 
726
    def update_revisions(self, other, stop_revision=None):
 
727
        """Pull in all new revisions from other branch.
 
728
        
 
729
        >>> from bzrlib.commit import commit
 
730
        >>> bzrlib.trace.silent = True
 
731
        >>> br1 = ScratchBranch(files=['foo', 'bar'])
 
732
        >>> br1.add('foo')
 
733
        >>> br1.add('bar')
 
734
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
 
735
        >>> br2 = ScratchBranch()
 
736
        >>> br2.update_revisions(br1)
 
737
        Added 2 texts.
 
738
        Added 1 inventories.
 
739
        Added 1 revisions.
 
740
        >>> br2.revision_history()
 
741
        [u'REVISION-ID-1']
 
742
        >>> br2.update_revisions(br1)
 
743
        Added 0 texts.
 
744
        Added 0 inventories.
 
745
        Added 0 revisions.
 
746
        >>> br1.text_store.total_size() == br2.text_store.total_size()
 
747
        True
 
748
        """
 
749
        from bzrlib.progress import ProgressBar
 
750
 
 
751
        pb = ProgressBar()
 
752
 
 
753
        pb.update('comparing histories')
 
754
        revision_ids = self.missing_revisions(other, stop_revision)
 
755
        revisions = []
 
756
        needed_texts = sets.Set()
 
757
        i = 0
 
758
        for rev_id in revision_ids:
 
759
            i += 1
 
760
            pb.update('fetching revision', i, len(revision_ids))
 
761
            rev = other.get_revision(rev_id)
 
762
            revisions.append(rev)
 
763
            inv = other.get_inventory(str(rev.inventory_id))
 
764
            for key, entry in inv.iter_entries():
 
765
                if entry.text_id is None:
 
766
                    continue
 
767
                if entry.text_id not in self.text_store:
 
768
                    needed_texts.add(entry.text_id)
 
769
 
 
770
        pb.clear()
 
771
                    
 
772
        count = self.text_store.copy_multi(other.text_store, needed_texts)
 
773
        print "Added %d texts." % count 
 
774
        inventory_ids = [ f.inventory_id for f in revisions ]
 
775
        count = self.inventory_store.copy_multi(other.inventory_store, 
 
776
                                                inventory_ids)
 
777
        print "Added %d inventories." % count 
 
778
        revision_ids = [ f.revision_id for f in revisions]
 
779
        count = self.revision_store.copy_multi(other.revision_store, 
 
780
                                               revision_ids)
 
781
        for revision_id in revision_ids:
 
782
            self.append_revision(revision_id)
 
783
        print "Added %d revisions." % count
 
784
                    
 
785
        
 
786
    def commit(self, *args, **kw):
 
787
        from bzrlib.commit import commit
 
788
        commit(self, *args, **kw)
 
789
        
 
790
 
 
791
    def lookup_revision(self, revno):
 
792
        """Return revision hash for revision number."""
 
793
        if revno == 0:
 
794
            return None
 
795
 
 
796
        try:
 
797
            # list is 0-based; revisions are 1-based
 
798
            return self.revision_history()[revno-1]
 
799
        except IndexError:
 
800
            raise BzrError("no such revision %s" % revno)
 
801
 
 
802
 
 
803
    def revision_tree(self, revision_id):
 
804
        """Return Tree for a revision on this branch.
 
805
 
 
806
        `revision_id` may be None for the null revision, in which case
 
807
        an `EmptyTree` is returned."""
 
808
        # TODO: refactor this to use an existing revision object
 
809
        # so we don't need to read it in twice.
 
810
        if revision_id == None:
 
811
            return EmptyTree()
 
812
        else:
 
813
            inv = self.get_revision_inventory(revision_id)
 
814
            return RevisionTree(self.text_store, inv)
 
815
 
 
816
 
 
817
    def working_tree(self):
 
818
        """Return a `Tree` for the working copy."""
 
819
        from workingtree import WorkingTree
 
820
        return WorkingTree(self.base, self.read_working_inventory())
 
821
 
 
822
 
 
823
    def basis_tree(self):
 
824
        """Return `Tree` object for last revision.
 
825
 
 
826
        If there are no revisions yet, return an `EmptyTree`.
 
827
        """
 
828
        r = self.last_patch()
 
829
        if r == None:
 
830
            return EmptyTree()
 
831
        else:
 
832
            return RevisionTree(self.text_store, self.get_revision_inventory(r))
 
833
 
 
834
 
 
835
 
 
836
    def rename_one(self, from_rel, to_rel):
 
837
        """Rename one file.
 
838
 
 
839
        This can change the directory or the filename or both.
 
840
        """
 
841
        self.lock_write()
 
842
        try:
 
843
            tree = self.working_tree()
 
844
            inv = tree.inventory
 
845
            if not tree.has_filename(from_rel):
 
846
                raise BzrError("can't rename: old working file %r does not exist" % from_rel)
 
847
            if tree.has_filename(to_rel):
 
848
                raise BzrError("can't rename: new working file %r already exists" % to_rel)
 
849
 
 
850
            file_id = inv.path2id(from_rel)
 
851
            if file_id == None:
 
852
                raise BzrError("can't rename: old name %r is not versioned" % from_rel)
 
853
 
 
854
            if inv.path2id(to_rel):
 
855
                raise BzrError("can't rename: new name %r is already versioned" % to_rel)
 
856
 
 
857
            to_dir, to_tail = os.path.split(to_rel)
 
858
            to_dir_id = inv.path2id(to_dir)
 
859
            if to_dir_id == None and to_dir != '':
 
860
                raise BzrError("can't determine destination directory id for %r" % to_dir)
 
861
 
 
862
            mutter("rename_one:")
 
863
            mutter("  file_id    {%s}" % file_id)
 
864
            mutter("  from_rel   %r" % from_rel)
 
865
            mutter("  to_rel     %r" % to_rel)
 
866
            mutter("  to_dir     %r" % to_dir)
 
867
            mutter("  to_dir_id  {%s}" % to_dir_id)
 
868
 
 
869
            inv.rename(file_id, to_dir_id, to_tail)
 
870
 
 
871
            print "%s => %s" % (from_rel, to_rel)
 
872
 
 
873
            from_abs = self.abspath(from_rel)
 
874
            to_abs = self.abspath(to_rel)
 
875
            try:
 
876
                os.rename(from_abs, to_abs)
 
877
            except OSError, e:
 
878
                raise BzrError("failed to rename %r to %r: %s"
 
879
                        % (from_abs, to_abs, e[1]),
 
880
                        ["rename rolled back"])
 
881
 
 
882
            self._write_inventory(inv)
 
883
        finally:
 
884
            self.unlock()
 
885
 
 
886
 
 
887
    def move(self, from_paths, to_name):
 
888
        """Rename files.
 
889
 
 
890
        to_name must exist as a versioned directory.
 
891
 
 
892
        If to_name exists and is a directory, the files are moved into
 
893
        it, keeping their old names.  If it is a directory, 
 
894
 
 
895
        Note that to_name is only the last component of the new name;
 
896
        this doesn't change the directory.
 
897
        """
 
898
        self.lock_write()
 
899
        try:
 
900
            ## TODO: Option to move IDs only
 
901
            assert not isinstance(from_paths, basestring)
 
902
            tree = self.working_tree()
 
903
            inv = tree.inventory
 
904
            to_abs = self.abspath(to_name)
 
905
            if not isdir(to_abs):
 
906
                raise BzrError("destination %r is not a directory" % to_abs)
 
907
            if not tree.has_filename(to_name):
 
908
                raise BzrError("destination %r not in working directory" % to_abs)
 
909
            to_dir_id = inv.path2id(to_name)
 
910
            if to_dir_id == None and to_name != '':
 
911
                raise BzrError("destination %r is not a versioned directory" % to_name)
 
912
            to_dir_ie = inv[to_dir_id]
 
913
            if to_dir_ie.kind not in ('directory', 'root_directory'):
 
914
                raise BzrError("destination %r is not a directory" % to_abs)
 
915
 
 
916
            to_idpath = inv.get_idpath(to_dir_id)
 
917
 
 
918
            for f in from_paths:
 
919
                if not tree.has_filename(f):
 
920
                    raise BzrError("%r does not exist in working tree" % f)
 
921
                f_id = inv.path2id(f)
 
922
                if f_id == None:
 
923
                    raise BzrError("%r is not versioned" % f)
 
924
                name_tail = splitpath(f)[-1]
 
925
                dest_path = appendpath(to_name, name_tail)
 
926
                if tree.has_filename(dest_path):
 
927
                    raise BzrError("destination %r already exists" % dest_path)
 
928
                if f_id in to_idpath:
 
929
                    raise BzrError("can't move %r to a subdirectory of itself" % f)
 
930
 
 
931
            # OK, so there's a race here, it's possible that someone will
 
932
            # create a file in this interval and then the rename might be
 
933
            # left half-done.  But we should have caught most problems.
 
934
 
 
935
            for f in from_paths:
 
936
                name_tail = splitpath(f)[-1]
 
937
                dest_path = appendpath(to_name, name_tail)
 
938
                print "%s => %s" % (f, dest_path)
 
939
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
 
940
                try:
 
941
                    os.rename(self.abspath(f), self.abspath(dest_path))
 
942
                except OSError, e:
 
943
                    raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
 
944
                            ["rename rolled back"])
 
945
 
 
946
            self._write_inventory(inv)
 
947
        finally:
 
948
            self.unlock()
 
949
 
 
950
 
 
951
    def revert(self, filenames, old_tree=None, backups=True):
 
952
        """Restore selected files to the versions from a previous tree.
 
953
 
 
954
        backups
 
955
            If true (default) backups are made of files before
 
956
            they're renamed.
 
957
        """
 
958
        from bzrlib.errors import NotVersionedError, BzrError
 
959
        from bzrlib.atomicfile import AtomicFile
 
960
        from bzrlib.osutils import backup_file
 
961
        
 
962
        inv = self.read_working_inventory()
 
963
        if old_tree is None:
 
964
            old_tree = self.basis_tree()
 
965
        old_inv = old_tree.inventory
 
966
 
 
967
        nids = []
 
968
        for fn in filenames:
 
969
            file_id = inv.path2id(fn)
 
970
            if not file_id:
 
971
                raise NotVersionedError("not a versioned file", fn)
 
972
            if not old_inv.has_id(file_id):
 
973
                raise BzrError("file not present in old tree", fn, file_id)
 
974
            nids.append((fn, file_id))
 
975
            
 
976
        # TODO: Rename back if it was previously at a different location
 
977
 
 
978
        # TODO: If given a directory, restore the entire contents from
 
979
        # the previous version.
 
980
 
 
981
        # TODO: Make a backup to a temporary file.
 
982
 
 
983
        # TODO: If the file previously didn't exist, delete it?
 
984
        for fn, file_id in nids:
 
985
            backup_file(fn)
 
986
            
 
987
            f = AtomicFile(fn, 'wb')
 
988
            try:
 
989
                f.write(old_tree.get_file(file_id).read())
 
990
                f.commit()
 
991
            finally:
 
992
                f.close()
 
993
 
 
994
 
 
995
 
 
996
class ScratchBranch(Branch):
 
997
    """Special test class: a branch that cleans up after itself.
 
998
 
 
999
    >>> b = ScratchBranch()
 
1000
    >>> isdir(b.base)
 
1001
    True
 
1002
    >>> bd = b.base
 
1003
    >>> b.destroy()
 
1004
    >>> isdir(bd)
 
1005
    False
 
1006
    """
 
1007
    def __init__(self, files=[], dirs=[], base=None):
 
1008
        """Make a test branch.
 
1009
 
 
1010
        This creates a temporary directory and runs init-tree in it.
 
1011
 
 
1012
        If any files are listed, they are created in the working copy.
 
1013
        """
 
1014
        init = False
 
1015
        if base is None:
 
1016
            base = tempfile.mkdtemp()
 
1017
            init = True
 
1018
        Branch.__init__(self, base, init=init)
 
1019
        for d in dirs:
 
1020
            os.mkdir(self.abspath(d))
 
1021
            
 
1022
        for f in files:
 
1023
            file(os.path.join(self.base, f), 'w').write('content of %s' % f)
 
1024
 
 
1025
 
 
1026
    def clone(self):
 
1027
        """
 
1028
        >>> orig = ScratchBranch(files=["file1", "file2"])
 
1029
        >>> clone = orig.clone()
 
1030
        >>> os.path.samefile(orig.base, clone.base)
 
1031
        False
 
1032
        >>> os.path.isfile(os.path.join(clone.base, "file1"))
 
1033
        True
 
1034
        """
 
1035
        base = tempfile.mkdtemp()
 
1036
        os.rmdir(base)
 
1037
        shutil.copytree(self.base, base, symlinks=True)
 
1038
        return ScratchBranch(base=base)
 
1039
        
 
1040
    def __del__(self):
 
1041
        self.destroy()
 
1042
 
 
1043
    def destroy(self):
 
1044
        """Destroy the test branch, removing the scratch directory."""
 
1045
        try:
 
1046
            if self.base:
 
1047
                mutter("delete ScratchBranch %s" % self.base)
 
1048
                shutil.rmtree(self.base)
 
1049
        except OSError, e:
 
1050
            # Work around for shutil.rmtree failing on Windows when
 
1051
            # readonly files are encountered
 
1052
            mutter("hit exception in destroying ScratchBranch: %s" % e)
 
1053
            for root, dirs, files in os.walk(self.base, topdown=False):
 
1054
                for name in files:
 
1055
                    os.chmod(os.path.join(root, name), 0700)
 
1056
            shutil.rmtree(self.base)
 
1057
        self.base = None
 
1058
 
 
1059
    
 
1060
 
 
1061
######################################################################
 
1062
# predicates
 
1063
 
 
1064
 
 
1065
def is_control_file(filename):
 
1066
    ## FIXME: better check
 
1067
    filename = os.path.normpath(filename)
 
1068
    while filename != '':
 
1069
        head, tail = os.path.split(filename)
 
1070
        ## mutter('check %r for control file' % ((head, tail), ))
 
1071
        if tail == bzrlib.BZRDIR:
 
1072
            return True
 
1073
        if filename == head:
 
1074
            break
 
1075
        filename = head
 
1076
    return False
 
1077
 
 
1078
 
 
1079
 
 
1080
def gen_file_id(name):
 
1081
    """Return new file id.
 
1082
 
 
1083
    This should probably generate proper UUIDs, but for the moment we
 
1084
    cope with just randomness because running uuidgen every time is
 
1085
    slow."""
 
1086
    import re
 
1087
 
 
1088
    # get last component
 
1089
    idx = name.rfind('/')
 
1090
    if idx != -1:
 
1091
        name = name[idx+1 : ]
 
1092
    idx = name.rfind('\\')
 
1093
    if idx != -1:
 
1094
        name = name[idx+1 : ]
 
1095
 
 
1096
    # make it not a hidden file
 
1097
    name = name.lstrip('.')
 
1098
 
 
1099
    # remove any wierd characters; we don't escape them but rather
 
1100
    # just pull them out
 
1101
    name = re.sub(r'[^\w.]', '', name)
 
1102
 
 
1103
    s = hexlify(rand_bytes(8))
 
1104
    return '-'.join((name, compact_date(time.time()), s))