/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

Partially fix pull.

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
 
from sets import Set
19
 
 
20
 
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
21
 
import traceback, socket, fnmatch, difflib, time
22
 
from binascii import hexlify
23
 
 
24
 
import bzrlib
25
 
from inventory import Inventory
26
 
from trace import mutter, note
27
 
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
28
 
from inventory import InventoryEntry, Inventory
29
 
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, chomp, \
30
 
     format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
31
 
     joinpath, sha_string, file_kind, local_time_offset
32
 
from store import ImmutableStore
33
 
from revision import Revision
34
 
from errors import bailout
35
 
from textui import show_status
36
 
from diff import diff_trees
37
 
 
38
 
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
39
 
## TODO: Maybe include checks for common corruption of newlines, etc?
40
 
 
41
 
 
42
 
 
43
 
def find_branch_root(f=None):
44
 
    """Find the branch root enclosing f, or pwd.
45
 
 
46
 
    It is not necessary that f exists.
47
 
 
48
 
    Basically we keep looking up until we find the control directory or
49
 
    run into the root."""
50
 
    if f is None:
51
 
        f = os.getcwd()
52
 
    elif hasattr(os.path, 'realpath'):
53
 
        f = os.path.realpath(f)
54
 
    else:
55
 
        f = os.path.abspath(f)
56
 
 
57
 
    orig_f = f
58
 
 
59
 
    last_f = f
60
 
    while True:
61
 
        if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
62
 
            return f
63
 
        head, tail = os.path.split(f)
64
 
        if head == f:
65
 
            # reached the root, whatever that may be
66
 
            bailout('%r is not in a branch' % orig_f)
67
 
        f = head
68
 
    
69
 
 
70
 
 
71
 
######################################################################
72
 
# branch objects
73
 
 
74
 
class Branch:
75
 
    """Branch holding a history of revisions.
76
 
 
77
 
    :todo: Perhaps use different stores for different classes of object,
78
 
           so that we can keep track of how much space each one uses,
79
 
           or garbage-collect them.
80
 
 
81
 
    :todo: Add a RemoteBranch subclass.  For the basic case of read-only
82
 
           HTTP access this should be very easy by, 
83
 
           just redirecting controlfile access into HTTP requests.
84
 
           We would need a RemoteStore working similarly.
85
 
 
86
 
    :todo: Keep the on-disk branch locked while the object exists.
87
 
 
88
 
    :todo: mkdir() method.
89
 
    """
90
 
    def __init__(self, base, init=False, find_root=True):
91
 
        """Create new branch object at a particular location.
92
 
 
93
 
        :param base: Base directory for the branch.
94
 
        
95
 
        :param init: If True, create new control files in a previously
96
 
             unversioned directory.  If False, the branch must already
97
 
             be versioned.
98
 
 
99
 
        :param find_root: If true and init is false, find the root of the
100
 
             existing branch containing base.
101
 
 
102
 
        In the test suite, creation of new trees is tested using the
103
 
        `ScratchBranch` class.
104
 
        """
105
 
        if init:
106
 
            self.base = os.path.realpath(base)
107
 
            self._make_control()
108
 
        elif find_root:
109
 
            self.base = find_branch_root(base)
110
 
        else:
111
 
            self.base = os.path.realpath(base)
112
 
            if not isdir(self.controlfilename('.')):
113
 
                bailout("not a bzr branch: %s" % quotefn(base),
114
 
                        ['use "bzr init" to initialize a new working tree',
115
 
                         'current bzr can only operate from top-of-tree'])
116
 
        self._check_format()
117
 
 
118
 
        self.text_store = ImmutableStore(self.controlfilename('text-store'))
119
 
        self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
120
 
        self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
121
 
 
122
 
 
123
 
    def __str__(self):
124
 
        return '%s(%r)' % (self.__class__.__name__, self.base)
125
 
 
126
 
 
127
 
    __repr__ = __str__
