/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-10 09:30:57 UTC
  • Revision ID: mbp@sourcefrog.net-20050610093057-23705fac7f7f956e
todo

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_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
        r = Revision.read_xml(self.revision_store[revision_id])
 
536
        assert r.revision_id == revision_id
 
537
        return r
 
538
 
 
539
 
 
540
    def get_inventory(self, inventory_id):
 
541
        """Get Inventory object by hash.
 
542
 
 
543
        TODO: Perhaps for this and similar methods, take a revision
 
544
               parameter which can be either an integer revno or a
 
545
               string hash."""
 
546
        i = Inventory.read_xml(self.inventory_store[inventory_id])
 
547
        return i
 
548
 
 
549
 
 
550
    def get_revision_inventory(self, revision_id):
 
551
        """Return inventory of a past revision."""
 
552
        if revision_id == None:
 
553
            return Inventory()
 
554
        else:
 
555
            return self.get_inventory(self.get_revision(revision_id).inventory_id)
 
556
 
 
557
 
 
558
    def revision_history(self):
 
559
        """Return sequence of revision hashes on to this branch.
 
560
 
 
561
        >>> ScratchBranch().revision_history()
 
562
        []
 
563
        """
 
564
        self.lock_read()
 
565
        try:
 
566
            return [l.rstrip('\r\n') for l in
 
567
                    self.controlfile('revision-history', 'r').readlines()]
 
568
        finally:
 
569
            self.unlock()
 
570
 
 
571
 
 
572
    def common_ancestor(self, other, self_revno=None, other_revno=None):
 
573
        """
 
574
        >>> import commit
 
575
        >>> sb = ScratchBranch(files=['foo', 'foo~'])
 
576
        >>> sb.common_ancestor(sb) == (None, None)
 
577
        True
 
578
        >>> commit.commit(sb, "Committing first revision", verbose=False)
 
579
        >>> sb.common_ancestor(sb)[0]
 
580
        1
 
581
        >>> clone = sb.clone()
 
582
        >>> commit.commit(sb, "Committing second revision", verbose=False)
 
583
        >>> sb.common_ancestor(sb)[0]
 
584
        2
 
585
        >>> sb.common_ancestor(clone)[0]
 
586
        1
 
587
        >>> commit.commit(clone, "Committing divergent second revision", 
 
588
        ...               verbose=False)
 
589
        >>> sb.common_ancestor(clone)[0]
 
590
        1
 
591
        >>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
 
592
        True
 
593
        >>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
 
594
        True
 
595
        >>> clone2 = sb.clone()
 
596
        >>> sb.common_ancestor(clone2)[0]
 
597
        2
 
598
        >>> sb.common_ancestor(clone2, self_revno=1)[0]
 
599
        1
 
600
        >>> sb.common_ancestor(clone2, other_revno=1)[0]
 
601
        1
 
602
        """
 
603
        my_history = self.revision_history()
 
604
        other_history = other.revision_history()
 
605
        if self_revno is None:
 
606
            self_revno = len(my_history)
 
607
        if other_revno is None:
 
608
            other_revno = len(other_history)
 
609
        indices = range(min((self_revno, other_revno)))
 
610
        indices.reverse()
 
611
        for r in indices:
 
612
            if my_history[r] == other_history[r]:
 
613
                return r+1, my_history[r]
 
614
        return None, None
 
615
 
 
616
    def enum_history(self, direction):
 
617
        """Return (revno, revision_id) for history of branch.
 
618
 
 
619
        direction
 
620
            'forward' is from earliest to latest
 
621
            'reverse' is from latest to earliest
 
622
        """
 
623
        rh = self.revision_history()
 
624
        if direction == 'forward':
 
625
            i = 1
 
626
            for rid in rh:
 
627
                yield i, rid
 
628
                i += 1
 
629
        elif direction == 'reverse':
 
630
            i = len(rh)
 
631
            while i > 0:
 
