/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: mbp at sourcefrog
  • Date: 2005-03-09 06:49:00 UTC
  • Revision ID: mbp@sourcefrog.net-20050309064900-74935ffb7350b24b
import more files from baz

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