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