/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 06:34:26 UTC
  • Revision ID: mbp@sourcefrog.net-20050610063426-cfcf5c0f96c271ec
- split out updated progress indicator

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
        """If self and other have not diverged, ensure self has all the
 
699
        revisions in other
 
700
 
 
701
        >>> from bzrlib.commit import commit
 
702
        >>> bzrlib.trace.silent = True
 
703
        >>> br1 = ScratchBranch(files=['foo', 'bar'])
 
704
        >>> br1.add('foo')
 
705
        >>> br1.add('bar')
 
706
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
 
707
        >>> br2 = ScratchBranch()
 
708
        >>> br2.update_revisions(br1)
 
709
        Added 2 texts.
 
710
        Added 1 inventories.
 
711
        Added 1 revisions.
 
712
        >>> br2.revision_history()
 
713
        [u'REVISION-ID-1']
 
714
        >>> br2.update_revisions(br1)
 
715
        Added 0 texts.
 
716
        Added 0 inventories.
 
717
        Added 0 revisions.
 
718
        >>> br1.text_store.total_size() == br2.text_store.total_size()
 
719
        True
 
720
        """
 
721
        revision_ids = self.missing_revisions(other)
 
722
        revisions = [other.get_revision(f) for f in revision_ids]
 
723
        needed_texts = sets.Set()
 
724
        for rev in revisions:
 
725
            inv = other.get_inventory(str(rev.inventory_id))
 
726
            for key, entry in inv.iter_entries():
 
727
                if entry.text_id is None:
 
728
                    continue
 
729
                if entry.text_id not in self.text_store:
 
730
                    needed_texts.add(entry.text_id)
 
731
        count = self.text_store.copy_multi(other.text_store, needed_texts)
 
732
        print "Added %d texts." % count 
 
733
        inventory_ids = [ f.inventory_id for f in revisions ]
 
734
        count = self.inventory_store.copy_multi(other.inventory_store, 
 
735
                                                inventory_ids)
 
736
        print "Added %d inventories." % count 
 
737
        revision_ids = [ f.revision_id for f in revisions]
 
738
        count = self.revision_store.copy_multi(other.revision_store, 
 
739
                                               revision_ids)
 
740
        for revision_id in revision_ids:
 
741
            self.append_revision(revision_id)
 
742
        print "Added %d revisions." % count
 
743
                    
 
744
        
 
745
    def commit(self, *args, **kw):
 
746
        """Deprecated"""
 
747
        from bzrlib.commit import commit
 
748
        commit(self, *args, **kw)
 
749
        
 
750
 
 
751
    def lookup_revision(self, revno):
 
752
        """Return revision hash for revision number."""
 
753
        if revno == 0:
 
754
            return None
 
755
 
 
756
        try:
 
757
            # list is 0-based; revisions are 1-based
 
758
            return self.revision_history()[revno-1]
 
759
        except IndexError:
 
760
            raise BzrError("no such revision %s" % revno)
 
761
 
 
762
 
 
763
    def revision_tree(self, revision_id):
 
764
        """Return Tree for a revision on this branch.
 
765
 
 
766
        `revision_id` may be None for the null revision, in which case
 
767
        an `EmptyTree` is returned."""
 
768
        # TODO: refactor this to use an existing revision object
 
769
        # so we don't need to read it in twice.
 
770
        if revision_id == None:
 
771
            return EmptyTree()
 
772
        else:
 
773
            inv = self.get_revision_inventory(revision_id)
 
774
            return RevisionTree(self.text_store, inv)
 
775
 
 
776
 
 
777
    def working_tree(self):
 
778
        """Return a `Tree` for the working copy."""
 
779
        from workingtree import WorkingTree
 
780
        return WorkingTree(self.base, self.read_working_inventory())
 
781
 
 
782
 
 
783
    def basis_tree(self):
 
784
        """Return `Tree` object for last revision.
 
785
 
 
786
        If there are no revisions yet, return an `EmptyTree`.
 
787
        """
 
788
        r = self.last_patch()
 
789
        if r == None:
 
790
            return EmptyTree()
 
791
        else:
 
792
            return RevisionTree(self.text_store, self.get_revision_inventory(r))
 
793
 
 
794
 
 
795
 
 
796
    def rename_one(self, from_rel, to_rel):
 
797
        """Rename one file.
 
798
 
 
799
        This can change the directory or the filename or both.
 
800
        """
 
801
        self.lock_write()
 
802
        try:
 
803
            tree = self.working_tree()
 