128
 
 
129
 
 
130
 
    def abspath(self, name):
131
 
        """Return absolute filename for something in the branch"""
132
 
        return os.path.join(self.base, name)
133
 
 
134
 
 
135
 
    def relpath(self, path):
136
 
        """Return path relative to this branch of something inside it.
137
 
 
138
 
        Raises an error if path is not in this branch."""
139
 
        rp = os.path.realpath(path)
140
 
        # FIXME: windows
141
 
        if not rp.startswith(self.base):
142
 
            bailout("path %r is not within branch %r" % (rp, self.base))
143
 
        rp = rp[len(self.base):]
144
 
        rp = rp.lstrip(os.sep)
145
 
        return rp
146
 
 
147
 
 
148
 
    def controlfilename(self, file_or_path):
149
 
        """Return location relative to branch."""
150
 
        if isinstance(file_or_path, types.StringTypes):
151
 
            file_or_path = [file_or_path]
152
 
        return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
153
 
 
154
 
 
155
 
    def controlfile(self, file_or_path, mode='r'):
156
 
        """Open a control file for this branch"""
157
 
        return file(self.controlfilename(file_or_path), mode)
158
 
 
159
 
 
160
 
    def _make_control(self):
161
 
        os.mkdir(self.controlfilename([]))
162
 
        self.controlfile('README', 'w').write(
163
 
            "This is a Bazaar-NG control directory.\n"
164
 
            "Do not change any files in this directory.")
165
 
        self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
166
 
        for d in ('text-store', 'inventory-store', 'revision-store'):
167
 
            os.mkdir(self.controlfilename(d))
168
 
        for f in ('revision-history', 'merged-patches',
169
 
                  'pending-merged-patches', 'branch-name'):
170
 
            self.controlfile(f, 'w').write('')
171
 
        mutter('created control directory in ' + self.base)
172
 
        Inventory().write_xml(self.controlfile('inventory','w'))
173
 
 
174
 
 
175
 
    def _check_format(self):
176
 
        """Check this branch format is supported.
177
 
 
178
 
        The current tool only supports the current unstable format.
179
 
 
180
 
        In the future, we might need different in-memory Branch
181
 
        classes to support downlevel branches.  But not yet.
182
 
        """        
183
 
        # read in binary mode to detect newline wierdness.
184
 
        fmt = self.controlfile('branch-format', 'rb').read()
185
 
        if fmt != BZR_BRANCH_FORMAT:
186
 
            bailout('sorry, branch format %r not supported' % fmt,
187
 
                    ['use a different bzr version',
188
 
                     'or remove the .bzr directory and "bzr init" again'])
189
 
 
190
 
 
191
 
    def read_working_inventory(self):
192
 
        """Read the working inventory."""
193
 
        before = time.time()
194
 
        inv = Inventory.read_xml(self.controlfile('inventory', 'r'))
195
 
        mutter("loaded inventory of %d items in %f"
196
 
               % (len(inv), time.time() - before))
197
 
        return inv
198
 
 
199
 
 
200
 
    def _write_inventory(self, inv):
201
 
        """Update the working inventory.
202
 
 
203
 
        That is to say, the inventory describing changes underway, that
204
 
        will be committed to the next revision.
205
 
        """
206
 
        ## TODO: factor out to atomicfile?  is rename safe on windows?
207
 
        ## TODO: Maybe some kind of clean/dirty marker on inventory?
208
 
        tmpfname = self.controlfilename('inventory.tmp')
209
 
        tmpf = file(tmpfname, 'w')
210
 
        inv.write_xml(tmpf)
211
 
        tmpf.close()
212
 
        os.rename(tmpfname, self.controlfilename('inventory'))
213
 
        mutter('wrote working inventory')
214
 
 
215
 
 
216
 
    inventory = property(read_working_inventory, _write_inventory, None,
217
 
                         """Inventory for the working copy.""")
