/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-15 04:24:01 UTC
  • Revision ID: mbp@sourcefrog.net-20050615042401-02a29d106bece661
add-bzr-to-baz allows multiple arguments

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
        ## TODO: factor out to atomicfile?  is rename safe on windows?
 
342
        ## TODO: Maybe some kind of clean/dirty marker on inventory?
 
343
        tmpfname = self.controlfilename('inventory.tmp')
 
344
        tmpf = file(tmpfname, 'wb')
 
345
        inv.write_xml(tmpf)
 
346
        tmpf.close()
 
347
        inv_fname = self.controlfilename('inventory')
 
348
        if sys.platform == 'win32':
 
349
            os.remove(inv_fname)
 
350
        os.rename(tmpfname, inv_fname)
 
351
        mutter('wrote working inventory')
 
352
            
 
353
 
 
354
    inventory = property(read_working_inventory, _write_inventory, None,
 
355
                         """Inventory for the working copy.""")
 
356
 
 
357
 
 
358
    def add(self, files, verbose=False, ids=None):
 
359
        """Make files versioned.
 
360
 
 
361
        Note that the command line normally calls smart_add instead.
 
362
 
 
363
        This puts the files in the Added state, so that they will be
 
364
        recorded by the next commit.
 
365
 
 
366
        files
 
367
            List of paths to add, relative to the base of the tree.
 
368
 
 
369
        ids
 
370
            If set, use these instead of automatically generated ids.
 
371
            Must be the same length as the list of files, but may
 
372
            contain None for ids that are to be autogenerated.
 
373
 
 
374
        TODO: Perhaps have an option to add the ids even if the files do
 
375
              not (yet) exist.
 
376
 
 
377
        TODO: Perhaps return the ids of the files?  But then again it
 
378
              is easy to retrieve them if they're needed.
 
379
 
 
380
        TODO: Adding a directory should optionally recurse down and
 
381
              add all non-ignored children.  Perhaps do that in a
 
382
              higher-level method.
 
383
        """
 
384
        # TODO: Re-adding a file that is removed in the working copy
 
385
        # should probably put it back with the previous ID.
 
386
        if isinstance(files, types.StringTypes):
 
387
            assert(ids is None or isinstance(ids, types.StringTypes))
 
388
            files = [files]
 
389
            if ids is not None:
 
390
                ids = [ids]
 
391
 
 
392
        if ids is None:
 
393
            ids = [None] * len(files)
 
394
        else:
 
395
            assert(len(ids) == len(files))
 
396
 
 
397
        self.lock_write()
 
398
        try:
 
399
            inv = self.read_working_inventory()
 
400
            for f,file_id in zip(files, ids):
 
401
                if is_control_file(f):
 
402
                    raise BzrError("cannot add control file %s" % quotefn(f))
 
403
 
 
404
                fp = splitpath(f)
 
405
 
 
406
                if len(fp) == 0:
 
407
                    raise BzrError("cannot add top-level %r" % f)
 
408
 
 
409
                fullpath = os.path.normpath(self.abspath(f))
 
410
 
 
411
                try:
 
412
                    kind = file_kind(fullpath)
 
413
                except OSError:
 
414
                    # maybe something better?
 
415
                    raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
 
416
 
 
417
                if kind != 'file' and kind != 'directory':
 
418
                    raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
 
419
 
 
420
                if file_id is None:
 
421
                    file_id = gen_file_id(f)
 
422
                inv.add_path(f, kind=kind, file_id=file_id)
 
423
 
 
424
                if verbose:
 
425
                    show_status('A', kind, quotefn(f))
 
426
 
 
427
                mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
 
428
 
 
429
            self._write_inventory(inv)
 
430
        finally:
 
431
            self.unlock()
 
432
            
 
433
 
 
434
    def print_file(self, file, revno):
 
435
        """Print `file` to stdout."""
 
436
        self.lock_read()
 
437
        try:
 
438
            tree = self.revision_tree(self.lookup_revision(revno))
 
439
            # use inventory as it was in that revision
 
440
            file_id = tree.inventory.path2id(file)
 
441
            if not file_id:
 
