/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:33:22 UTC
  • Revision ID: mbp@sourcefrog.net-20050611013322-f12014bf65accd0c
- don't show progress bar unless completion is known

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