218
 
 
219
 
 
220
 
    def add(self, files, verbose=False):
221
 
        """Make files versioned.
222
 
 
223
 
        This puts the files in the Added state, so that they will be
224
 
        recorded by the next commit.
225
 
 
226
 
        :todo: Perhaps have an option to add the ids even if the files do
227
 
               not (yet) exist.
228
 
 
229
 
        :todo: Perhaps return the ids of the files?  But then again it
230
 
               is easy to retrieve them if they're needed.
231
 
 
232
 
        :todo: Option to specify file id.
233
 
 
234
 
        :todo: Adding a directory should optionally recurse down and
235
 
               add all non-ignored children.  Perhaps do that in a
236
 
               higher-level method.
237
 
 
238
 
        >>> b = ScratchBranch(files=['foo'])
239
 
        >>> 'foo' in b.unknowns()
240
 
        True
241
 
        >>> b.show_status()
242
 
        ?       foo
243
 
        >>> b.add('foo')
244
 
        >>> 'foo' in b.unknowns()
245
 
        False
246
 
        >>> bool(b.inventory.path2id('foo'))
247
 
        True
248
 
        >>> b.show_status()
249
 
        A       foo
250
 
 
251
 
        >>> b.add('foo')
252
 
        Traceback (most recent call last):
253
 
        ...
254
 
        BzrError: ('foo is already versioned', [])
255
 
 
256
 
        >>> b.add(['nothere'])
257
 
        Traceback (most recent call last):
258
 
        BzrError: ('cannot add: not a regular file or directory: nothere', [])
259
 
        """
260
 
 
261
 
        # TODO: Re-adding a file that is removed in the working copy
262
 
        # should probably put it back with the previous ID.
263
 
        if isinstance(files, types.StringTypes):
264
 
            files = [files]
265
 
        
266
 
        inv = self.read_working_inventory()
267
 
        for f in files:
268
 
            if is_control_file(f):
269
 
                bailout("cannot add control file %s" % quotefn(f))
270
 
 
271
 
            fp = splitpath(f)
272
 
 
273
 
            if len(fp) == 0:
274
 
                bailout("cannot add top-level %r" % f)
275
 
                
276
 
            fullpath = os.path.normpath(self.abspath(f))
277
 
 
278
 
            try:
279
 
                kind = file_kind(fullpath)
280
 
            except OSError:
281
 
                # maybe something better?
282
 
                bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
283
 
            
284
 
            if kind != 'file' and kind != 'directory':
285
 
                bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
286
 
 
287
 
            file_id = gen_file_id(f)
288
 
            inv.add_path(f, kind=kind, file_id=file_id)
289
 
 
290
 
            if verbose:
291
 
                show_status('A', kind, quotefn(f))
292
 
                
293
 
            mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
294
 
            
295
 
        self._write_inventory(inv)
296
 
 
297
 
 
298
 
 
299
 
    def remove(self, files, verbose=False):
300
 
        """Mark nominated files for removal from the inventory.
301
 
 
302
 
        This does not remove their text.  This does not run on 
303
 
 
304
 
        :todo: Refuse to remove modified files unless --force is given?
305
 
 
306
 
        >>> b = ScratchBranch(files=['foo'])
307
 
        >>> b.add('foo')
308
 
        >>> b.inventory.has_filename('foo')
309
 
        True
310
 
        >>> b.remove('foo')
311
 
        >>> b.working_tree().has_filename('foo')
312
 
        True
313
 
        >>> b.inventory.has_filename('foo')
314
 
        False
315
 
        
316
 
        >>> b = ScratchBranch(files=['foo'])
317
 
        >>> b.add('foo')
318
 
        >>> b.commit('one')
319
 
        >>> b.remove('foo')
320
 
        >>> b.commit('two')
321
 
        >>> b.inventory.has_filename('foo') 
322
 
        False
323
 
        >>> b.basis_tree().has_filename('foo') 
324
 
        False
325
 
        >>> b.working_tree().has_filename('foo') 
326
 
        True
327
 
 
328
 
        :todo: Do something useful with directories.
329
 
 
330
 
        :todo: Should this remove the text or not?  Tough call; not
331
 
        removing may be useful and the user can just use use rm, and
332
 
        is the opposite of add.  Removing it is consistent with most
333
 
        other tools.  Maybe an option.
334
 
        """