442
                raise BzrError("%r is not present in revision %d" % (file, revno))
 
443
            tree.print_file(file_id)
 
444
        finally:
 
445
            self.unlock()
 
446
 
 
447
 
 
448
    def remove(self, files, verbose=False):
 
449
        """Mark nominated files for removal from the inventory.
 
450
 
 
451
        This does not remove their text.  This does not run on 
 
452
 
 
453
        TODO: Refuse to remove modified files unless --force is given?
 
454
 
 
455
        TODO: Do something useful with directories.
 
456
 
 
457
        TODO: Should this remove the text or not?  Tough call; not
 
458
        removing may be useful and the user can just use use rm, and
 
459
        is the opposite of add.  Removing it is consistent with most
 
460
        other tools.  Maybe an option.
 
461
        """
 
462
        ## TODO: Normalize names
 
463
        ## TODO: Remove nested loops; better scalability
 
464
        if isinstance(files, types.StringTypes):
 
465
            files = [files]
 
466
 
 
467
        self.lock_write()
 
468
 
 
469
        try:
 
470
            tree = self.working_tree()
 
471
            inv = tree.inventory
 
472
 
 
473
            # do this before any modifications
 
474
            for f in files:
 
475
                fid = inv.path2id(f)
 
476
                if not fid:
 
477
                    raise BzrError("cannot remove unversioned file %s" % quotefn(f))
 
478
                mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
 
479
                if verbose:
 
480
                    # having remove it, it must be either ignored or unknown
 
481
                    if tree.is_ignored(f):
 
482
                        new_status = 'I'
 
483
                    else:
 
484
                        new_status = '?'
 
485
                    show_status(new_status, inv[fid].kind, quotefn(f))
 
486
                del inv[fid]
 
487
 
 
488
            self._write_inventory(inv)
 
489
        finally:
 
490
            self.unlock()
 
491
 
 
492
 
 
493
    # FIXME: this doesn't need to be a branch method
 
494
    def set_inventory(self, new_inventory_list):
 
495
        inv = Inventory()
 
496
        for path, file_id, parent, kind in new_inventory_list:
 
497
            name = os.path.basename(path)
 
498
            if name == "":
 
499
                continue
 
500
            inv.add(InventoryEntry(file_id, name, kind, parent))
 
501
        self._write_inventory(inv)
 
502
 
 
503
 
 
504
    def unknowns(self):
 
505
        """Return all unknown files.
 
506
 
 
507
        These are files in the working directory that are not versioned or
 
508
        control files or ignored.
 
509
        
 
510
        >>> b = ScratchBranch(files=['foo', 'foo~'])
 
511
        >>> list(b.unknowns())
 
512
        ['foo']
 
513
        >>> b.add('foo')
 
514
        >>> list(b.unknowns())
 
515
        []
 
516
        >>> b.remove('foo')
 
517
        >>> list(b.unknowns())
 
518
        ['foo']
 
519
        """
 
520
        return self.working_tree().unknowns()
 
521
 
 
522
 
 
523
    def append_revision(self, revision_id):
 
524
        mutter("add {%s} to revision-history" % revision_id)
 
525
        rev_history = self.revision_history()
 
526
 
 
527
        tmprhname = self.controlfilename('revision-history.tmp')
 
528
        rhname = self.controlfilename('revision-history')
 
529
        
 
530
        f = file(tmprhname, 'wt')
 
531
        rev_history.append(revision_id)
 
532
        f.write('\n'.join(rev_history))
 
533
        f.write('\n')
 
534
        f.close()
 
535
 
 
536
        if sys.platform == 'win32':
 
537
            os.remove(rhname)
 
538
        os.rename(tmprhname, rhname)
 
539
        
 
540
 
 
541
 
 
542
    def get_revision(self, revision_id):
 
543
        """Return the Revision object for a named revision"""
 
544
        if not revision_id or not isinstance(revision_id, basestring):
 
545
            raise ValueError('invalid revision-id: %r' % revision_id)
 
546
        r = Revision.read_xml(self.revision_store[revision_id])
 
547
        assert r.revision_id == revision_id
 
548
        return r
 
549
 
 
550
    def get_revision_sha1(self, revision_id):
 