632
                yield i, rh[i-1]
 
633
                i -= 1
 
634
        else:
 
635
            raise ValueError('invalid history direction', direction)
 
636
 
 
637
 
 
638
    def revno(self):
 
639
        """Return current revision number for this branch.
 
640
 
 
641
        That is equivalent to the number of revisions committed to
 
642
        this branch.
 
643
        """
 
644
        return len(self.revision_history())
 
645
 
 
646
 
 
647
    def last_patch(self):
 
648
        """Return last patch hash, or None if no history.
 
649
        """
 
650
        ph = self.revision_history()
 
651
        if ph:
 
652
            return ph[-1]
 
653
        else:
 
654
            return None
 
655
 
 
656
 
 
657
    def missing_revisions(self, other):
 
658
        """
 
659
        If self and other have not diverged, return a list of the revisions
 
660
        present in other, but missing from self.
 
661
 
 
662
        >>> from bzrlib.commit import commit
 
663
        >>> bzrlib.trace.silent = True
 
664
        >>> br1 = ScratchBranch()
 
665
        >>> br2 = ScratchBranch()
 
666
        >>> br1.missing_revisions(br2)
 
667
        []
 
668
        >>> commit(br2, "lala!", rev_id="REVISION-ID-1")
 
669
        >>> br1.missing_revisions(br2)
 
670
        [u'REVISION-ID-1']
 
671
        >>> br2.missing_revisions(br1)
 
672
        []
 
673
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1")
 
674
        >>> br1.missing_revisions(br2)
 
675
        []
 
676
        >>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
 
677
        >>> br1.missing_revisions(br2)
 
678
        [u'REVISION-ID-2A']
 
679
        >>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
 
680
        >>> br1.missing_revisions(br2)
 
681
        Traceback (most recent call last):
 
682
        DivergedBranches: These branches have diverged.
 
683
        """
 
684
        self_history = self.revision_history()
 
685
        self_len = len(self_history)
 
686
        other_history = other.revision_history()
 
687
        other_len = len(other_history)
 
688
        common_index = min(self_len, other_len) -1
 
689
        if common_index >= 0 and \
 
690
            self_history[common_index] != other_history[common_index]:
 
691
            raise DivergedBranches(self, other)
 
692
        if self_len < other_len:
 
693
            return other_history[self_len:]
 
694
        return []
 
695
 
 
696
 
 
697
    def update_revisions(self, other):
 
698
        """Pull in all new revisions from other branch.
 
699
        
 
700
        >>> from bzrlib.commit import commit
 
701
        >>> bzrlib.trace.silent = True
 
702
        >>> br1 = ScratchBranch(files=['foo', 'bar'])
 
703
        >>> br1.add('foo')
 
704
        >>> br1.add('bar')
 
705
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
 
706
        >>> br2 = ScratchBranch()
 
707
        >>> br2.update_revisions(br1)
 
708
        Added 2 texts.
 
709
        Added 1 inventories.
 
710
        Added 1 revisions.
 
711
        >>> br2.revision_history()
 
712
        [u'REVISION-ID-1']
 
713
        >>> br2.update_revisions(br1)
 
714
        Added 0 texts.
 
715
        Added 0 inventories.
 
716
        Added 0 revisions.
 
717
        >>> br1.text_store.total_size() == br2.text_store.total_size()
 
718
        True
 
719
        """
 
720
        revision_ids = self.missing_revisions(other)
 
721
        revisions = [other.get_revision(f) for f in revision_ids]
 
722
        needed_texts = sets.Set()
 
723
        for rev in revisions:
 
724
            inv = other.get_inventory(str(rev.inventory_id))
 
725
            for key, entry in inv.iter_entries():
 
726
                if entry.text_id is None:
 
727
                    continue
 
728
                if entry.text_id not in self.text_store:
 
729
                    needed_texts.add(entry.text_id)
 
730
        count = self.text_store.copy_multi(other.text_store, needed_texts)
 