335
 
        ## TODO: Normalize names
336
 
        ## TODO: Remove nested loops; better scalability
337
 
 
338
 
        if isinstance(files, types.StringTypes):
339
 
            files = [files]
340
 
        
341
 
        tree = self.working_tree()
342
 
        inv = tree.inventory
343
 
 
344
 
        # do this before any modifications
345
 
        for f in files:
346
 
            fid = inv.path2id(f)
347
 
            if not fid:
348
 
                bailout("cannot remove unversioned file %s" % quotefn(f))
349
 
            mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
350
 
            if verbose:
351
 
                # having remove it, it must be either ignored or unknown
352
 
                if tree.is_ignored(f):
353
 
                    new_status = 'I'
354
 
                else:
355
 
                    new_status = '?'
356
 
                show_status(new_status, inv[fid].kind, quotefn(f))
357
 
            del inv[fid]
358
 
 
359
 
        self._write_inventory(inv)
360
 
 
361
 
 
362
 
    def unknowns(self):
363
 
        """Return all unknown files.
364
 
 
365
 
        These are files in the working directory that are not versioned or
366
 
        control files or ignored.
367
 
        
368
 
        >>> b = ScratchBranch(files=['foo', 'foo~'])
369
 
        >>> list(b.unknowns())
370
 
        ['foo']
371
 
        >>> b.add('foo')
372
 
        >>> list(b.unknowns())
373
 
        []
374
 
        >>> b.remove('foo')
375
 
        >>> list(b.unknowns())
376
 
        ['foo']
377
 
        """
378
 
        return self.working_tree().unknowns()
379
 
 
380
 
 
381
 
    def commit(self, message, timestamp=None, timezone=None,
382
 
               committer=None,
383
 
               verbose=False):
384
 
        """Commit working copy as a new revision.
385
 
        
386
 
        The basic approach is to add all the file texts into the
387
 
        store, then the inventory, then make a new revision pointing
388
 
        to that inventory and store that.
389
 
        
390
 
        This is not quite safe if the working copy changes during the
391
 
        commit; for the moment that is simply not allowed.  A better
392
 
        approach is to make a temporary copy of the files before
393
 
        computing their hashes, and then add those hashes in turn to
394
 
        the inventory.  This should mean at least that there are no
395
 
        broken hash pointers.  There is no way we can get a snapshot
396
 
        of the whole directory at an instant.  This would also have to
397
 
        be robust against files disappearing, moving, etc.  So the
398
 
        whole thing is a bit hard.
399
 
 
400
 
        :param timestamp: if not None, seconds-since-epoch for a
401
 
             postdated/predated commit.
402
 
        """
403
 
 
404
 
        ## TODO: Show branch names
405
 
 
406
 
        # TODO: Don't commit if there are no changes, unless forced?
407
 
 
408
 
        # First walk over the working inventory; and both update that
409
 
        # and also build a new revision inventory.  The revision
410
 
        # inventory needs to hold the text-id, sha1 and size of the
411
 
        # actual file versions committed in the revision.  (These are
412
 
        # not present in the working inventory.)  We also need to
413
 
        # detect missing/deleted files, and remove them from the
414
 
        # working inventory.
415
 
 
416
 
        work_inv = self.read_working_inventory()
417
 
        inv = Inventory()
418
 
        basis = self.basis_tree()
419
 
        basis_inv = basis.inventory
420
 
        missing_ids = []