551
        """Hash the stored value of a revision, and return it."""
 
552
        # In the future, revision entries will be signed. At that
 
553
        # point, it is probably best *not* to include the signature
 
554
        # in the revision hash. Because that lets you re-sign
 
555
        # the revision, (add signatures/remove signatures) and still
 
556
        # have all hash pointers stay consistent.
 
557
        # But for now, just hash the contents.
 
558
        return sha_file(self.revision_store[revision_id])
 
559
 
 
560
 
 
561
    def get_inventory(self, inventory_id):
 
562
        """Get Inventory object by hash.
 
563
 
 
564
        TODO: Perhaps for this and similar methods, take a revision
 
565
               parameter which can be either an integer revno or a
 
566
               string hash."""
 
567
        i = Inventory.read_xml(self.inventory_store[inventory_id])
 
568
        return i
 
569
 
 
570
    def get_inventory_sha1(self, inventory_id):
 
571
        """Return the sha1 hash of the inventory entry
 
572
        """
 
573
        return sha_file(self.inventory_store[inventory_id])
 
574
 
 
575
 
 
576
    def get_revision_inventory(self, revision_id):
 
577
        """Return inventory of a past revision."""
 
578
        if revision_id == None:
 
579
            return Inventory()
 
580
        else:
 
581
            return self.get_inventory(self.get_revision(revision_id).inventory_id)
 
582
 
 
583
 
 
584
    def revision_history(self):
 
585
        """Return sequence of revision hashes on to this branch.
 
586
 
 
587
        >>> ScratchBranch().revision_history()
 
588
        []
 
589
        """
 
590
        self.lock_read()
 
591
        try:
 
592
            return [l.rstrip('\r\n') for l in
 
593
                    self.controlfile('revision-history', 'r').readlines()]
 
594
        finally:
 
595
            self.unlock()
 
596
 
 
597
 
 
598
    def common_ancestor(self, other, self_revno=None, other_revno=None):
 
599
        """
 
600
        >>> import commit
 
601
        >>> sb = ScratchBranch(files=['foo', 'foo~'])
 
602
        >>> sb.common_ancestor(sb) == (None, None)
 
603
        True
 
604
        >>> commit.commit(sb, "Committing first revision", verbose=False)
 
605
        >>> sb.common_ancestor(sb)[0]
 
606
        1
 
607
        >>> clone = sb.clone()
 
608
        >>> commit.commit(sb, "Committing second revision", verbose=False)
 
609
        >>> sb.common_ancestor(sb)[0]
 
610
        2
 
611
        >>> sb.common_ancestor(clone)[0]
 
612
        1
 
613
        >>> commit.commit(clone, "Committing divergent second revision", 
 
614
        ...               verbose=False)
 
615
        >>> sb.common_ancestor(clone)[0]
 
616
        1
 
617
        >>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
 
618
        True
 
619
        >>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
 
620
        True
 
621
        >>> clone2 = sb.clone()
 
622
        >>> sb.common_ancestor(clone2)[0]
 
623
        2
 
624
        >>> sb.common_ancestor(clone2, self_revno=1)[0]
 
625
        1
 
626
        >>> sb.common_ancestor(clone2, other_revno=1)[0]
 
627
        1
 
628
        """
 
629
        my_history = self.revision_history()
 
630
        other_history = other.revision_history()
 
631
        if self_revno is None:
 
632
            self_revno = len(my_history)
 
633
        if other_revno is None:
 
634
            other_revno = len(other_history)
 
635
        indices = range(min((self_revno, other_revno)))
 
636
        indices.reverse()
 
637
        for r in indices:
 
638
            if my_history[r] == other_history[r]:
 
639
                return r+1, my_history[r]
 
640
        return None, None
 
641
 
 
642
    def enum_history(self, direction):
 
643
        """Return (revno, revision_id) for history of branch.
 
644
 
 
645
        direction
 
646
            'forward' is from earliest to latest
 
647
            'reverse' is from latest to earliest
 
648
        """
 
649
        rh = self.revision_history()
 
650
        if direction == 'forward':
 
651
            i = 1
 
652
            for rid in rh:
 