731
        print "Added %d texts." % count 
 
732
        inventory_ids = [ f.inventory_id for f in revisions ]
 
733
        count = self.inventory_store.copy_multi(other.inventory_store, 
 
734
                                                inventory_ids)
 
735
        print "Added %d inventories." % count 
 
736
        revision_ids = [ f.revision_id for f in revisions]
 
737
        count = self.revision_store.copy_multi(other.revision_store, 
 
738
                                               revision_ids)
 
739
        for revision_id in revision_ids:
 
740
            self.append_revision(revision_id)
 
741
        print "Added %d revisions." % count
 
742
                    
 
743
        
 
744
    def commit(self, *args, **kw):
 
745
        """Deprecated"""
 
746
        from bzrlib.commit import commit
 
747
        commit(self, *args, **kw)
 
748
        
 
749
 
 
750
    def lookup_revision(self, revno):
 
751
        """Return revision hash for revision number."""
 
752
        if revno == 0:
 
753
            return None
 
754
 
 
755
        try:
 
756
            # list is 0-based; revisions are 1-based
 
757
            return self.revision_history()[revno-1]
 
758
        except IndexError:
 
759
            raise BzrError("no such revision %s" % revno)
 
760
 
 
761
 
 
762
    def revision_tree(self, revision_id):
 
763
        """Return Tree for a revision on this branch.
 
764
 
 
765
        `revision_id` may be None for the null revision, in which case
 
766
        an `EmptyTree` is returned."""
 
767
        # TODO: refactor this to use an existing revision object
 
768
        # so we don't need to read it in twice.
 
769
        if revision_id == None:
 
770
            return EmptyTree()
 
771
        else:
 
772
            inv = self.get_revision_inventory(revision_id)
 
773
            return RevisionTree(self.text_store, inv)
 
774
 
 
775
 
 
776
    def working_tree(self):
 
777
        """Return a `Tree` for the working copy."""
 
778
        from workingtree import WorkingTree
 
779
        return WorkingTree(self.base, self.read_working_inventory())
 
780
 
 
781
 
 
782
    def basis_tree(self):
 
783
        """Return `Tree` object for last revision.
 
784
 
 
785
        If there are no revisions yet, return an `EmptyTree`.
 
786
        """
 
787
        r = self.last_patch()
 
788
        if r == None:
 
789
            return EmptyTree()
 
790
        else:
 
791
            return RevisionTree(self.text_store, self.get_revision_inventory(r))
 
792
 
 
793
 
 
794
 
 
795
    def rename_one(self, from_rel, to_rel):
 
796
        """Rename one file.
 
797
 
 
798
        This can change the directory or the filename or both.
 
799
        """
 
800
        self.lock_write()
 
801
        try:
 
802
            tree = self.working_tree()
 
803
            inv = tree.inventory
 
804
            if not tree.has_filename(from_rel):
 
805
                raise BzrError("can't rename: old working file %r does not exist" % from_rel)
 
806
            if tree.has_filename(to_rel):
 
807
                raise BzrError("can't rename: new working file %r already exists" % to_rel)
 
808
 
 
809
            file_id = inv.path2id(from_rel)
 
810
            if file_id == None:
 
811
                raise BzrError("can't rename: old name %r is not versioned" % from_rel)
 
812
 
 
813
            if inv.path2id(to_rel):
 
814
                raise BzrError("can't rename: new name %r is already versioned" % to_rel)
 
815
 
 
816
            to_dir, to_tail = os.path.split(to_rel)
 
817
            to_dir_id = inv.path2id(to_dir)
 
818
            if to_dir_id == None and to_dir != '':
 
819
                raise BzrError("can't determine destination directory id for %r" % to_dir)
 
820
 
 
821
            mutter("rename_one:")
 
822
            mutter("  file_id    {%s}" % file_id)
 
823
            mutter("  from_rel   %r" % from_rel)
 
824
            mutter("  to_rel     %r" % to_rel)
 
