/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-04-11 02:44:45 UTC
  • Revision ID: mbp@sourcefrog.net-20050411024445-a2d4fa7e39309d2300533a6a
- Experiments in inventory performance

Show diffs side-by-side

added added

removed removed

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