653
                yield i, rid
 
654
                i += 1
 
655
        elif direction == 'reverse':
 
656
            i = len(rh)
 
657
            while i > 0:
 
658
                yield i, rh[i-1]
 
659
                i -= 1
 
660
        else:
 
661
            raise ValueError('invalid history direction', direction)
 
662
 
 
663
 
 
664
    def revno(self):
 
665
        """Return current revision number for this branch.
 
666
 
 
667
        That is equivalent to the number of revisions committed to
 
668
        this branch.
 
669
        """
 
670
        return len(self.revision_history())
 
671
 
 
672
 
 
673
    def last_patch(self):
 
674
        """Return last patch hash, or None if no history.
 
675
        """
 
676
        ph = self.revision_history()
 
677
        if ph:
 
678
            return ph[-1]
 
679
        else:
 
680
            return None
 
681
 
 
682
 
 
683
    def missing_revisions(self, other, stop_revision=None):
 
684
        """
 
685
        If self and other have not diverged, return a list of the revisions
 
686
        present in other, but missing from self.
 
687
 
 
688
        >>> from bzrlib.commit import commit
 
689
        >>> bzrlib.trace.silent = True
 
690
        >>> br1 = ScratchBranch()
 
691
        >>> br2 = ScratchBranch()
 
692
        >>> br1.missing_revisions(br2)
 
693
        []
 
694
        >>> commit(br2, "lala!", rev_id="REVISION-ID-1")
 
695
        >>> br1.missing_revisions(br2)
 
696
        [u'REVISION-ID-1']
 
697
        >>> br2.missing_revisions(br1)
 
698
        []
 
699
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1")
 
700
        >>> br1.missing_revisions(br2)
 
701
        []
 
702
        >>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
 
703
        >>> br1.missing_revisions(br2)
 
704
        [u'REVISION-ID-2A']
 
705
        >>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
 
706
        >>> br1.missing_revisions(br2)
 
707
        Traceback (most recent call last):
 
708
        DivergedBranches: These branches have diverged.
 
709
        """
 
710
        self_history = self.revision_history()
 
711
        self_len = len(self_history)
 
712
        other_history = other.revision_history()
 
713
        other_len = len(other_history)
 
714
        common_index = min(self_len, other_len) -1
 
715
        if common_index >= 0 and \
 
716
            self_history[common_index] != other_history[common_index]:
 
717
            raise DivergedBranches(self, other)
 
718
 
 
719
        if stop_revision is None:
 
720
            stop_revision = other_len
 
721
        elif stop_revision > other_len:
 
722
            raise NoSuchRevision(self, stop_revision)
 
723
        
 
724
        return other_history[self_len:stop_revision]
 
725
 
 
726
 
 
727
    def update_revisions(self, other, stop_revision=None):
 
728
        """Pull in all new revisions from other branch.
 
729
        
 
730
        >>> from bzrlib.commit import commit
 
731
        >>> bzrlib.trace.silent = True
 
732
        >>> br1 = ScratchBranch(files=['foo', 'bar'])
 
733
        >>> br1.add('foo')
 
734
        >>> br1.add('bar')
 
735
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
 
736
        >>> br2 = ScratchBranch()
 
737
        >>> br2.update_revisions(br1)
 
738
        Added 2 texts.
 
739
        Added 1 inventories.
 
740
        Added 1 revisions.
 
741
        >>> br2.revision_history()
 
742
        [u'REVISION-ID-1']
 
743
        >>> br2.update_revisions(br1)
 
744
        Added 0 texts.
 
745
        Added 0 inventories.
 
746
        Added 0 revisions.
 
747
        >>> br1.text_store.total_size() == br2.text_store.total_size()
 
748
        True
 
749
        """
 
750
        from bzrlib.progress import ProgressBar
 
751
 
 
752
        pb = ProgressBar()
 
753
 
 
754
        pb.update('comparing histories')
 
755
        revision_ids = self.missing_revisions(other, stop_revision)
 
756
        revisions = []
 
757
        needed_texts = sets.Set()
 
758
        i = 0
 
759
        for rev_id in revision_ids:
 
760
            i += 1
 