421
 
        for path, entry in work_inv.iter_entries():
422
 
            ## TODO: Cope with files that have gone missing.
423
 
 
424
 
            ## TODO: Check that the file kind has not changed from the previous
425
 
            ## revision of this file (if any).
426
 
 
427
 
            entry = entry.copy()
428
 
 
429
 
            p = self.abspath(path)
430
 
            file_id = entry.file_id
431
 
            mutter('commit prep file %s, id %r ' % (p, file_id))
432
 
 
433
 
            if not os.path.exists(p):
434
 
                mutter("    file is missing, removing from inventory")
435
 
                if verbose:
436
 
                    show_status('D', entry.kind, quotefn(path))
437
 
                missing_ids.append(file_id)
438
 
                continue
439
 
 
440
 
            # TODO: Handle files that have been deleted
441
 
 
442
 
            # TODO: Maybe a special case for empty files?  Seems a
443
 
            # waste to store them many times.
444
 
 
445
 
            inv.add(entry)
446
 
 
447
 
            if basis_inv.has_id(file_id):
448
 
                old_kind = basis_inv[file_id].kind
449
 
                if old_kind != entry.kind:
450
 
                    bailout("entry %r changed kind from %r to %r"
451
 
                            % (file_id, old_kind, entry.kind))
452
 
 
453
 
            if entry.kind == 'directory':
454
 
                if not isdir(p):
455
 
                    bailout("%s is entered as directory but not a directory" % quotefn(p))
456
 
            elif entry.kind == 'file':
457
 
                if not isfile(p):
458
 
                    bailout("%s is entered as file but is not a file" % quotefn(p))
459
 
 
460
 
                content = file(p, 'rb').read()
461
 
 
462
 
                entry.text_sha1 = sha_string(content)
463
 
                entry.text_size = len(content)
464
 
 
465
 
                old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
466
 
                if (old_ie
467
 
                    and (old_ie.text_size == entry.text_size)
468
 
                    and (old_ie.text_sha1 == entry.text_sha1)):
469
 
                    ## assert content == basis.get_file(file_id).read()
470
 
                    entry.text_id = basis_inv[file_id].text_id
471
 
                    mutter('    unchanged from previous text_id {%s}' %
472
 
                           entry.text_id)
473
 
                    
474
 
                else:
475
 
                    entry.text_id = gen_file_id(entry.name)
476
 
                    self.text_store.add(content, entry.text_id)
477
 
                    mutter('    stored with text_id {%s}' % entry.text_id)
478
 
                    if verbose:
479
 
                        if not old_ie:
480
 
                            state = 'A'
481
 
                        elif (old_ie.name == entry.name
482
 
                              and old_ie.parent_id == entry.parent_id):
483
 
                            state = 'M'
484
 
                        else:
485
 
                            state = 'R'
486
 
 
487
 
                        show_status(state, entry.kind, quotefn(path))
488
 
 
489
 
        for file_id in missing_ids:
490
 
            # have to do this later so we don't mess up the iterator.
491
 
            # since parents may be removed before their children we
492
 
            # have to test.
493
 
 
494
 
            # FIXME: There's probably a better way to do this; perhaps
495
 
            # the workingtree should know how to filter itself.
496
 
            if work_inv.has_id(file_id):
497
 
                del work_inv[file_id]
498
 
 
499
 
 
500
 
        inv_id = rev_id = _gen_revision_id(time.time())
501
 
        
502
 
        inv_tmp = tempfile.TemporaryFile()
503
 
        inv.write_xml(inv_tmp)
504
 
        inv_tmp.seek(0)
505
 
        self.inventory_store.add(inv_tmp, inv_id)
506
 
        mutter('new inventory_id is {%s}' % inv_id)
507
 
 
508
 
        self._write_inventory(work_inv)
509
 
 
510
 
        if timestamp == None:
511
 
            timestamp = time.time()