825
            mutter("  to_dir     %r" % to_dir)
 
826
            mutter("  to_dir_id  {%s}" % to_dir_id)
 
827
 
 
828
            inv.rename(file_id, to_dir_id, to_tail)
 
829
 
 
830
            print "%s => %s" % (from_rel, to_rel)
 
831
 
 
832
            from_abs = self.abspath(from_rel)
 
833
            to_abs = self.abspath(to_rel)
 
834
            try:
 
835
                os.rename(from_abs, to_abs)
 
836
            except OSError, e:
 
837
                raise BzrError("failed to rename %r to %r: %s"
 
838
                        % (from_abs, to_abs, e[1]),
 
839
                        ["rename rolled back"])
 
840
 
 
841
            self._write_inventory(inv)
 
842
        finally:
 
843
            self.unlock()
 
844
 
 
845
 
 
846
    def move(self, from_paths, to_name):
 
847
        """Rename files.
 
848
 
 
849
        to_name must exist as a versioned directory.
 
850
 
 
851
        If to_name exists and is a directory, the files are moved into
 
852
        it, keeping their old names.  If it is a directory, 
 
853
 
 
854
        Note that to_name is only the last component of the new name;
 
855
        this doesn't change the directory.
 
856
        """
 
857
        self.lock_write()
 
858
        try:
 
859
            ## TODO: Option to move IDs only
 
860
            assert not isinstance(from_paths, basestring)
 
861
            tree = self.working_tree()
 
862
            inv = tree.inventory
 
863
            to_abs = self.abspath(to_name)
 
864
            if not isdir(to_abs):
 
865
                raise BzrError("destination %r is not a directory" % to_abs)
 
866
            if not tree.has_filename(to_name):
 
867
                raise BzrError("destination %r not in working directory" % to_abs)
 
868
            to_dir_id = inv.path2id(to_name)
 
869
            if to_dir_id == None and to_name != '':
 
870
                raise BzrError("destination %r is not a versioned directory" % to_name)
 
871
            to_dir_ie = inv[to_dir_id]
 
872
            if to_dir_ie.kind not in ('directory', 'root_directory'):
 
873
                raise BzrError("destination %r is not a directory" % to_abs)
 
874
 
 
875
            to_idpath = inv.get_idpath(to_dir_id)
 
876
 
 
877
            for f in from_paths:
 
878
                if not tree.has_filename(f):
 
879
                    raise BzrError("%r does not exist in working tree" % f)
 
880
                f_id = inv.path2id(f)
 
881
                if f_id == None:
 
882
                    raise BzrError("%r is not versioned" % f)
 
883
                name_tail = splitpath(f)[-1]
 
884
                dest_path = appendpath(to_name, name_tail)
 
885
                if tree.has_filename(dest_path):
 
886
                    raise BzrError("destination %r already exists" % dest_path)
 
887
                if f_id in to_idpath:
 
888
                    raise BzrError("can't move %r to a subdirectory of itself" % f)
 
889
 
 
890
            # OK, so there's a race here, it's possible that someone will
 
891
            # create a file in this interval and then the rename might be
 
892
            # left half-done.  But we should have caught most problems.
 
893
 
 
894
            for f in from_paths:
 
895
                name_tail = splitpath(f)[-1]
 
896
                dest_path = appendpath(to_name, name_tail)
 
897
                print "%s => %s" % (f, dest_path)
 
898
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
 
899
                try:
 
900
                    os.rename(self.abspath(f), self.abspath(dest_path))
 
901
                except OSError, e:
 
902
                    raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
 
903
                            ["rename rolled back"])
 
904
 
 
905
            self._write_inventory(inv)
 
906
        finally:
 
907
            self.unlock()
 
908
 
 
909
 
 
910
 
 
911
class ScratchBranch(Branch):
 