761
            pb.update('fetching revision', i, len(revision_ids))
 
762
            rev = other.get_revision(rev_id)
 
763
            revisions.append(rev)
 
764
            inv = other.get_inventory(str(rev.inventory_id))
 
765
            for key, entry in inv.iter_entries():
 
766
                if entry.text_id is None:
 
767
                    continue
 
768
                if entry.text_id not in self.text_store:
 
769
                    needed_texts.add(entry.text_id)
 
770
 
 
771
        pb.clear()
 
772
                    
 
773
        count = self.text_store.copy_multi(other.text_store, needed_texts)
 
774
        print "Added %d texts." % count 
 
775
        inventory_ids = [ f.inventory_id for f in revisions ]
 
776
        count = self.inventory_store.copy_multi(other.inventory_store, 
 
777
                                                inventory_ids)
 
778
        print "Added %d inventories." % count 
 
779
        revision_ids = [ f.revision_id for f in revisions]
 
780
        count = self.revision_store.copy_multi(other.revision_store, 
 
781
                                               revision_ids)
 
782
        for revision_id in revision_ids:
 
783
            self.append_revision(revision_id)
 
784
        print "Added %d revisions." % count
 
785
                    
 
786
        
 
787
    def commit(self, *args, **kw):
 
788
        """Deprecated"""
 
789
        from bzrlib.commit import commit
 
790
        commit(self, *args, **kw)
 
791
        
 
792
 
 
793
    def lookup_revision(self, revno):
 
794
        """Return revision hash for revision number."""
 
795
        if revno == 0:
 
796
            return None
 
797
 
 
798
        try:
 
799
            # list is 0-based; revisions are 1-based
 
800
            return self.revision_history()[revno-1]
 
801
        except IndexError:
 
802
            raise BzrError("no such revision %s" % revno)
 
803
 
 
804
 
 
805
    def revision_tree(self, revision_id):
 
806
        """Return Tree for a revision on this branch.
 
807
 
 
808
        `revision_id` may be None for the null revision, in which case
 
809
        an `EmptyTree` is returned."""
 
810
        # TODO: refactor this to use an existing revision object
 
811
        # so we don't need to read it in twice.
 
812
        if revision_id == None:
 
813
            return EmptyTree()
 
814
        else:
 
815
            inv = self.get_revision_inventory(revision_id)
 
816
            return RevisionTree(self.text_store, inv)
 
817
 
 
818
 
 
819
    def working_tree(self):
 
820
        """Return a `Tree` for the working copy."""
 
821
        from workingtree import WorkingTree
 
822
        return WorkingTree(self.base, self.read_working_inventory())
 
823
 
 
824
 
 
825
    def basis_tree(self):
 
826
        """Return `Tree` object for last revision.
 
827
 
 
828
        If there are no revisions yet, return an `EmptyTree`.
 
829
        """
 
830
        r = self.last_patch()
 
831
        if r == None:
 
832
            return EmptyTree()
 
833
        else:
 
834
            return RevisionTree(self.text_store, self.get_revision_inventory(r))
 
835
 
 
836
 
 
837
 
 
838
    def rename_one(self, from_rel, to_rel):
 
839
        """Rename one file.
 
840
 
 
841
        This can change the directory or the filename or both.
 
842
        """
 
843
        self.lock_write()
 
844
        try:
 
845
            tree = self.working_tree()
 
846
            inv = tree.inventory
 
847
            if not tree.has_filename(from_rel):
 
848
                raise BzrError("can't rename: old working file %r does not exist" % from_rel)
 
849
            if tree.has_filename(to_rel):
 
850
                raise BzrError("can't rename: new working file %r already exists" % to_rel)
 
851
 
 
852
            file_id = inv.path2id(from_rel)
 
853
            if file_id == None:
 
854
                raise BzrError("can't rename: old name %r is not versioned" % from_rel)
 
855
 
 
856
            if inv.path2id(to_rel):
 
857
                raise BzrError("can't rename: new name %r is already versioned" % to_rel)
 
858
 
 
859
            to_dir, to_tail = os.path.split(to_rel)
 
860
            to_dir_id = inv.path2id(to_dir)
 