512
 
 
513
 
        if committer == None:
514
 
            committer = username()
515
 
 
516
 
        if timezone == None:
517
 
            timezone = local_time_offset()
518
 
 
519
 
        mutter("building commit log message")
520
 
        rev = Revision(timestamp=timestamp,
521
 
                       timezone=timezone,
522
 
                       committer=committer,
523
 
                       precursor = self.last_patch(),
524
 
                       message = message,
525
 
                       inventory_id=inv_id,
526
 
                       revision_id=rev_id)
527
 
 
528
 
        rev_tmp = tempfile.TemporaryFile()
529
 
        rev.write_xml(rev_tmp)
530
 
        rev_tmp.seek(0)
531
 
        self.revision_store.add(rev_tmp, rev_id)
532
 
        mutter("new revision_id is {%s}" % rev_id)
533
 
        
534
 
        ## XXX: Everything up to here can simply be orphaned if we abort
535
 
        ## the commit; it will leave junk files behind but that doesn't
536
 
        ## matter.
537
 
 
538
 
        ## TODO: Read back the just-generated changeset, and make sure it
539
 
        ## applies and recreates the right state.
540
 
 
541
 
        ## TODO: Also calculate and store the inventory SHA1
542
 
        mutter("committing patch r%d" % (self.revno() + 1))
543
 
 
544
 
        mutter("append to revision-history")
545
 
        f = self.controlfile('revision-history', 'at')
546
 
        f.write(rev_id + '\n')
547
 
        f.close()
548
 
 
549
 
        if verbose:
550
 
            note("commited r%d" % self.revno())
551
 
 
552
 
 
553
 
    def get_revision(self, revision_id):
554
 
        """Return the Revision object for a named revision"""
555
 
        r = Revision.read_xml(self.revision_store[revision_id])
556
 
        assert r.revision_id == revision_id
557
 
        return r
558
 
 
559
 
 
560
 
    def get_inventory(self, inventory_id):
561
 
        """Get Inventory object by hash.
562
 
 
563
 
        :todo: Perhaps for this and similar methods, take a revision
564
 
               parameter which can be either an integer revno or a
565
 
               string hash."""
566
 
        i = Inventory.read_xml(self.inventory_store[inventory_id])
567
 
        return i
568
 
 
569
 
 
570
 
    def get_revision_inventory(self, revision_id):
571
 
        """Return inventory of a past revision."""
572
 
        if revision_id == None:
573
 
            return Inventory()
574
 
        else:
575
 
            return self.get_inventory(self.get_revision(revision_id).inventory_id)
576
 
 
577
 
 
578
 
    def revision_history(self):
579
 
        """Return sequence of revision hashes on to this branch.
580
 
 
581
 
        >>> ScratchBranch().revision_history()
582
 
        []
583
 
        """
584
 
        return [chomp(l) for l in self.controlfile('revision-history').readlines()]
585
 
 
586
 
 
587
 
    def revno(self):
588
 
        """Return current revision number for this branch.
589
 
 
590
 
        That is equivalent to the number of revisions committed to
591
 
        this branch.
592
 
 
593
 
        >>> b = ScratchBranch()
594
 
        >>> b.revno()
595
 
        0
596
 
        >>> b.commit('no foo')
597
 
        >>> b.revno()
598
 
        1
599
 
        """
600
 
        return len(self.revision_history())
601
 
 
602
 
 
603
 
    def last_patch(self):
604
 
        """Return last patch hash, or None if no history.
605
 
 
606
 
        >>> ScratchBranch().last_patch() == None
607
 
        True
608
 
        """
609
 
        ph = self.revision_history()
610
 
        if ph:
611
 
            return ph[-1]
612
 
 
613
 
 
614
 
    def lookup_revision(self, revno):
615
 
        """Return revision hash for revision number."""
616
 
        if revno == 0:
617
 
            return None
618
 
 
619
 
        try:
620
 
            # list is 0-based; revisions are 1-based
621
 
            return self.revision_history()[revno-1]
622
 
        except IndexError:
623
 
            bailout("no such revision %s" % revno)
624
 
 
625
 
 
626
 
    def revision_tree(self, revision_id):
627
 
        """Return Tree for a revision on this branch.
628
 
 
629
 
        `revision_id` may be None for the null revision, in which case
630
 
        an `EmptyTree` is returned."""
631
 
 
632
 
        if revision_id == None:
633
 
            return EmptyTree()
634
 
        else:
635
 
            inv = self.get_revision_inventory(revision_id)
636
 
            return RevisionTree(self.text_store, inv)
637
 
 
638
 
 
639
 
    def working_tree(self):
640
 
        """Return a `Tree` for the working copy."""
641
 
        return WorkingTree(self.base, self.read_working_inventory())
642
 
 
643
 
 
644
 
    def basis_tree(self):
645
 
        """Return `Tree` object for last revision.
646
 
 
647
 
        If there are no revisions yet, return an `EmptyTree`.
648
 
 
649
 
        >>> b = ScratchBranch(files=['foo'])
650
 
        >>> b.basis_tree().has_filename('foo')
651
 
        False
652
 
        >>> b.working_tree().has_filename('foo')
653
 
        True
654
 
        >>> b.add('foo')
655
 
        >>> b.commit('add foo')
656
 
        >>> b.basis_tree().has_filename('foo')
657
 
        True
658
 
        """
659
 
        r = self.last_patch()
660
 
        if r == None:
661
 
            return EmptyTree()
662
 
        else:
663
 
            return RevisionTree(self.text_store, self.get_revision_inventory(r))
664
 
 
665
 
 
666
 
 
667
 
    def write_log(self, show_timezone='original'):
668
 
        """Write out human-readable log of commits to this branch
669
 
 
670
 
        :param utc: If true, show dates in universal time, not local time."""
671
 
        ## TODO: Option to choose either original, utc or local timezone
672
 
        revno = 1
673
 
        precursor = None
674
 
        for p in self.revision_history():
675
 
            print '-' * 40
676
 
            print 'revno:', revno
677
 
            ## TODO: Show hash if --id is given.
678
 
            ##print 'revision-hash:', p
679
 
            rev = self.get_revision(p)
680
 
            print 'committer:', rev.committer
681
 
            print 'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
682
 
                                                 show_timezone))
683
 
 
684
 
            ## opportunistic consistency check, same as check_patch_chaining
685
 
            if rev.precursor != precursor:
686
 
                bailout("mismatched precursor!")
687
 
 
688
 
            print 'message:'
689
 
            if not rev.message:
690
 
                print '  (no message)'
691
 
            else:
692
 
                for l in rev.message.split('\n'):
693
 
                    print '  ' + l
694
 
 
695
 
            revno += 1
696
 
            precursor = p
697
 
 
698
 
 
699
 
 
700
 
    def show_status(branch, show_all=False):
701
 
        """Display single-line status for non-ignored working files.
702
 
 
703
 
        The list is show sorted in order by file name.
704
 
 
705
 
        >>> b = ScratchBranch(files=['foo', 'foo~'])
706
 
        >>> b.show_status()
707
 
        ?       foo
708
 
        >>> b.add('foo')
709
 
        >>> b.show_status()
710
 
        A       foo
711
 
        >>> b.commit("add foo")
712
 
        >>> b.show_status()
713
 
        >>> os.unlink(b.abspath('foo'))
714
 
        >>> b.show_status()
715
 
        D       foo
716
 
        
717
 
 
718
 
        :todo: Get state for single files.
719
 
 
720
 
        :todo: Perhaps show a slash at the end of directory names.        
721
 
 
722
 
        """
723
 
 
724
 
        # We have to build everything into a list first so that it can
