/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-11 01:58:46 UTC
  • Revision ID: mbp@sourcefrog.net-20050611015846-025426c28372ea3f
- lock branch while checking

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