912
    """Special test class: a branch that cleans up after itself.
 
913
 
 
914
    >>> b = ScratchBranch()
 
915
    >>> isdir(b.base)
 
916
    True
 
917
    >>> bd = b.base
 
918
    >>> b.destroy()
 
919
    >>> isdir(bd)
 
920
    False
 
921
    """
 
922
    def __init__(self, files=[], dirs=[], base=None):
 
923
        """Make a test branch.
 
924
 
 
925
        This creates a temporary directory and runs init-tree in it.
 
926
 
 
927
        If any files are listed, they are created in the working copy.
 
928
        """
 
929
        init = False
 
930
        if base is None:
 
931
            base = tempfile.mkdtemp()
 
932
            init = True
 
933
        Branch.__init__(self, base, init=init)
 
934
        for d in dirs:
 
935
            os.mkdir(self.abspath(d))
 
936
            
 
937
        for f in files:
 
938
            file(os.path.join(self.base, f), 'w').write('content of %s' % f)
 
939
 
 
940
 
 
941
    def clone(self):
 
942
        """
 
943
        >>> orig = ScratchBranch(files=["file1", "file2"])
 
944
        >>> clone = orig.clone()
 
945
        >>> os.path.samefile(orig.base, clone.base)
 
946
        False
 
947
        >>> os.path.isfile(os.path.join(clone.base, "file1"))
 
948
        True
 
949
        """
 
950
        base = tempfile.mkdtemp()
 
951
        os.rmdir(base)
 
952
        shutil.copytree(self.base, base, symlinks=True)
 
953
        return ScratchBranch(base=base)
 
954
        
 
955
    def __del__(self):
 
956
        self.destroy()
 
957
 
 
958
    def destroy(self):
 
959
        """Destroy the test branch, removing the scratch directory."""
 
960
        try:
 
961
            if self.base:
 
962
                mutter("delete ScratchBranch %s" % self.base)
 
963
                shutil.rmtree(self.base)
 
964
        except OSError, e:
 
965
            # Work around for shutil.rmtree failing on Windows when
 
966
            # readonly files are encountered
 
967
            mutter("hit exception in destroying ScratchBranch: %s" % e)
 
968
            for root, dirs, files in os.walk(self.base, topdown=False):
 
969
                for name in files:
 
970
                    os.chmod(os.path.join(root, name), 0700)
 
971
            shutil.rmtree(self.base)
 
972
        self.base = None
 
973
 
 
974
    
 
975
 
 
976
######################################################################
 
977
# predicates
 
978
 
 
979
 
 
980
def is_control_file(filename):
 
981
    ## FIXME: better check
 
982
    filename = os.path.normpath(filename)
 
983
    while filename != '':
 
984
        head, tail = os.path.split(filename)
 
985
        ## mutter('check %r for control file' % ((head, tail), ))
 
986
        if tail == bzrlib.BZRDIR:
 
987
            return True
 
988
        if filename == head:
 
989
            break
 
990
        filename = head
 
991
    return False
 
992
 
 
993
 
 
994
 
 
995
def gen_file_id(name):
 
996
    """Return new file id.
 
997
 
 
998
    This should probably generate proper UUIDs, but for the moment we
 
999
    cope with just randomness because running uuidgen every time is
 
1000
    slow."""
 
1001
    import re
 
1002
 
 
1003
    # get last component
 
1004
    idx = name.rfind('/')
 
1005
    if idx != -1:
 
1006
        name = name[idx+1 : ]
 
1007
    idx = name.rfind('\\')
 
1008
    if idx != -1:
 
1009
        name = name[idx+1 : ]
 
1010
 
 
1011
    # make it not a hidden file
 
1012
    name = name.lstrip('.')
 
1013
 
 
1014
    # remove any wierd characters; we don't escape them but rather
 
1015
    # just pull them out
 
1016
    name = re.sub(r'[^\w.]', '', name)
 
1017
 
 
1018
    s = hexlify(rand_bytes(8))
 
1019
    return '-'.join((name, compact_date(time.time()), s))