861
            if to_dir_id == None and to_dir != '':
 
862
                raise BzrError("can't determine destination directory id for %r" % to_dir)
 
863
 
 
864
            mutter("rename_one:")
 
865
            mutter("  file_id    {%s}" % file_id)
 
866
            mutter("  from_rel   %r" % from_rel)
 
867
            mutter("  to_rel     %r" % to_rel)
 
868
            mutter("  to_dir     %r" % to_dir)
 
869
            mutter("  to_dir_id  {%s}" % to_dir_id)
 
870
 
 
871
            inv.rename(file_id, to_dir_id, to_tail)
 
872
 
 
873
            print "%s => %s" % (from_rel, to_rel)
 
874
 
 
875
            from_abs = self.abspath(from_rel)
 
876
            to_abs = self.abspath(to_rel)
 
877
            try:
 
878
                os.rename(from_abs, to_abs)
 
879
            except OSError, e:
 
880
                raise BzrError("failed to rename %r to %r: %s"
 
881
                        % (from_abs, to_abs, e[1]),
 
882
                        ["rename rolled back"])
 
883
 
 
884
            self._write_inventory(inv)
 
885
        finally:
 
886
            self.unlock()
 
887
 
 
888
 
 
889
    def move(self, from_paths, to_name):
 
890
        """Rename files.
 
891
 
 
892
        to_name must exist as a versioned directory.
 
893
 
 
894
        If to_name exists and is a directory, the files are moved into
 
895
        it, keeping their old names.  If it is a directory, 
 
896
 
 
897
        Note that to_name is only the last component of the new name;
 
898
        this doesn't change the directory.
 
899
        """
 
900
        self.lock_write()
 
901
        try:
 
902
            ## TODO: Option to move IDs only
 
903
            assert not isinstance(from_paths, basestring)
 
904
            tree = self.working_tree()
 
905
            inv = tree.inventory
 
906
            to_abs = self.abspath(to_name)
 
907
            if not isdir(to_abs):
 
908
                raise BzrError("destination %r is not a directory" % to_abs)
 
909
            if not tree.has_filename(to_name):
 
910
                raise BzrError("destination %r not in working directory" % to_abs)
 
911
            to_dir_id = inv.path2id(to_name)
 
912
            if to_dir_id == None and to_name != '':
 
913
                raise BzrError("destination %r is not a versioned directory" % to_name)
 
914
            to_dir_ie = inv[to_dir_id]
 
915
            if to_dir_ie.kind not in ('directory', 'root_directory'):
 
916
                raise BzrError("destination %r is not a directory" % to_abs)
 
917
 
 
918
            to_idpath = inv.get_idpath(to_dir_id)
 
919
 
 
920
            for f in from_paths:
 
921
                if not tree.has_filename(f):
 
922
                    raise BzrError("%r does not exist in working tree" % f)
 
923
                f_id = inv.path2id(f)
 
924
                if f_id == None:
 
925
                    raise BzrError("%r is not versioned" % f)
 
926
                name_tail = splitpath(f)[-1]
 
927
                dest_path = appendpath(to_name, name_tail)
 
928
                if tree.has_filename(dest_path):
 
929
                    raise BzrError("destination %r already exists" % dest_path)
 
930
                if f_id in to_idpath:
 
931
                    raise BzrError("can't move %r to a subdirectory of itself" % f)
 
932
 
 
933
            # OK, so there's a race here, it's possible that someone will
 
934
            # create a file in this interval and then the rename might be
 
935
            # left half-done.  But we should have caught most problems.
 
936
 
 
937
            for f in from_paths:
 
938
                name_tail = splitpath(f)[-1]
 
939
                dest_path = appendpath(to_name, name_tail)
 
940
                print "%s => %s" % (f, dest_path)
 
941
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
 
942
                try:
 
943
                    os.rename(self.abspath(f), self.abspath(dest_path))
 
944
                except OSError, e:
 
945
                    raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
 
946
                            ["rename rolled back"])
 
947
 
 
948
            self._write_inventory(inv)
 
949
        finally:
 
950
            self.unlock()
 
951
 
 
952
 
 
953
 
 
954
class ScratchBranch(Branch):
 