725
 
        # sorted by name, incorporating all the different sources.
726
 
 
727
 
        # FIXME: Rather than getting things in random order and then sorting,
728
 
        # just step through in order.
729
 
 
730
 
        # Interesting case: the old ID for a file has been removed,
731
 
        # but a new file has been created under that name.
732
 
 
733
 
        old = branch.basis_tree()
734
 
        old_inv = old.inventory
735
 
        new = branch.working_tree()
736
 
        new_inv = new.inventory
737
 
 
738
 
        for fs, fid, oldname, newname, kind in diff_trees(old, new):
739
 
            if fs == 'R':
740
 
                show_status(fs, kind,
741
 
                            oldname + ' => ' + newname)
742
 
            elif fs == 'A' or fs == 'M':
743
 
                show_status(fs, kind, newname)
744
 
            elif fs == 'D':
745
 
                show_status(fs, kind, oldname)
746
 
            elif fs == '.':
747
 
                if show_all:
748
 
                    show_status(fs, kind, newname)
749
 
            elif fs == 'I':
750
 
                if show_all:
751
 
                    show_status(fs, kind, newname)
752
 
            elif fs == '?':
753
 
                show_status(fs, kind, newname)
754
 
            else:
755
 
                bailout("wierd file state %r" % ((fs, fid),))
756
 
                
757
 
 
758
 
 
759
 
class ScratchBranch(Branch):
760
 
    """Special test class: a branch that cleans up after itself.
761
 
 
762
 
    >>> b = ScratchBranch()
763
 
    >>> isdir(b.base)
764
 
    True
765
 
    >>> bd = b.base
766
 
    >>> del b
767
 
    >>> isdir(bd)
768
 
    False
769
 
    """
770
 
    def __init__(self, files=[], dirs=[]):
771
 
        """Make a test branch.
772
 
 
773
 
        This creates a temporary directory and runs init-tree in it.
774
 
 
775
 
        If any files are listed, they are created in the working copy.
776
 
        """
777
 
        Branch.__init__(self, tempfile.mkdtemp(), init=True)
778
 
        for d in dirs:
779
 
            os.mkdir(self.abspath(d))
780
 
            
781
 
        for f in files:
782
 
            file(os.path.join(self.base, f), 'w').write('content of %s' % f)
783
 
 
784
 
 
785
 
    def __del__(self):
786
 
        """Destroy the test branch, removing the scratch directory."""
787
 
        shutil.rmtree(self.base)
788
 
 
789
 
    
790
 
 
791
 
######################################################################
792
 
# predicates
793
 
 
794
 
 
795
 
def is_control_file(filename):
796
 
    ## FIXME: better check
797
 
    filename = os.path.normpath(filename)
798
 
    while filename != '':
799
 
        head, tail = os.path.split(filename)
800
 
        ## mutter('check %r for control file' % ((head, tail), ))
801
 
        if tail == bzrlib.BZRDIR:
802
 
            return True
803
 
        if filename == head:
804
 
            break
805
 
        filename = head
806
 
    return False
807
 
 
808
 
 
809
 
 
810
 
def _gen_revision_id(when):
811
 
    """Return new revision-id."""
812
 
    s = '%s-%s-' % (user_email(), compact_date(when))
813
 
    s += hexlify(rand_bytes(8))
814
 
    return s
815
 
 
816
 
 
817
 
def gen_file_id(name):
818
 
    """Return new file id.
819
 
 
820
 
    This should probably generate proper UUIDs, but for the moment we
821
 
    cope with just randomness because running uuidgen every time is
822
 
    slow."""
823
 
    idx = name.rfind('/')
824
 
    if idx != -1:
825
 
        name = name[idx+1 : ]
826
 
 
827
 
    name = name.lstrip('.')
828
 
 
829
 
    s = hexlify(rand_bytes(8))
830
 
    return '-'.join((name, compact_date(time.time()), s))
831
 
 
832