~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: mbp at sourcefrog
  • Date: 2005-04-04 09:50:24 UTC
  • Revision ID: mbp@sourcefrog.net-20050404095024-4646dbcc42eada9e
workaround for python2.3 difflib bug

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
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, appendpath
 
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 rename(self, from_paths, to_name):
 
701
        """Rename files.
 
702
 
 
703
        If to_name exists and is a directory, the files are moved into
 
704
        it, keeping their old names.  If it is a directory, 
 
705
 
 
706
        Note that to_name is only the last component of the new name;
 
707
        this doesn't change the directory.
 
708
        """
 
709
        ## TODO: Option to move IDs only
 
710
        assert not isinstance(from_paths, basestring)
 
711
        tree = self.working_tree()
 
712
        inv = tree.inventory
 
713
        dest_dir = isdir(self.abspath(to_name))
 
714
        if dest_dir:
 
715
            # TODO: Wind back properly if some can't be moved?
 
716
            dest_dir_id = inv.path2id(to_name)
 
717
            if not dest_dir_id and to_name != '':
 
718
                bailout("destination %r is not a versioned directory" % to_name)
 
719
            for f in from_paths:
 
720
                name_tail = splitpath(f)[-1]
 
721
                dest_path = appendpath(to_name, name_tail)
 
722
                print "%s => %s" % (f, dest_path)
 
723
                inv.rename(inv.path2id(f), dest_dir_id, name_tail)
 
724
                os.rename(self.abspath(f), self.abspath(dest_path))
 
725
            self._write_inventory(inv)
 
726
        else:
 
727
            if len(from_paths) != 1:
 
728
                bailout("when moving multiple files, destination must be a directory")
 
729
            bailout("rename to non-directory %r not implemented sorry" % to_name)
 
730
 
 
731
 
 
732
 
 
733
    def show_status(branch, show_all=False):
 
734
        """Display single-line status for non-ignored working files.
 
735
 
 
736
        The list is show sorted in order by file name.
 
737
 
 
738
        >>> b = ScratchBranch(files=['foo', 'foo~'])
 
739
        >>> b.show_status()
 
740
        ?       foo
 
741
        >>> b.add('foo')
 
742
        >>> b.show_status()
 
743
        A       foo
 
744
        >>> b.commit("add foo")
 
745
        >>> b.show_status()
 
746
        >>> os.unlink(b.abspath('foo'))
 
747
        >>> b.show_status()
 
748
        D       foo
 
749
        
 
750
 
 
751
        :todo: Get state for single files.
 
752
 
 
753
        :todo: Perhaps show a slash at the end of directory names.        
 
754
 
 
755
        """
 
756
 
 
757
        # We have to build everything into a list first so that it can
 
758
        # sorted by name, incorporating all the different sources.
 
759
 
 
760
        # FIXME: Rather than getting things in random order and then sorting,
 
761
        # just step through in order.
 
762
 
 
763
        # Interesting case: the old ID for a file has been removed,
 
764
        # but a new file has been created under that name.
 
765
 
 
766
        old = branch.basis_tree()
 
767
        old_inv = old.inventory
 
768
        new = branch.working_tree()
 
769
        new_inv = new.inventory
 
770
 
 
771
        for fs, fid, oldname, newname, kind in diff_trees(old, new):
 
772
            if fs == 'R':
 
773
                show_status(fs, kind,
 
774
                            oldname + ' => ' + newname)
 
775
            elif fs == 'A' or fs == 'M':
 
776
                show_status(fs, kind, newname)
 
777
            elif fs == 'D':
 
778
                show_status(fs, kind, oldname)
 
779
            elif fs == '.':
 
780
                if show_all:
 
781
                    show_status(fs, kind, newname)
 
782
            elif fs == 'I':
 
783
                if show_all:
 
784
                    show_status(fs, kind, newname)
 
785
            elif fs == '?':
 
786
                show_status(fs, kind, newname)
 
787
            else:
 
788
                bailout("wierd file state %r" % ((fs, fid),))
 
789
                
 
790
 
 
791
 
 
792
class ScratchBranch(Branch):
 
793
    """Special test class: a branch that cleans up after itself.
 
794
 
 
795
    >>> b = ScratchBranch()
 
796
    >>> isdir(b.base)
 
797
    True
 
798
    >>> bd = b.base
 
799
    >>> del b
 
800
    >>> isdir(bd)
 
801
    False
 
802
    """
 
803
    def __init__(self, files=[], dirs=[]):
 
804
        """Make a test branch.
 
805
 
 
806
        This creates a temporary directory and runs init-tree in it.
 
807
 
 
808
        If any files are listed, they are created in the working copy.
 
809
        """
 
810
        Branch.__init__(self, tempfile.mkdtemp(), init=True)
 
811
        for d in dirs:
 
812
            os.mkdir(self.abspath(d))
 
813
            
 
814
        for f in files:
 
815
            file(os.path.join(self.base, f), 'w').write('content of %s' % f)
 
816
 
 
817
 
 
818
    def __del__(self):
 
819
        """Destroy the test branch, removing the scratch directory."""
 
820
        shutil.rmtree(self.base)
 
821
 
 
822
    
 
823
 
 
824
######################################################################
 
825
# predicates
 
826
 
 
827
 
 
828
def is_control_file(filename):
 
829
    ## FIXME: better check
 
830
    filename = os.path.normpath(filename)
 
831
    while filename != '':
 
832
        head, tail = os.path.split(filename)
 
833
        ## mutter('check %r for control file' % ((head, tail), ))
 
834
        if tail == bzrlib.BZRDIR:
 
835
            return True
 
836
        if filename == head:
 
837
            break
 
838
        filename = head
 
839
    return False
 
840
 
 
841
 
 
842
 
 
843
def _gen_revision_id(when):
 
844
    """Return new revision-id."""
 
845
    s = '%s-%s-' % (user_email(), compact_date(when))
 
846
    s += hexlify(rand_bytes(8))
 
847
    return s
 
848
 
 
849
 
 
850
def gen_file_id(name):
 
851
    """Return new file id.
 
852
 
 
853
    This should probably generate proper UUIDs, but for the moment we
 
854
    cope with just randomness because running uuidgen every time is
 
855
    slow."""
 
856
    idx = name.rfind('/')
 
857
    if idx != -1:
 
858
        name = name[idx+1 : ]
 
859
 
 
860
    name = name.lstrip('.')
 
861
 
 
862
    s = hexlify(rand_bytes(8))
 
863
    return '-'.join((name, compact_date(time.time()), s))
 
864
 
 
865