804
            inv = tree.inventory
 
805
            if not tree.has_filename(from_rel):
 
806
                raise BzrError("can't rename: old working file %r does not exist" % from_rel)
 
807
            if tree.has_filename(to_rel):
 
808
                raise BzrError("can't rename: new working file %r already exists" % to_rel)
 
809
 
 
810
            file_id = inv.path2id(from_rel)
 
811
            if file_id == None:
 
812
                raise BzrError("can't rename: old name %r is not versioned" % from_rel)
 
813
 
 
814
            if inv.path2id(to_rel):
 
815
                raise BzrError("can't rename: new name %r is already versioned" % to_rel)
 
816
 
 
817
            to_dir, to_tail = os.path.split(to_rel)
 
818
            to_dir_id = inv.path2id(to_dir)
 
819
            if to_dir_id == None and to_dir != '':
 
820
                raise BzrError("can't determine destination directory id for %r" % to_dir)
 
821
 
 
822
            mutter("rename_one:")
 
823
            mutter("  file_id    {%s}" % file_id)
 
824
            mutter("  from_rel   %r" % from_rel)
 
825
            mutter("  to_rel     %r" % to_rel)
 
826
            mutter("  to_dir     %r" % to_dir)
 
827
            mutter("  to_dir_id  {%s}" % to_dir_id)
 
828
 
 
829
            inv.rename(file_id, to_dir_id, to_tail)
 
830
 
 
831
            print "%s => %s" % (from_rel, to_rel)
 
832
 
 
833
            from_abs = self.abspath(from_rel)
 
834
            to_abs = self.abspath(to_rel)
 
835
            try:
 
836
                os.rename(from_abs, to_abs)
 
837
            except OSError, e:
 
838
                raise BzrError("failed to rename %r to %r: %s"
 
839
                        % (from_abs, to_abs, e[1]),
 
840
                        ["rename rolled back"])
 
841
 
 
842
            self._write_inventory(inv)
 
843
        finally:
 
844
            self.unlock()
 
845
 
 
846
 
 
847
    def move(self, from_paths, to_name):
 
848
        """Rename files.
 
849
 
 
850
        to_name must exist as a versioned directory.
 
851
 
 
852
        If to_name exists and is a directory, the files are moved into
 
853
        it, keeping their old names.  If it is a directory, 
 
854
 
 
855
        Note that to_name is only the last component of the new name;
 
856
        this doesn't change the directory.
 
857
        """
 
858
        self.lock_write()
 
859
        try:
 
860
            ## TODO: Option to move IDs only
 
861
            assert not isinstance(from_paths, basestring)
 
862
            tree = self.working_tree()
 
863
            inv = tree.inventory
 
864
            to_abs = self.abspath(to_name)
 
865
            if not isdir(to_abs):
 
866
                raise BzrError("destination %r is not a directory" % to_abs)
 
867
            if not tree.has_filename(to_name):
 
868
                raise BzrError("destination %r not in working directory" % to_abs)
 
869
            to_dir_id = inv.path2id(to_name)
 
870
            if to_dir_id == None and to_name != '':
 
871
                raise BzrError("destination %r is not a versioned directory" % to_name)
 
872
            to_dir_ie = inv[to_dir_id]
 
873
            if to_dir_ie.kind not in ('directory', 'root_directory'):
 
874
                raise BzrError("destination %r is not a directory" % to_abs)
 
875
 
 
876
            to_idpath = inv.get_idpath(to_dir_id)
 
877
 
 
878
            for f in from_paths:
 
879
                if not tree.has_filename(f):
 
880
                    raise BzrError("%r does not exist in working tree" % f)
 
881
                f_id = inv.path2id(f)
 
882
                if f_id == None:
 
883
                    raise BzrError("%r is not versioned" % f)
 
884
                name_tail = splitpath(f)[-1]
 
885
                dest_path = appendpath(to_name, name_tail)
 
886
                if tree.has_filename(dest_path):
 
887
                    raise BzrError("destination %r already exists" % dest_path)
 
888
                if f_id in to_idpath:
 
889
                    raise BzrError("can't move %r to a subdirectory of itself" % f)
 
890
 
 
891
            # OK, so there's a race here, it's possible that someone will
 
892
            # create a file in this interval and then the rename might be
 
893
            # left half-done.  But we should have caught most problems.
 
894
 
 
895
            for f in from_paths:
 
896
                name_tail = splitpath(f)[-1]
 
897
                dest_path = appendpath(to_name, name_tail)
 