955
    """Special test class: a branch that cleans up after itself.
 
956
 
 
957
    >>> b = ScratchBranch()
 
958
    >>> isdir(b.base)
 
959
    True
 
960
    >>> bd = b.base
 
961
    >>> b.destroy()
 
962
    >>> isdir(bd)
 
963
    False
 
964
    """
 
965
    def __init__(self, files=[], dirs=[], base=None):
 
966
        """Make a test branch.
 
967
 
 
968
        This creates a temporary directory and runs init-tree in it.
 
969
 
 
970
        If any files are listed, they are created in the working copy.
 
971
        """
 
972
        init = False
 
973
        if base is None:
 
974
            base = tempfile.mkdtemp()
 
975
            init = True
 
976
        Branch.__init__(self, base, init=init)
 
977
        for d in dirs:
 
978
            os.mkdir(self.abspath(d))
 
979
            
 
980
        for f in files:
 
981
            file(os.path.join(self.base, f), 'w').write('content of %s' % f)
 
982
 
 
983
 
 
984
    def clone(self):
 
985
        """
 
986
        >>> orig = ScratchBranch(files=["file1", "file2"])
 
987
        >>> clone = orig.clone()
 
988
        >>> os.path.samefile(orig.base, clone.base)
 
989
        False
 
990
        >>> os.path.isfile(os.path.join(clone.base, "file1"))
 
991
        True
 
992
        """
 
993
        base = tempfile.mkdtemp()
 
994
        os.rmdir(base)
 
995
        shutil.copytree(self.base, base, symlinks=True)
 
996
        return ScratchBranch(base=base)
 
997
        
 
998
    def __del__(self):
 
999
        self.destroy()
 
1000
 
 
1001
    def destroy(self):
 
1002
        """Destroy the test branch, removing the scratch directory."""
 
1003
        try:
 
1004
            if self.base:
 
1005
                mutter("delete ScratchBranch %s" % self.base)
 
1006
                shutil.rmtree(self.base)
 
1007
        except OSError, e:
 
1008
            # Work around for shutil.rmtree failing on Windows when
 
1009
            # readonly files are encountered
 
1010
            mutter("hit exception in destroying ScratchBranch: %s" % e)
 
1011
            for root, dirs, files in os.walk(self.base, topdown=False):
 
1012
                for name in files:
 
1013
                    os.chmod(os.path.join(root, name), 0700)
 
1014
            shutil.rmtree(self.base)
 
1015
        self.base = None
 
1016
 
 
1017
    
 
1018
 
 
1019
######################################################################
 
1020
# predicates
 
1021
 
 
1022
 
 
1023
def is_control_file(filename):
 
1024
    ## FIXME: better check
 
1025
    filename = os.path.normpath(filename)
 
1026
    while filename != '':
 
1027
        head, tail = os.path.split(filename)
 
1028
        ## mutter('check %r for control file' % ((head, tail), ))
 
1029
        if tail == bzrlib.BZRDIR:
 
1030
            return True
 
1031
        if filename == head:
 
1032
            break
 
1033
        filename = head
 
1034
    return False
 
1035
 
 
1036
 
 
1037
 
 
1038
def gen_file_id(name):
 
1039
    """Return new file id.
 
1040
 
 
1041
    This should probably generate proper UUIDs, but for the moment we
 
1042
    cope with just randomness because running uuidgen every time is
 
1043
    slow."""
 
1044
    import re
 
1045
 
 
1046
    # get last component
 
1047
    idx = name.rfind('/')
 
1048
    if idx != -1:
 
1049
        name = name[idx+1 : ]
 
1050
    idx = name.rfind('\\')
 
1051
    if idx != -1:
 
1052
        name = name[idx+1 : ]
 
1053
 
 
1054
    # make it not a hidden file
 
1055
    name = name.lstrip('.')
 
1056
 
 
1057
    # remove any wierd characters; we don't escape them but rather
 
1058
    # just pull them out
 
1059
    name = re.sub(r'[^\w.]', '', name)
 
1060
 
 
1061
    s = hexlify(rand_bytes(8))
 
1062
    return '-'.join((name, compact_date(time.time()), s))