898
                print "%s => %s" % (f, dest_path)
 
899
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
 
900
                try:
 
901
                    os.rename(self.abspath(f), self.abspath(dest_path))
 
902
                except OSError, e:
 
903
                    raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
 
904
                            ["rename rolled back"])
 
905
 
 
906
            self._write_inventory(inv)
 
907
        finally:
 
908
            self.unlock()
 
909
 
 
910
 
 
911
 
 
912
class ScratchBranch(Branch):
 
913
    """Special test class: a branch that cleans up after itself.
 
914
 
 
915
    >>> b = ScratchBranch()
 
916
    >>> isdir(b.base)
 
917
    True
 
918
    >>> bd = b.base
 
919
    >>> b.destroy()
 
920
    >>> isdir(bd)
 
921
    False
 
922
    """
 
923
    def __init__(self, files=[], dirs=[], base=None):
 
924
        """Make a test branch.
 
925
 
 
926
        This creates a temporary directory and runs init-tree in it.
 
927
 
 
928
        If any files are listed, they are created in the working copy.
 
929
        """
 
930
        init = False
 
931
        if base is None:
 
932
            base = tempfile.mkdtemp()
 
933
            init = True
 
934
        Branch.__init__(self, base, init=init)
 
935
        for d in dirs:
 
936
            os.mkdir(self.abspath(d))
 
937
            
 
938
        for f in files:
 
939
            file(os.path.join(self.base, f), 'w').write('content of %s' % f)
 
940
 
 
941
 
 
942
    def clone(self):
 
943
        """
 
944
        >>> orig = ScratchBranch(files=["file1", "file2"])
 
945
        >>> clone = orig.clone()
 
946
        >>> os.path.samefile(orig.base, clone.base)
 
947
        False
 
948
        >>> os.path.isfile(os.path.join(clone.base, "file1"))
 
949
        True
 
950
        """
 
951
        base = tempfile.mkdtemp()
 
952
        os.rmdir(base)
 
953
        shutil.copytree(self.base, base, symlinks=True)
 
954
        return ScratchBranch(base=base)
 
955
        
 
956
    def __del__(self):
 
957
        self.destroy()
 
958
 
 
959
    def destroy(self):
 
960
        """Destroy the test branch, removing the scratch directory."""
 
961
        try:
 
962
            if self.base:
 
963
                mutter("delete ScratchBranch %s" % self.base)
 
964
                shutil.rmtree(self.base)
 
965
        except OSError, e:
 
966
            # Work around for shutil.rmtree failing on Windows when
 
967
            # readonly files are encountered
 
968
            mutter("hit exception in destroying ScratchBranch: %s" % e)
 
969
            for root, dirs, files in os.walk(self.base, topdown=False):
 
970
                for name in files:
 
971
                    os.chmod(os.path.join(root, name), 0700)
 
972
            shutil.rmtree(self.base)
 
973
        self.base = None
 
974
 
 
975
    
 
976
 
 
977
######################################################################
 
978
# predicates
 
979
 
 
980
 
 
981
def is_control_file(filename):
 
982
    ## FIXME: better check
 
983
    filename = os.path.normpath(filename)
 
984
    while filename != '':
 
985
        head, tail = os.path.split(filename)
 
986
        ## mutter('check %r for control file' % ((head, tail), ))
 
987
        if tail == bzrlib.BZRDIR:
 
988
            return True
 
989
        if filename == head:
 
990
            break
 
991
        filename = head
 
992
    return False
 
993
 
 
994
 
 
995
 
 
996
def gen_file_id(name):
 
997
    """Return new file id.
 
998
 
 
999
    This should probably generate proper UUIDs, but for the moment we
 
1000
    cope with just randomness because running uuidgen every time is
 
1001
    slow."""
 
1002
    import re
 
1003
 
 
1004
    # get last component
 
1005
    idx = name.rfind('/')
 
1006
    if idx != -1:
 
1007
        name = name[idx+1 : ]
 
1008
    idx = name.rfind('\\')
 
1009
    if idx != -1:
 
1010
        name = name[idx+1 : ]
 
1011
 
 
1012
    # make it not a hidden file
 
1013
    name = name.lstrip('.')
 
1014
 
 
1015
    # remove any wierd characters; we don't escape them but rather
 
1016
    # just pull them out
 
1017
    name = re.sub(r'[^\w.]', '', name)
 
1018
 
 
1019
    s = hexlify(rand_bytes(8))
 
1020
    return '-'.join((name, compact_date(time.time()), s))