← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: John Arbash Meinel
  • Date: 2006-01-23 22:33:23 UTC
  • mto: This revision was merged to the branch mainline in revision 1551.
  • Revision ID: john@arbash-meinel.com-20060123223323-16eb865383bf650a
From Jari Alto: Makefile fixes (clean target error suppression)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/branch.py
1
 
#! /usr/bin/env python
2
 
# -*- coding: UTF-8 -*-
 
1
# Copyright (C) 2005 Canonical Ltd
3
2
 
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
16
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
16
 
18
17
 
19
 
from sets import Set
 
18
import shutil
 
19
import sys
 
20
import os
 
21
import errno
 
22
from warnings import warn
 
23
import xml.sax.saxutils
 
24
from cStringIO import StringIO
20
25
 
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
26
 
25
27
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"
 
28
import bzrlib.inventory as inventory
 
29
from bzrlib.trace import mutter, note
 
30
from bzrlib.osutils import (isdir, quotefn,
 
31
                            rename, splitpath, sha_file,
 
32
                            file_kind, abspath, normpath, pathjoin)
 
33
import bzrlib.errors as errors
 
34
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
 
35
                           NoSuchRevision, HistoryMissing, NotBranchError,
 
36
                           DivergedBranches, LockError, UnlistableStore,
 
37
                           UnlistableBranch, NoSuchFile, NotVersionedError,
 
38
                           NoWorkingTree)
 
39
from bzrlib.textui import show_status
 
40
from bzrlib.revision import (Revision, is_ancestor, get_intervening_revisions,
 
41
                             NULL_REVISION)
 
42
 
 
43
from bzrlib.delta import compare_trees
 
44
from bzrlib.tree import EmptyTree, RevisionTree
 
45
from bzrlib.inventory import Inventory
 
46
from bzrlib.store import copy_all
 
47
from bzrlib.store.text import TextStore
 
48
from bzrlib.store.weave import WeaveStore
 
49
from bzrlib.testament import Testament
 
50
import bzrlib.transactions as transactions
 
51
from bzrlib.transport import Transport, get_transport
 
52
import bzrlib.xml5
 
53
import bzrlib.ui
 
54
from config import TreeConfig
 
55
 
 
56
 
 
57
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
 
58
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
 
59
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
40
60
## TODO: Maybe include checks for common corruption of newlines, etc?
41
61
 
42
62
 
43
 
 
44
 
 
 
63
# TODO: Some operations like log might retrieve the same revisions
 
64
# repeatedly to calculate deltas.  We could perhaps have a weakref
 
65
# cache in memory to make this faster.  In general anything can be
 
66
# cached in memory between lock and unlock operations.
 
67
 
 
68
def find_branch(*ignored, **ignored_too):
 
69
    # XXX: leave this here for about one release, then remove it
 
70
    raise NotImplementedError('find_branch() is not supported anymore, '
 
71
                              'please use one of the new branch constructors')
 
72
 
 
73
 
 
74
def needs_read_lock(unbound):
 
75
    """Decorate unbound to take out and release a read lock."""
 
76
    def decorated(self, *args, **kwargs):
 
77
        self.lock_read()
 
78
        try:
 
79
            return unbound(self, *args, **kwargs)
 
80
        finally:
 
81
            self.unlock()
 
82
    return decorated
 
83
 
 
84
 
 
85
def needs_write_lock(unbound):
 
86
    """Decorate unbound to take out and release a write lock."""
 
87
    def decorated(self, *args, **kwargs):
 
88
        self.lock_write()
 
89
        try:
 
90
            return unbound(self, *args, **kwargs)
 
91
        finally:
 
92
            self.unlock()
 
93
    return decorated
45
94
 
46
95
######################################################################
47
96
# branch objects
48
97
 
49
 
class Branch:
 
98
class Branch(object):
50
99
    """Branch holding a history of revisions.
51
100
 
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):
 
101
    base
 
102
        Base directory/url of the branch.
 
103
    """
 
104
    base = None
 
105
 
 
106
    def __init__(self, *ignored, **ignored_too):
 
107
        raise NotImplementedError('The Branch class is abstract')
 
108
 
 
109
    @staticmethod
 
110
    def open_downlevel(base):
 
111
        """Open a branch which may be of an old format.
 
112
        
 
113
        Only local branches are supported."""
 
114
        return BzrBranch(get_transport(base), relax_version_check=True)
 
115
        
 
116
    @staticmethod
 
117
    def open(base):
 
118
        """Open an existing branch, rooted at 'base' (url)"""
 
119
        t = get_transport(base)
 
120
        mutter("trying to open %r with transport %r", base, t)
 
121
        return BzrBranch(t)
 
122
 
 
123
    @staticmethod
 
124
    def open_containing(url):
 
125
        """Open an existing branch which contains url.
 
126
        
 
127
        This probes for a branch at url, and searches upwards from there.
 
128
 
 
129
        Basically we keep looking up until we find the control directory or
 
130
        run into the root.  If there isn't one, raises NotBranchError.
 
131
        If there is one, it is returned, along with the unused portion of url.
 
132
        """
 
133
        t = get_transport(url)
 
134
        while True:
 
135
            try:
 
136
                return BzrBranch(t), t.relpath(url)
 
137
            except NotBranchError, e:
 
138
                mutter('not a branch in: %r %s', t.base, e)
 
139
            new_t = t.clone('..')
 
140
            if new_t.base == t.base:
 
141
                # reached the root, whatever that may be
 
142
                raise NotBranchError(path=url)
 
143
            t = new_t
 
144
 
 
145
    @staticmethod
 
146
    def initialize(base):
 
147
        """Create a new branch, rooted at 'base' (url)"""
 
148
        t = get_transport(base)
 
149
        return BzrBranch(t, init=True)
 
150
 
 
151
    def setup_caching(self, cache_root):
 
152
        """Subclasses that care about caching should override this, and set
 
153
        up cached stores located under cache_root.
 
154
        """
 
155
        self.cache_root = cache_root
 
156
 
 
157
    def _get_nick(self):
 
158
        cfg = self.tree_config()
 
159
        return cfg.get_option(u"nickname", default=self.base.split('/')[-2])
 
160
 
 
161
    def _set_nick(self, nick):
 
162
        cfg = self.tree_config()
 
163
        cfg.set_option(nick, "nickname")
 
164
        assert cfg.get_option("nickname") == nick
 
165
 
 
166
    nick = property(_get_nick, _set_nick)
 
167
        
 
168
    def push_stores(self, branch_to):
 
169
        """Copy the content of this branches store to branch_to."""
 
170
        raise NotImplementedError('push_stores is abstract')
 
171
 
 
172
    def get_transaction(self):
 
173
        """Return the current active transaction.
 
174
 
 
175
        If no transaction is active, this returns a passthrough object
 
176
        for which all data is immediately flushed and no caching happens.
 
177
        """
 
178
        raise NotImplementedError('get_transaction is abstract')
 
179
 
 
180
    def lock_write(self):
 
181
        raise NotImplementedError('lock_write is abstract')
 
182
        
 
183
    def lock_read(self):
 
184
        raise NotImplementedError('lock_read is abstract')
 
185
 
 
186
    def unlock(self):
 
187
        raise NotImplementedError('unlock is abstract')
 
188
 
 
189
    def abspath(self, name):
 
190
        """Return absolute filename for something in the branch
 
191
        
 
192
        XXX: Robert Collins 20051017 what is this used for? why is it a branch
 
193
        method and not a tree method.
 
194
        """
 
195
        raise NotImplementedError('abspath is abstract')
 
196
 
 
197
    def controlfilename(self, file_or_path):
 
198
        """Return location relative to branch."""
 
199
        raise NotImplementedError('controlfilename is abstract')
 
200
 
 
201
    def controlfile(self, file_or_path, mode='r'):
 
202
        """Open a control file for this branch.
 
203
 
 
204
        There are two classes of file in the control directory: text
 
205
        and binary.  binary files are untranslated byte streams.  Text
 
206
        control files are stored with Unix newlines and in UTF-8, even
 
207
        if the platform or locale defaults are different.
 
208
 
 
209
        Controlfiles should almost never be opened in write mode but
 
210
        rather should be atomically copied and replaced using atomicfile.
 
211
        """
 
212
        raise NotImplementedError('controlfile is abstract')
 
213
 
 
214
    def put_controlfile(self, path, f, encode=True):
 
215
        """Write an entry as a controlfile.
 
216
 
 
217
        :param path: The path to put the file, relative to the .bzr control
 
218
                     directory
 
219
        :param f: A file-like or string object whose contents should be copied.
 
220
        :param encode:  If true, encode the contents as utf-8
 
221
        """
 
222
        raise NotImplementedError('put_controlfile is abstract')
 
223
 
 
224
    def put_controlfiles(self, files, encode=True):
 
225
        """Write several entries as controlfiles.
 
226
 
 
227
        :param files: A list of [(path, file)] pairs, where the path is the directory
 
228
                      underneath the bzr control directory
 
229
        :param encode:  If true, encode the contents as utf-8
 
230
        """
 
231
        raise NotImplementedError('put_controlfiles is abstract')
 
232
 
 
233
    def get_root_id(self):
 
234
        """Return the id of this branches root"""
 
235
        raise NotImplementedError('get_root_id is abstract')
 
236
 
 
237
    def set_root_id(self, file_id):
 
238
        raise NotImplementedError('set_root_id is abstract')
 
239
 
 
240
    def print_file(self, file, revision_id):
 
241
        """Print `file` to stdout."""
 
242
        raise NotImplementedError('print_file is abstract')
 
243
 
 
244
    def append_revision(self, *revision_ids):
 
245
        raise NotImplementedError('append_revision is abstract')
 
246
 
 
247
    def set_revision_history(self, rev_history):
 
248
        raise NotImplementedError('set_revision_history is abstract')
 
249
 
 
250
    def has_revision(self, revision_id):
 
251
        """True if this branch has a copy of the revision.
 
252
 
 
253
        This does not necessarily imply the revision is merge
 
254
        or on the mainline."""
 
255
        raise NotImplementedError('has_revision is abstract')
 
256
 
 
257
    def get_revision_xml(self, revision_id):
 
258
        raise NotImplementedError('get_revision_xml is abstract')
 
259
 
 
260
    def get_revision(self, revision_id):
 
261
        """Return the Revision object for a named revision"""
 
262
        raise NotImplementedError('get_revision is abstract')
 
263
 
 
264
    def get_revision_delta(self, revno):
 
265
        """Return the delta for one revision.
 
266
 
 
267
        The delta is relative to its mainline predecessor, or the
 
268
        empty tree for revision 1.
 
269
        """
 
270
        assert isinstance(revno, int)
 
271
        rh = self.revision_history()
 
272
        if not (1 <= revno <= len(rh)):
 
273
            raise InvalidRevisionNumber(revno)
 
274
 
 
275
        # revno is 1-based; list is 0-based
 
276
 
 
277
        new_tree = self.revision_tree(rh[revno-1])
 
278
        if revno == 1:
 
279
            old_tree = EmptyTree()
 
280
        else:
 
281
            old_tree = self.revision_tree(rh[revno-2])
 
282
 
 
283
        return compare_trees(old_tree, new_tree)
 
284
 
 
285
    def get_revision_sha1(self, revision_id):
 
286
        """Hash the stored value of a revision, and return it."""
 
287
        raise NotImplementedError('get_revision_sha1 is abstract')
 
288
 
 
289
    def get_ancestry(self, revision_id):
 
290
        """Return a list of revision-ids integrated by a revision.
 
291
        
 
292
        This currently returns a list, but the ordering is not guaranteed:
 
293
        treat it as a set.
 
294
        """
 
295
        raise NotImplementedError('get_ancestry is abstract')
 
296
 
 
297
    def get_inventory(self, revision_id):
 
298
        """Get Inventory object by hash."""
 
299
        raise NotImplementedError('get_inventory is abstract')
 
300
 
 
301
    def get_inventory_xml(self, revision_id):
 
302
        """Get inventory XML as a file object."""
 
303
        raise NotImplementedError('get_inventory_xml is abstract')
 
304
 
 
305
    def get_inventory_sha1(self, revision_id):
 
306
        """Return the sha1 hash of the inventory entry."""
 
307
        raise NotImplementedError('get_inventory_sha1 is abstract')
 
308
 
 
309
    def get_revision_inventory(self, revision_id):
 
310
        """Return inventory of a past revision."""
 
311
        raise NotImplementedError('get_revision_inventory is abstract')
 
312
 
 
313
    def revision_history(self):
 
314
        """Return sequence of revision hashes on to this branch."""
 
315
        raise NotImplementedError('revision_history is abstract')
 
316
 
 
317
    def revno(self):
 
318
        """Return current revision number for this branch.
 
319
 
 
320
        That is equivalent to the number of revisions committed to
 
321
        this branch.
 
322
        """
 
323
        return len(self.revision_history())
 
324
 
 
325
    def last_revision(self):
 
326
        """Return last patch hash, or None if no history."""
 
327
        ph = self.revision_history()
 
328
        if ph:
 
329
            return ph[-1]
 
330
        else:
 
331
            return None
 
332
 
 
333
    def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
 
334
        """Return a list of new revisions that would perfectly fit.
 
335
        
 
336
        If self and other have not diverged, return a list of the revisions
 
337
        present in other, but missing from self.
 
338
 
 
339
        >>> from bzrlib.commit import commit
 
340
        >>> bzrlib.trace.silent = True
 
341
        >>> br1 = ScratchBranch()
 
342
        >>> br2 = ScratchBranch()
 
343
        >>> br1.missing_revisions(br2)
 
344
        []
 
345
        >>> commit(br2, "lala!", rev_id="REVISION-ID-1")
 
346
        >>> br1.missing_revisions(br2)
 
347
        [u'REVISION-ID-1']
 
348
        >>> br2.missing_revisions(br1)
 
349
        []
 
350
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1")
 
351
        >>> br1.missing_revisions(br2)
 
352
        []
 
353
        >>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
 
354
        >>> br1.missing_revisions(br2)
 
355
        [u'REVISION-ID-2A']
 
356
        >>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
 
357
        >>> br1.missing_revisions(br2)
 
358
        Traceback (most recent call last):
 
359
        DivergedBranches: These branches have diverged.  Try merge.
 
360
        """
 
361
        self_history = self.revision_history()
 
362
        self_len = len(self_history)
 
363
        other_history = other.revision_history()
 
364
        other_len = len(other_history)
 
365
        common_index = min(self_len, other_len) -1
 
366
        if common_index >= 0 and \
 
367
            self_history[common_index] != other_history[common_index]:
 
368
            raise DivergedBranches(self, other)
 
369
 
 
370
        if stop_revision is None:
 
371
            stop_revision = other_len
 
372
        else:
 
373
            assert isinstance(stop_revision, int)
 
374
            if stop_revision > other_len:
 
375
                raise bzrlib.errors.NoSuchRevision(self, stop_revision)
 
376
        return other_history[self_len:stop_revision]
 
377
    
 
378
    def update_revisions(self, other, stop_revision=None):
 
379
        """Pull in new perfect-fit revisions."""
 
380
        raise NotImplementedError('update_revisions is abstract')
 
381
 
 
382
    def pullable_revisions(self, other, stop_revision):
 
383
        raise NotImplementedError('pullable_revisions is abstract')
 
384
        
 
385
    def revision_id_to_revno(self, revision_id):
 
386
        """Given a revision id, return its revno"""
 
387
        if revision_id is None:
 
388
            return 0
 
389
        history = self.revision_history()
 
390
        try:
 
391
            return history.index(revision_id) + 1
 
392
        except ValueError:
 
393
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
 
394
 
 
395
    def get_rev_id(self, revno, history=None):
 
396
        """Find the revision id of the specified revno."""
 
397
        if revno == 0:
 
398
            return None
 
399
        if history is None:
 
400
            history = self.revision_history()
 
401
        elif revno <= 0 or revno > len(history):
 
402
            raise bzrlib.errors.NoSuchRevision(self, revno)
 
403
        return history[revno - 1]
 
404
 
 
405
    def revision_tree(self, revision_id):
 
406
        """Return Tree for a revision on this branch.
 
407
 
 
408
        `revision_id` may be None for the null revision, in which case
 
409
        an `EmptyTree` is returned."""
 
410
        raise NotImplementedError('revision_tree is abstract')
 
411
 
 
412
    def working_tree(self):
 
413
        """Return a `Tree` for the working copy if this is a local branch."""
 
414
        raise NotImplementedError('working_tree is abstract')
 
415
 
 
416
    def pull(self, source, overwrite=False):
 
417
        raise NotImplementedError('pull is abstract')
 
418
 
 
419
    def basis_tree(self):
 
420
        """Return `Tree` object for last revision.
 
421
 
 
422
        If there are no revisions yet, return an `EmptyTree`.
 
423
        """
 
424
        return self.revision_tree(self.last_revision())
 
425
 
 
426
    def rename_one(self, from_rel, to_rel):
 
427
        """Rename one file.
 
428
 
 
429
        This can change the directory or the filename or both.
 
430
        """
 
431
        raise NotImplementedError('rename_one is abstract')
 
432
 
 
433
    def move(self, from_paths, to_name):
 
434
        """Rename files.
 
435
 
 
436
        to_name must exist as a versioned directory.
 
437
 
 
438
        If to_name exists and is a directory, the files are moved into
 
439
        it, keeping their old names.  If it is a directory, 
 
440
 
 
441
        Note that to_name is only the last component of the new name;
 
442
        this doesn't change the directory.
 
443
 
 
444
        This returns a list of (from_path, to_path) pairs for each
 
445
        entry that is moved.
 
446
        """
 
447
        raise NotImplementedError('move is abstract')
 
448
 
 
449
    def get_parent(self):
 
450
        """Return the parent location of the branch.
 
451
 
 
452
        This is the default location for push/pull/missing.  The usual
 
453
        pattern is that the user can override it by specifying a
 
454
        location.
 
455
        """
 
456
        raise NotImplementedError('get_parent is abstract')
 
457
 
 
458
    def get_push_location(self):
 
459
        """Return the None or the location to push this branch to."""
 
460
        raise NotImplementedError('get_push_location is abstract')
 
461
 
 
462
    def set_push_location(self, location):
 
463
        """Set a new push location for this branch."""
 
464
        raise NotImplementedError('set_push_location is abstract')
 
465
 
 
466
    def set_parent(self, url):
 
467
        raise NotImplementedError('set_parent is abstract')
 
468
 
 
469
    def check_revno(self, revno):
 
470
        """\
 
471
        Check whether a revno corresponds to any revision.
 
472
        Zero (the NULL revision) is considered valid.
 
473
        """
 
474
        if revno != 0:
 
475
            self.check_real_revno(revno)
 
476
            
 
477
    def check_real_revno(self, revno):
 
478
        """\
 
479
        Check whether a revno corresponds to a real revision.
 
480
        Zero (the NULL revision) is considered invalid
 
481
        """
 
482
        if revno < 1 or revno > self.revno():
 
483
            raise InvalidRevisionNumber(revno)
 
484
        
 
485
    def sign_revision(self, revision_id, gpg_strategy):
 
486
        raise NotImplementedError('sign_revision is abstract')
 
487
 
 
488
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
 
489
        raise NotImplementedError('store_revision_signature is abstract')
 
490
 
 
491
    def fileid_involved_between_revs(self, from_revid, to_revid):
 
492
        """ This function returns the file_id(s) involved in the
 
493
            changes between the from_revid revision and the to_revid
 
494
            revision
 
495
        """
 
496
        raise NotImplementedError('fileid_involved_between_revs is abstract')
 
497
 
 
498
    def fileid_involved(self, last_revid=None):
 
499
        """ This function returns the file_id(s) involved in the
 
500
            changes up to the revision last_revid
 
501
            If no parametr is passed, then all file_id[s] present in the
 
502
            repository are returned
 
503
        """
 
504
        raise NotImplementedError('fileid_involved is abstract')
 
505
 
 
506
    def fileid_involved_by_set(self, changes):
 
507
        """ This function returns the file_id(s) involved in the
 
508
            changes present in the set 'changes'
 
509
        """
 
510
        raise NotImplementedError('fileid_involved_by_set is abstract')
 
511
 
 
512
class BzrBranch(Branch):
 
513
    """A branch stored in the actual filesystem.
 
514
 
 
515
    Note that it's "local" in the context of the filesystem; it doesn't
 
516
    really matter if it's on an nfs/smb/afs/coda/... share, as long as
 
517
    it's writable, and can be accessed via the normal filesystem API.
 
518
 
 
519
    _lock_mode
 
520
        None, or 'r' or 'w'
 
521
 
 
522
    _lock_count
 
523
        If _lock_mode is true, a positive count of the number of times the
 
524
        lock has been taken.
 
525
 
 
526
    _lock
 
527
        Lock object from bzrlib.lock.
 
528
    """
 
529
    # We actually expect this class to be somewhat short-lived; part of its
 
530
    # purpose is to try to isolate what bits of the branch logic are tied to
 
531
    # filesystem access, so that in a later step, we can extricate them to
 
532
    # a separarte ("storage") class.
 
533
    _lock_mode = None
 
534
    _lock_count = None
 
535
    _lock = None
 
536
    _inventory_weave = None
 
537
    # If set to False (by a plugin, etc) BzrBranch will not set the
 
538
    # mode on created files or directories
 
539
    _set_file_mode = True
 
540
    _set_dir_mode = True
 
541
    
 
542
    # Map some sort of prefix into a namespace
 
543
    # stuff like "revno:10", "revid:", etc.
 
544
    # This should match a prefix with a function which accepts
 
545
    REVISION_NAMESPACES = {}
 
546
 
 
547
    def push_stores(self, branch_to):
 
548
        """See Branch.push_stores."""
 
549
        if (self._branch_format != branch_to._branch_format
 
550
            or self._branch_format != 4):
 
551
            from bzrlib.fetch import greedy_fetch
 
552
            mutter("falling back to fetch logic to push between %s(%s) and %s(%s)",
 
553
                   self, self._branch_format, branch_to, branch_to._branch_format)
 
554
            greedy_fetch(to_branch=branch_to, from_branch=self,
 
555
                         revision=self.last_revision())
 
556
            return
 
557
 
 
558
        store_pairs = ((self.text_store,      branch_to.text_store),
 
559
                       (self.inventory_store, branch_to.inventory_store),
 
560
                       (self.revision_store,  branch_to.revision_store))
 
561
        try:
 
562
            for from_store, to_store in store_pairs: 
 
563
                copy_all(from_store, to_store)
 
564
        except UnlistableStore:
 
565
            raise UnlistableBranch(from_store)
 
566
 
 
567
    def __init__(self, transport, init=False,
 
568
                 relax_version_check=False):
66
569
        """Create new branch object at a particular location.
67
570
 
68
 
        :param base: Base directory for the branch.
69
 
 
70
 
        :param init: If True, create new control files in a previously
 
571
        transport -- A Transport object, defining how to access files.
 
572
        
 
573
        init -- If True, create new control files in a previously
71
574
             unversioned directory.  If False, the branch must already
72
575
             be versioned.
73
576
 
 
577
        relax_version_check -- If true, the usual check for the branch
 
578
            version is not applied.  This is intended only for
 
579
            upgrade/recovery type use; it's not guaranteed that
 
580
            all operations will work on old format branches.
 
581
 
74
582
        In the test suite, creation of new trees is tested using the
75
583
        `ScratchBranch` class.
76
584
        """
77
 
        self.base = os.path.realpath(base)
 
585
        assert isinstance(transport, Transport), \
 
586
            "%r is not a Transport" % transport
 
587
        self._transport = transport
78
588
        if init:
79
589
            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
 
 
 
590
        self._check_format(relax_version_check)
 
591
        self._find_modes()
 
592
 
 
593
        def get_store(name, compressed=True, prefixed=False):
 
594
            relpath = self._rel_controlfilename(unicode(name))
 
595
            store = TextStore(self._transport.clone(relpath),
 
596
                              dir_mode=self._dir_mode,
 
597
                              file_mode=self._file_mode,
 
598
                              prefixed=prefixed,
 
599
                              compressed=compressed)
 
600
            return store
 
601
 
 
602
        def get_weave(name, prefixed=False):
 
603
            relpath = self._rel_controlfilename(unicode(name))
 
604
            ws = WeaveStore(self._transport.clone(relpath),
 
605
                            prefixed=prefixed,
 
606
                            dir_mode=self._dir_mode,
 
607
                            file_mode=self._file_mode)
 
608
            if self._transport.should_cache():
 
609
                ws.enable_cache = True
 
610
            return ws
 
611
 
 
612
        if self._branch_format == 4:
 
613
            self.inventory_store = get_store('inventory-store')
 
614
            self.text_store = get_store('text-store')
 
615
            self.revision_store = get_store('revision-store')
 
616
        elif self._branch_format == 5:
 
617
            self.control_weaves = get_weave(u'')
 
618
            self.weave_store = get_weave(u'weaves')
 
619
            self.revision_store = get_store(u'revision-store', compressed=False)
 
620
        elif self._branch_format == 6:
 
621
            self.control_weaves = get_weave(u'')
 
622
            self.weave_store = get_weave(u'weaves', prefixed=True)
 
623
            self.revision_store = get_store(u'revision-store', compressed=False,
 
624
                                            prefixed=True)
 
625
        self.revision_store.register_suffix('sig')
 
626
        self._transaction = None
91
627
 
92
628
    def __str__(self):
93
 
        return '%s(%r)' % (self.__class__.__name__, self.base)
94
 
 
 
629
        return '%s(%r)' % (self.__class__.__name__, self._transport.base)
95
630
 
96
631
    __repr__ = __str__
97
632
 
98
 
 
99
 
    def _rel(self, name):
100
 
        """Return filename relative to branch top"""
101
 
        return os.path.join(self.base, name)
102
 
        
 
633
    def __del__(self):
 
634
        if self._lock_mode or self._lock:
 
635
            # XXX: This should show something every time, and be suitable for
 
636
            # headless operation and embedding
 
637
            warn("branch %r was not explicitly unlocked" % self)
 
638
            self._lock.unlock()
 
639
 
 
640
        # TODO: It might be best to do this somewhere else,
 
641
        # but it is nice for a Branch object to automatically
 
642
        # cache it's information.
 
643
        # Alternatively, we could have the Transport objects cache requests
 
644
        # See the earlier discussion about how major objects (like Branch)
 
645
        # should never expect their __del__ function to run.
 
646
        if hasattr(self, 'cache_root') and self.cache_root is not None:
 
647
            try:
 
648
                shutil.rmtree(self.cache_root)
 
649
            except:
 
650
                pass
 
651
            self.cache_root = None
 
652
 
 
653
    def _get_base(self):
 
654
        if self._transport:
 
655
            return self._transport.base
 
656
        return None
 
657
 
 
658
    base = property(_get_base, doc="The URL for the root of this branch.")
 
659
 
 
660
    def _finish_transaction(self):
 
661
        """Exit the current transaction."""
 
662
        if self._transaction is None:
 
663
            raise errors.LockError('Branch %s is not in a transaction' %
 
664
                                   self)
 
665
        transaction = self._transaction
 
666
        self._transaction = None
 
667
        transaction.finish()
 
668
 
 
669
    def get_transaction(self):
 
670
        """See Branch.get_transaction."""
 
671
        if self._transaction is None:
 
672
            return transactions.PassThroughTransaction()
 
673
        else:
 
674
            return self._transaction
 
675
 
 
676
    def _set_transaction(self, new_transaction):
 
677
        """Set a new active transaction."""
 
678
        if self._transaction is not None:
 
679
            raise errors.LockError('Branch %s is in a transaction already.' %
 
680
                                   self)
 
681
        self._transaction = new_transaction
 
682
 
 
683
    def lock_write(self):
 
684
        #mutter("lock write: %s (%s)", self, self._lock_count)
 
685
        # TODO: Upgrade locking to support using a Transport,
 
686
        # and potentially a remote locking protocol
 
687
        if self._lock_mode:
 
688
            if self._lock_mode != 'w':
 
689
                raise LockError("can't upgrade to a write lock from %r" %
 
690
                                self._lock_mode)
 
691
            self._lock_count += 1
 
692
        else:
 
693
            self._lock = self._transport.lock_write(
 
694
                    self._rel_controlfilename('branch-lock'))
 
695
            self._lock_mode = 'w'
 
696
            self._lock_count = 1
 
697
            self._set_transaction(transactions.PassThroughTransaction())
 
698
 
 
699
    def lock_read(self):
 
700
        #mutter("lock read: %s (%s)", self, self._lock_count)
 
701
        if self._lock_mode:
 
702
            assert self._lock_mode in ('r', 'w'), \
 
703
                   "invalid lock mode %r" % self._lock_mode
 
704
            self._lock_count += 1
 
705
        else:
 
706
            self._lock = self._transport.lock_read(
 
707
                    self._rel_controlfilename('branch-lock'))
 
708
            self._lock_mode = 'r'
 
709
            self._lock_count = 1
 
710
            self._set_transaction(transactions.ReadOnlyTransaction())
 
711
            # 5K may be excessive, but hey, its a knob.
 
712
            self.get_transaction().set_cache_size(5000)
 
713
                        
 
714
    def unlock(self):
 
715
        #mutter("unlock: %s (%s)", self, self._lock_count)
 
716
        if not self._lock_mode:
 
717
            raise LockError('branch %r is not locked' % (self))
 
718
 
 
719
        if self._lock_count > 1:
 
720
            self._lock_count -= 1
 
721
        else:
 
722
            self._finish_transaction()
 
723
            self._lock.unlock()
 
724
            self._lock = None
 
725
            self._lock_mode = self._lock_count = None
 
726
 
 
727
    def abspath(self, name):
 
728
        """See Branch.abspath."""
 
729
        return self._transport.abspath(name)
 
730
 
 
731
    def _rel_controlfilename(self, file_or_path):
 
732
        if not isinstance(file_or_path, basestring):
 
733
            file_or_path = u'/'.join(file_or_path)
 
734
        if file_or_path == '':
 
735
            return bzrlib.BZRDIR
 
736
        return bzrlib.transport.urlescape(bzrlib.BZRDIR + u'/' + file_or_path)
103
737
 
104
738
    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
 
 
 
739
        """See Branch.controlfilename."""
 
740
        return self._transport.abspath(self._rel_controlfilename(file_or_path))
110
741
 
111
742
    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
 
 
 
743
        """See Branch.controlfile."""
 
744
        import codecs
 
745
 
 
746
        relpath = self._rel_controlfilename(file_or_path)
 
747
        #TODO: codecs.open() buffers linewise, so it was overloaded with
 
748
        # a much larger buffer, do we need to do the same for getreader/getwriter?
 
749
        if mode == 'rb': 
 
750
            return self._transport.get(relpath)
 
751
        elif mode == 'wb':
 
752
            raise BzrError("Branch.controlfile(mode='wb') is not supported, use put_controlfiles")
 
753
        elif mode == 'r':
 
754
            # XXX: Do we really want errors='replace'?   Perhaps it should be
 
755
            # an error, or at least reported, if there's incorrectly-encoded
 
756
            # data inside a file.
 
757
            # <https://launchpad.net/products/bzr/+bug/3823>
 
758
            return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
 
759
        elif mode == 'w':
 
760
            raise BzrError("Branch.controlfile(mode='w') is not supported, use put_controlfiles")
 
761
        else:
 
762
            raise BzrError("invalid controlfile mode %r" % mode)
 
763
 
 
764
    def put_controlfile(self, path, f, encode=True):
 
765
        """See Branch.put_controlfile."""
 
766
        self.put_controlfiles([(path, f)], encode=encode)
 
767
 
 
768
    def put_controlfiles(self, files, encode=True):
 
769
        """See Branch.put_controlfiles."""
 
770
        import codecs
 
771
        ctrl_files = []
 
772
        for path, f in files:
 
773
            if encode:
 
774
                if isinstance(f, basestring):
 
775
                    f = f.encode('utf-8', 'replace')
 
776
                else:
 
777
                    f = codecs.getwriter('utf-8')(f, errors='replace')
 
778
            path = self._rel_controlfilename(path)
 
779
            ctrl_files.append((path, f))
 
780
        self._transport.put_multi(ctrl_files, mode=self._file_mode)
 
781
 
 
782
    def _find_modes(self, path=None):
 
783
        """Determine the appropriate modes for files and directories."""
 
784
        try:
 
785
            if path is None:
 
786
                path = self._rel_controlfilename('')
 
787
            st = self._transport.stat(path)
 
788
        except errors.TransportNotPossible:
 
789
            self._dir_mode = 0755
 
790
            self._file_mode = 0644
 
791
        else:
 
792
            self._dir_mode = st.st_mode & 07777
 
793
            # Remove the sticky and execute bits for files
 
794
            self._file_mode = self._dir_mode & ~07111
 
795
        if not self._set_dir_mode:
 
796
            self._dir_mode = None
 
797
        if not self._set_file_mode:
 
798
            self._file_mode = None
115
799
 
116
800
    def _make_control(self):
117
 
        os.mkdir(self.controlfilename([]))
118
 
        self.controlfile('README', 'w').write(
 
801
        from bzrlib.inventory import Inventory
 
802
        from bzrlib.weavefile import write_weave_v5
 
803
        from bzrlib.weave import Weave
 
804
        
 
805
        # Create an empty inventory
 
806
        sio = StringIO()
 
807
        # if we want per-tree root ids then this is the place to set
 
808
        # them; they're not needed for now and so ommitted for
 
809
        # simplicity.
 
810
        bzrlib.xml5.serializer_v5.write_inventory(Inventory(), sio)
 
811
        empty_inv = sio.getvalue()
 
812
        sio = StringIO()
 
813
        bzrlib.weavefile.write_weave_v5(Weave(), sio)
 
814
        empty_weave = sio.getvalue()
 
815
 
 
816
        cfn = self._rel_controlfilename
 
817
        # Since we don't have a .bzr directory, inherit the
 
818
        # mode from the root directory
 
819
        self._find_modes(u'.')
 
820
 
 
821
        dirs = ['', 'revision-store', 'weaves']
 
822
        files = [('README', 
119
823
            "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):
 
824
            "Do not change any files in this directory.\n"),
 
825
            ('branch-format', BZR_BRANCH_FORMAT_6),
 
826
            ('revision-history', ''),
 
827
            ('branch-name', ''),
 
828
            ('branch-lock', ''),
 
829
            ('pending-merges', ''),
 
830
            ('inventory', empty_inv),
 
831
            ('inventory.weave', empty_weave),
 
832
        ]
 
833
        self._transport.mkdir_multi([cfn(d) for d in dirs], mode=self._dir_mode)
 
834
        self.put_controlfiles(files)
 
835
        mutter('created control directory in ' + self._transport.base)
 
836
 
 
837
    def _check_format(self, relax_version_check):
132
838
        """Check this branch format is supported.
133
839
 
134
 
        The current tool only supports the current unstable format.
 
840
        The format level is stored, as an integer, in
 
841
        self._branch_format for code that needs to check it later.
135
842
 
136
843
        In the future, we might need different in-memory Branch
137
844
        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
 
        ## TODO: factor out to atomicfile?  is rename safe on windows?
163
 
        tmpfname = self.controlfilename('inventory.tmp')
164
 
        tmpf = file(tmpfname, 'w')
165
 
        inv.write_xml(tmpf)
166
 
        tmpf.close()
167
 
        os.rename(tmpfname, self.controlfilename('inventory'))
168
 
        mutter('wrote working inventory')
169
 
 
170
 
 
171
 
    inventory = property(read_working_inventory, _write_inventory, None,
172
 
                         """Inventory for the working copy.""")
173
 
 
174
 
 
175
 
    def add(self, files, verbose=False):
176
 
        """Make files versioned.
177
 
 
178
 
        This puts the files in the Added state, so that they will be
179
 
        recorded by the next commit.
180
 
 
181
 
        :todo: Perhaps have an option to add the ids even if the files do
182
 
               not (yet) exist.
183
 
 
184
 
        :todo: Perhaps return the ids of the files?  But then again it
185
 
               is easy to retrieve them if they're needed.
186
 
 
187
 
        :todo: Option to specify file id.
188
 
 
189
 
        :todo: Adding a directory should optionally recurse down and
190
 
               add all non-ignored children.  Perhaps do that in a
191
 
               higher-level method.
192
 
 
193
 
        >>> b = ScratchBranch(files=['foo'])
194
 
        >>> 'foo' in b.unknowns()
195
 
        True
196
 
        >>> b.show_status()
197
 
        ?       foo
198
 
        >>> b.add('foo')
199
 
        >>> 'foo' in b.unknowns()
200
 
        False
201
 
        >>> bool(b.inventory.path2id('foo'))
202
 
        True
203
 
        >>> b.show_status()
204
 
        A       foo
205
 
 
206
 
        >>> b.add('foo')
207
 
        Traceback (most recent call last):
208
 
        ...
209
 
        BzrError: ('foo is already versioned', [])
210
 
 
211
 
        >>> b.add(['nothere'])
212
 
        Traceback (most recent call last):
213
 
        BzrError: ('cannot add: not a regular file or directory: nothere', [])
214
 
        """
215
 
 
216
 
        # TODO: Re-adding a file that is removed in the working copy
217
 
        # should probably put it back with the previous ID.
218
 
        if isinstance(files, types.StringTypes):
219
 
            files = [files]
220
 
        
221
 
        inv = self.read_working_inventory()
222
 
        for f in files:
223
 
            if is_control_file(f):
224
 
                bailout("cannot add control file %s" % quotefn(f))
225
 
 
226
 
            fp = splitpath(f)
227
 
 
228
 
            if len(fp) == 0:
229
 
                bailout("cannot add top-level %r" % f)
230
 
                
231
 
            fullpath = os.path.normpath(self._rel(f))
232
 
 
233
 
            if isfile(fullpath):
234
 
                kind = 'file'
235
 
            elif isdir(fullpath):
236
 
                kind = 'directory'
237
 
            else:
238
 
                bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
239
 
 
240
 
            if len(fp) > 1:
241
 
                parent_name = joinpath(fp[:-1])
242
 
                mutter("lookup parent %r" % parent_name)
243
 
                parent_id = inv.path2id(parent_name)
244
 
                if parent_id == None:
245
 
                    bailout("cannot add: parent %r is not versioned"
246
 
                            % joinpath(fp[:-1]))
247
 
            else:
248
 
                parent_id = None
249
 
 
250
 
            file_id = _gen_file_id(fp[-1])
251
 
            inv.add(InventoryEntry(file_id, fp[-1], kind=kind, parent_id=parent_id))
252
 
            if verbose:
253
 
                show_status('A', kind, quotefn(f))
254
 
                
255
 
            mutter("add file %s file_id:{%s} kind=%r parent_id={%s}"
256
 
                   % (f, file_id, kind, parent_id))
257
 
        self._write_inventory(inv)
258
 
 
259
 
 
260
 
 
261
 
    def remove(self, files, verbose=False):
262
 
        """Mark nominated files for removal from the inventory.
263
 
 
264
 
        This does not remove their text.  This does not run on 
265
 
 
266
 
        :todo: Refuse to remove modified files unless --force is given?
267
 
 
268
 
        >>> b = ScratchBranch(files=['foo'])
269
 
        >>> b.add('foo')
270
 
        >>> b.inventory.has_filename('foo')
271
 
        True
272
 
        >>> b.remove('foo')
273
 
        >>> b.working_tree().has_filename('foo')
274
 
        True
275
 
        >>> b.inventory.has_filename('foo')
276
 
        False
277
 
        
278
 
        >>> b = ScratchBranch(files=['foo'])
279
 
        >>> b.add('foo')
280
 
        >>> b.commit('one')
281
 
        >>> b.remove('foo')
282
 
        >>> b.commit('two')
283
 
        >>> b.inventory.has_filename('foo') 
284
 
        False
285
 
        >>> b.basis_tree().has_filename('foo') 
286
 
        False
287
 
        >>> b.working_tree().has_filename('foo') 
288
 
        True
289
 
 
290
 
        :todo: Do something useful with directories.
291
 
 
292
 
        :todo: Should this remove the text or not?  Tough call; not
293
 
        removing may be useful and the user can just use use rm, and
294
 
        is the opposite of add.  Removing it is consistent with most
295
 
        other tools.  Maybe an option.
296
 
        """
297
 
        ## TODO: Normalize names
298
 
        ## TODO: Remove nested loops; better scalability
299
 
 
300
 
        if isinstance(files, types.StringTypes):
301
 
            files = [files]
302
 
        
303
 
        tree = self.working_tree()
304
 
        inv = tree.inventory
305
 
 
306
 
        # do this before any modifications
307
 
        for f in files:
308
 
            fid = inv.path2id(f)
309
 
            if not fid:
310
 
                bailout("cannot remove unversioned file %s" % quotefn(f))
311
 
            mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
312
 
            if verbose:
313
 
                # having remove it, it must be either ignored or unknown
314
 
                if tree.is_ignored(f):
315
 
                    new_status = 'I'
316
 
                else:
317
 
                    new_status = '?'
318
 
                show_status(new_status, inv[fid].kind, quotefn(f))
319
 
            del inv[fid]
320
 
 
321
 
        self._write_inventory(inv)
322
 
 
323
 
 
324
 
    def unknowns(self):
325
 
        """Return all unknown files.
326
 
 
327
 
        These are files in the working directory that are not versioned or
328
 
        control files or ignored.
329
 
        
330
 
        >>> b = ScratchBranch(files=['foo', 'foo~'])
331
 
        >>> list(b.unknowns())
332
 
        ['foo']
333
 
        >>> b.add('foo')
334
 
        >>> list(b.unknowns())
335
 
        []
336
 
        >>> b.remove('foo')
337
 
        >>> list(b.unknowns())
338
 
        ['foo']
339
 
        """
340
 
        return self.working_tree().unknowns()
341
 
 
342
 
 
343
 
    def commit(self, message, timestamp=None, timezone=None,
344
 
               committer=None,
345
 
               verbose=False):
346
 
        """Commit working copy as a new revision.
347
 
        
348
 
        The basic approach is to add all the file texts into the
349
 
        store, then the inventory, then make a new revision pointing
350
 
        to that inventory and store that.
351
 
        
352
 
        This is not quite safe if the working copy changes during the
353
 
        commit; for the moment that is simply not allowed.  A better
354
 
        approach is to make a temporary copy of the files before
355
 
        computing their hashes, and then add those hashes in turn to
356
 
        the inventory.  This should mean at least that there are no
357
 
        broken hash pointers.  There is no way we can get a snapshot
358
 
        of the whole directory at an instant.  This would also have to
359
 
        be robust against files disappearing, moving, etc.  So the
360
 
        whole thing is a bit hard.
361
 
 
362
 
        :param timestamp: if not None, seconds-since-epoch for a
363
 
             postdated/predated commit.
364
 
        """
365
 
 
366
 
        ## TODO: Show branch names
367
 
 
368
 
        # TODO: Don't commit if there are no changes, unless forced?
369
 
 
370
 
        # First walk over the working inventory; and both update that
371
 
        # and also build a new revision inventory.  The revision
372
 
        # inventory needs to hold the text-id, sha1 and size of the
373
 
        # actual file versions committed in the revision.  (These are
374
 
        # not present in the working inventory.)  We also need to
375
 
        # detect missing/deleted files, and remove them from the
376
 
        # working inventory.
377
 
 
378
 
        work_inv = self.read_working_inventory()
379
 
        inv = Inventory()
380
 
        basis = self.basis_tree()
381
 
        basis_inv = basis.inventory
382
 
        missing_ids = []
383
 
        for path, entry in work_inv.iter_entries():
384
 
            ## TODO: Cope with files that have gone missing.
385
 
 
386
 
            ## TODO: Check that the file kind has not changed from the previous
387
 
            ## revision of this file (if any).
388
 
 
389
 
            entry = entry.copy()
390
 
 
391
 
            p = self._rel(path)
392
 
            file_id = entry.file_id
393
 
            mutter('commit prep file %s, id %r ' % (p, file_id))
394
 
 
395
 
            if not os.path.exists(p):
396
 
                mutter("    file is missing, removing from inventory")
397
 
                if verbose:
398
 
                    show_status('D', entry.kind, quotefn(path))
399
 
                missing_ids.append(file_id)
400
 
                continue
401
 
 
402
 
            # TODO: Handle files that have been deleted
403
 
 
404
 
            # TODO: Maybe a special case for empty files?  Seems a
405
 
            # waste to store them many times.
406
 
 
407
 
            inv.add(entry)
408
 
 
409
 
            if basis_inv.has_id(file_id):
410
 
                old_kind = basis_inv[file_id].kind
411
 
                if old_kind != entry.kind:
412
 
                    bailout("entry %r changed kind from %r to %r"
413
 
                            % (file_id, old_kind, entry.kind))
414
 
 
415
 
            if entry.kind == 'directory':
416
 
                if not isdir(p):
417
 
                    bailout("%s is entered as directory but not a directory" % quotefn(p))
418
 
            elif entry.kind == 'file':
419
 
                if not isfile(p):
420
 
                    bailout("%s is entered as file but is not a file" % quotefn(p))
421
 
 
422
 
                content = file(p, 'rb').read()
423
 
 
424
 
                entry.text_sha1 = sha_string(content)
425
 
                entry.text_size = len(content)
426
 
 
427
 
                old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
428
 
                if (old_ie
429
 
                    and (old_ie.text_size == entry.text_size)
430
 
                    and (old_ie.text_sha1 == entry.text_sha1)):
431
 
                    ## assert content == basis.get_file(file_id).read()
432
 
                    entry.text_id = basis_inv[file_id].text_id
433
 
                    mutter('    unchanged from previous text_id {%s}' %
434
 
                           entry.text_id)
435
 
                    
436
 
                else:
437
 
                    entry.text_id = _gen_file_id(entry.name)
438
 
                    self.text_store.add(content, entry.text_id)
439
 
                    mutter('    stored with text_id {%s}' % entry.text_id)
440
 
                    if verbose:
441
 
                        if not old_ie:
442
 
                            state = 'A'
443
 
                        elif (old_ie.name == entry.name
444
 
                              and old_ie.parent_id == entry.parent_id):
445
 
                            state = 'R'
446
 
                        else:
447
 
                            state = 'M'
448
 
 
449
 
                        show_status(state, entry.kind, quotefn(path))
450
 
 
451
 
        for file_id in missing_ids:
452
 
            # have to do this later so we don't mess up the iterator.
453
 
            # since parents may be removed before their children we
454
 
            # have to test.
455
 
 
456
 
            # FIXME: There's probably a better way to do this; perhaps
457
 
            # the workingtree should know how to filter itself.
458
 
            if work_inv.has_id(file_id):
459
 
                del work_inv[file_id]
460
 
 
461
 
 
462
 
        inv_id = rev_id = _gen_revision_id(time.time())
463
 
        
464
 
        inv_tmp = tempfile.TemporaryFile()
465
 
        inv.write_xml(inv_tmp)
466
 
        inv_tmp.seek(0)
467
 
        self.inventory_store.add(inv_tmp, inv_id)
468
 
        mutter('new inventory_id is {%s}' % inv_id)
469
 
 
470
 
        self._write_inventory(work_inv)
471
 
 
472
 
        if timestamp == None:
473
 
            timestamp = time.time()
474
 
 
475
 
        if committer == None:
476
 
            committer = username()
477
 
 
478
 
        if timezone == None:
479
 
            timezone = local_time_offset()
480
 
 
481
 
        mutter("building commit log message")
482
 
        rev = Revision(timestamp=timestamp,
483
 
                       timezone=timezone,
484
 
                       committer=committer,
485
 
                       precursor = self.last_patch(),
486
 
                       message = message,
487
 
                       inventory_id=inv_id,
488
 
                       revision_id=rev_id)
489
 
 
490
 
        rev_tmp = tempfile.TemporaryFile()
491
 
        rev.write_xml(rev_tmp)
492
 
        rev_tmp.seek(0)
493
 
        self.revision_store.add(rev_tmp, rev_id)
494
 
        mutter("new revision_id is {%s}" % rev_id)
495
 
        
496
 
        ## XXX: Everything up to here can simply be orphaned if we abort
497
 
        ## the commit; it will leave junk files behind but that doesn't
498
 
        ## matter.
499
 
 
500
 
        ## TODO: Read back the just-generated changeset, and make sure it
501
 
        ## applies and recreates the right state.
502
 
 
503
 
        ## TODO: Also calculate and store the inventory SHA1
504
 
        mutter("committing patch r%d" % (self.revno() + 1))
505
 
 
506
 
        mutter("append to revision-history")
507
 
        self.controlfile('revision-history', 'at').write(rev_id + '\n')
508
 
 
509
 
        mutter("done!")
510
 
 
 
845
        """
 
846
        try:
 
847
            fmt = self.controlfile('branch-format', 'r').read()
 
848
        except NoSuchFile:
 
849
            raise NotBranchError(path=self.base)
 
850
        mutter("got branch format %r", fmt)
 
851
        if fmt == BZR_BRANCH_FORMAT_6:
 
852
            self._branch_format = 6
 
853
        elif fmt == BZR_BRANCH_FORMAT_5:
 
854
            self._branch_format = 5
 
855
        elif fmt == BZR_BRANCH_FORMAT_4:
 
856
            self._branch_format = 4
 
857
 
 
858
        if (not relax_version_check
 
859
            and self._branch_format not in (5, 6)):
 
860
            raise errors.UnsupportedFormatError(
 
861
                           'sorry, branch format %r not supported' % fmt,
 
862
                           ['use a different bzr version',
 
863
                            'or remove the .bzr directory'
 
864
                            ' and "bzr init" again'])
 
865
 
 
866
    @needs_read_lock
 
867
    def get_root_id(self):
 
868
        """See Branch.get_root_id."""
 
869
        inv = self.get_inventory(self.last_revision())
 
870
        return inv.root.file_id
 
871
 
 
872
    @needs_read_lock
 
873
    def print_file(self, file, revision_id):
 
874
        """See Branch.print_file."""
 
875
        tree = self.revision_tree(revision_id)
 
876
        # use inventory as it was in that revision
 
877
        file_id = tree.inventory.path2id(file)
 
878
        if not file_id:
 
879
            try:
 
880
                revno = self.revision_id_to_revno(revision_id)
 
881
            except errors.NoSuchRevision:
 
882
                # TODO: This should not be BzrError,
 
883
                # but NoSuchFile doesn't fit either
 
884
                raise BzrError('%r is not present in revision %s' 
 
885
                                % (file, revision_id))
 
886
            else:
 
887
                raise BzrError('%r is not present in revision %s'
 
888
                                % (file, revno))
 
889
        tree.print_file(file_id)
 
890
 
 
891
    @needs_write_lock
 
892
    def append_revision(self, *revision_ids):
 
893
        """See Branch.append_revision."""
 
894
        for revision_id in revision_ids:
 
895
            mutter("add {%s} to revision-history" % revision_id)
 
896
        rev_history = self.revision_history()
 
897
        rev_history.extend(revision_ids)
 
898
        self.set_revision_history(rev_history)
 
899
 
 
900
    @needs_write_lock
 
901
    def set_revision_history(self, rev_history):
 
902
        """See Branch.set_revision_history."""
 
903
        old_revision = self.last_revision()
 
904
        new_revision = rev_history[-1]
 
905
        self.put_controlfile('revision-history', '\n'.join(rev_history))
 
906
        try:
 
907
            self.working_tree().set_last_revision(new_revision, old_revision)
 
908
        except NoWorkingTree:
 
909
            mutter('Unable to set_last_revision without a working tree.')
 
910
 
 
911
    def has_revision(self, revision_id):
 
912
        """See Branch.has_revision."""
 
913
        return (revision_id is None
 
914
                or self.revision_store.has_id(revision_id))
 
915
 
 
916
    @needs_read_lock
 
917
    def _get_revision_xml_file(self, revision_id):
 
918
        if not revision_id or not isinstance(revision_id, basestring):
 
919
            raise InvalidRevisionId(revision_id=revision_id, branch=self)
 
920
        try:
 
921
            return self.revision_store.get(revision_id)
 
922
        except (IndexError, KeyError):
 
923
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
 
924
 
 
925
    def get_revision_xml(self, revision_id):
 
926
        """See Branch.get_revision_xml."""
 
927
        return self._get_revision_xml_file(revision_id).read()
511
928
 
512
929
    def get_revision(self, revision_id):
513
 
        """Return the Revision object for a named revision"""
514
 
        r = Revision.read_xml(self.revision_store[revision_id])
 
930
        """See Branch.get_revision."""
 
931
        xml_file = self._get_revision_xml_file(revision_id)
 
932
 
 
933
        try:
 
934
            r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
 
935
        except SyntaxError, e:
 
936
            raise bzrlib.errors.BzrError('failed to unpack revision_xml',
 
937
                                         [revision_id,
 
938
                                          str(e)])
 
939
            
515
940
        assert r.revision_id == revision_id
516
941
        return r
517
942
 
518
 
 
519
 
    def get_inventory(self, inventory_id):
520
 
        """Get Inventory object by hash.
521
 
 
522
 
        :todo: Perhaps for this and similar methods, take a revision
523
 
               parameter which can be either an integer revno or a
524
 
               string hash."""
525
 
        i = Inventory.read_xml(self.inventory_store[inventory_id])
526
 
        return i
527
 
 
528
 
 
529
 
    def get_revision_inventory(self, revision_id):
530
 
        """Return inventory of a past revision."""
531
 
        if revision_id == None:
532
 
            return Inventory()
533
 
        else:
534
 
            return self.get_inventory(self.get_revision(revision_id).inventory_id)
535
 
 
536
 
 
537
 
    def revision_history(self):
538
 
        """Return sequence of revision hashes on to this branch.
539
 
 
540
 
        >>> ScratchBranch().revision_history()
541
 
        []
542
 
        """
543
 
        return [chomp(l) for l in self.controlfile('revision-history').readlines()]
544
 
 
545
 
 
546
 
    def revno(self):
547
 
        """Return current revision number for this branch.
548
 
 
549
 
        That is equivalent to the number of revisions committed to
550
 
        this branch.
551
 
 
552
 
        >>> b = ScratchBranch()
553
 
        >>> b.revno()
554
 
        0
555
 
        >>> b.commit('no foo')
556
 
        >>> b.revno()
557
 
        1
558
 
        """
559
 
        return len(self.revision_history())
560
 
 
561
 
 
562
 
    def last_patch(self):
563
 
        """Return last patch hash, or None if no history.
564
 
 
565
 
        >>> ScratchBranch().last_patch() == None
566
 
        True
567
 
        """
568
 
        ph = self.revision_history()
569
 
        if ph:
570
 
            return ph[-1]
571
 
 
572
 
 
573
 
    def lookup_revision(self, revno):
574
 
        """Return revision hash for revision number."""
575
 
        if revno == 0:
576
 
            return None
577
 
 
 
943
    def get_revision_sha1(self, revision_id):
 
944
        """See Branch.get_revision_sha1."""
 
945
        # In the future, revision entries will be signed. At that
 
946
        # point, it is probably best *not* to include the signature
 
947
        # in the revision hash. Because that lets you re-sign
 
948
        # the revision, (add signatures/remove signatures) and still
 
949
        # have all hash pointers stay consistent.
 
950
        # But for now, just hash the contents.
 
951
        return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
 
952
 
 
953
    def get_ancestry(self, revision_id):
 
954
        """See Branch.get_ancestry."""
 
955
        if revision_id is None:
 
956
            return [None]
 
957
        w = self._get_inventory_weave()
 
958
        return [None] + map(w.idx_to_name,
 
959
                            w.inclusions([w.lookup(revision_id)]))
 
960
 
 
961
    def _get_inventory_weave(self):
 
962
        return self.control_weaves.get_weave('inventory',
 
963
                                             self.get_transaction())
 
964
 
 
965
    def get_inventory(self, revision_id):
 
966
        """See Branch.get_inventory."""
 
967
        xml = self.get_inventory_xml(revision_id)
 
968
        return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
 
969
 
 
970
    def get_inventory_xml(self, revision_id):
 
971
        """See Branch.get_inventory_xml."""
578
972
        try:
579
 
            # list is 0-based; revisions are 1-based
580
 
            return self.revision_history()[revno-1]
 
973
            assert isinstance(revision_id, basestring), type(revision_id)
 
974
            iw = self._get_inventory_weave()
 
975
            return iw.get_text(iw.lookup(revision_id))
581
976
        except IndexError:
582
 
            bailout("no such revision %s" % revno)
583
 
 
584
 
 
 
977
            raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
 
978
 
 
979
    def get_inventory_sha1(self, revision_id):
 
980
        """See Branch.get_inventory_sha1."""
 
981
        return self.get_revision(revision_id).inventory_sha1
 
982
 
 
983
    def get_revision_inventory(self, revision_id):
 
984
        """See Branch.get_revision_inventory."""
 
985
        # TODO: Unify this with get_inventory()
 
986
        # bzr 0.0.6 and later imposes the constraint that the inventory_id
 
987
        # must be the same as its revision, so this is trivial.
 
988
        if revision_id == None:
 
989
            # This does not make sense: if there is no revision,
 
990
            # then it is the current tree inventory surely ?!
 
991
            # and thus get_root_id() is something that looks at the last
 
992
            # commit on the branch, and the get_root_id is an inventory check.
 
993
            raise NotImplementedError
 
994
            # return Inventory(self.get_root_id())
 
995
        else:
 
996
            return self.get_inventory(revision_id)
 
997
 
 
998
    @needs_read_lock
 
999
    def revision_history(self):
 
1000
        """See Branch.revision_history."""
 
1001
        transaction = self.get_transaction()
 
1002
        history = transaction.map.find_revision_history()
 
1003
        if history is not None:
 
1004
            mutter("cache hit for revision-history in %s", self)
 
1005
            return list(history)
 
1006
        history = [l.rstrip('\r\n') for l in
 
1007
                self.controlfile('revision-history', 'r').readlines()]
 
1008
        transaction.map.add_revision_history(history)
 
1009
        # this call is disabled because revision_history is 
 
1010
        # not really an object yet, and the transaction is for objects.
 
1011
        # transaction.register_clean(history, precious=True)
 
1012
        return list(history)
 
1013
 
 
1014
    def update_revisions(self, other, stop_revision=None):
 
1015
        """See Branch.update_revisions."""
 
1016
        from bzrlib.fetch import greedy_fetch
 
1017
        if stop_revision is None:
 
1018
            stop_revision = other.last_revision()
 
1019
        ### Should this be checking is_ancestor instead of revision_history?
 
1020
        if (stop_revision is not None and 
 
1021
            stop_revision in self.revision_history()):
 
1022
            return
 
1023
        greedy_fetch(to_branch=self, from_branch=other,
 
1024
                     revision=stop_revision)
 
1025
        pullable_revs = self.pullable_revisions(other, stop_revision)
 
1026
        if len(pullable_revs) > 0:
 
1027
            self.append_revision(*pullable_revs)
 
1028
 
 
1029
    def pullable_revisions(self, other, stop_revision):
 
1030
        """See Branch.pullable_revisions."""
 
1031
        other_revno = other.revision_id_to_revno(stop_revision)
 
1032
        try:
 
1033
            return self.missing_revisions(other, other_revno)
 
1034
        except DivergedBranches, e:
 
1035
            try:
 
1036
                pullable_revs = get_intervening_revisions(self.last_revision(),
 
1037
                                                          stop_revision, self)
 
1038
                assert self.last_revision() not in pullable_revs
 
1039
                return pullable_revs
 
1040
            except bzrlib.errors.NotAncestor:
 
1041
                if is_ancestor(self.last_revision(), stop_revision, self):
 
1042
                    return []
 
1043
                else:
 
1044
                    raise e
 
1045
        
585
1046
    def revision_tree(self, revision_id):
586
 
        """Return Tree for a revision on this branch.
587
 
 
588
 
        `revision_id` may be None for the null revision, in which case
589
 
        an `EmptyTree` is returned."""
590
 
 
591
 
        if revision_id == None:
 
1047
        """See Branch.revision_tree."""
 
1048
        # TODO: refactor this to use an existing revision object
 
1049
        # so we don't need to read it in twice.
 
1050
        if revision_id == None or revision_id == NULL_REVISION:
592
1051
            return EmptyTree()
593
1052
        else:
594
1053
            inv = self.get_revision_inventory(revision_id)
595
 
            return RevisionTree(self.text_store, inv)
 
1054
            return RevisionTree(self, inv, revision_id)
596
1055
 
 
1056
    def basis_tree(self):
 
1057
        """See Branch.basis_tree."""
 
1058
        try:
 
1059
            revision_id = self.revision_history()[-1]
 
1060
            xml = self.working_tree().read_basis_inventory(revision_id)
 
1061
            inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
 
1062
            return RevisionTree(self, inv, revision_id)
 
1063
        except (IndexError, NoSuchFile, NoWorkingTree), e:
 
1064
            return self.revision_tree(self.last_revision())
597
1065
 
598
1066
    def working_tree(self):
599
 
        """Return a `Tree` for the working copy."""
600
 
        return WorkingTree(self.base, self.read_working_inventory())
601
 
 
602
 
 
603
 
    def basis_tree(self):
604
 
        """Return `Tree` object for last revision.
605
 
 
606
 
        If there are no revisions yet, return an `EmptyTree`.
607
 
 
608
 
        >>> b = ScratchBranch(files=['foo'])
609
 
        >>> b.basis_tree().has_filename('foo')
610
 
        False
611
 
        >>> b.working_tree().has_filename('foo')
612
 
        True
613
 
        >>> b.add('foo')
614
 
        >>> b.commit('add foo')
615
 
        >>> b.basis_tree().has_filename('foo')
616
 
        True
617
 
        """
618
 
        r = self.last_patch()
619
 
        if r == None:
620
 
            return EmptyTree()
 
1067
        """See Branch.working_tree."""
 
1068
        from bzrlib.workingtree import WorkingTree
 
1069
        if self._transport.base.find('://') != -1:
 
1070
            raise NoWorkingTree(self.base)
 
1071
        return WorkingTree(self.base, branch=self)
 
1072
 
 
1073
    @needs_write_lock
 
1074
    def pull(self, source, overwrite=False):
 
1075
        """See Branch.pull."""
 
1076
        source.lock_read()
 
1077
        try:
 
1078
            old_count = len(self.revision_history())
 
1079
            try:
 
1080
                self.update_revisions(source)
 
1081
            except DivergedBranches:
 
1082
                if not overwrite:
 
1083
                    raise
 
1084
            if overwrite:
 
1085
                self.set_revision_history(source.revision_history())
 
1086
            new_count = len(self.revision_history())
 
1087
            return new_count - old_count
 
1088
        finally:
 
1089
            source.unlock()
 
1090
 
 
1091
    def get_parent(self):
 
1092
        """See Branch.get_parent."""
 
1093
        import errno
 
1094
        _locs = ['parent', 'pull', 'x-pull']
 
1095
        for l in _locs:
 
1096
            try:
 
1097
                return self.controlfile(l, 'r').read().strip('\n')
 
1098
            except NoSuchFile:
 
1099
                pass
 
1100
        return None
 
1101
 
 
1102
    def get_push_location(self):
 
1103
        """See Branch.get_push_location."""
 
1104
        config = bzrlib.config.BranchConfig(self)
 
1105
        push_loc = config.get_user_option('push_location')
 
1106
        return push_loc
 
1107
 
 
1108
    def set_push_location(self, location):
 
1109
        """See Branch.set_push_location."""
 
1110
        config = bzrlib.config.LocationConfig(self.base)
 
1111
        config.set_user_option('push_location', location)
 
1112
 
 
1113
    @needs_write_lock
 
1114
    def set_parent(self, url):
 
1115
        """See Branch.set_parent."""
 
1116
        # TODO: Maybe delete old location files?
 
1117
        from bzrlib.atomicfile import AtomicFile
 
1118
        f = AtomicFile(self.controlfilename('parent'))
 
1119
        try:
 
1120
            f.write(url + '\n')
 
1121
            f.commit()
 
1122
        finally:
 
1123
            f.close()
 
1124
 
 
1125
    def tree_config(self):
 
1126
        return TreeConfig(self)
 
1127
 
 
1128
    def sign_revision(self, revision_id, gpg_strategy):
 
1129
        """See Branch.sign_revision."""
 
1130
        plaintext = Testament.from_revision(self, revision_id).as_short_text()
 
1131
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
 
1132
 
 
1133
    @needs_write_lock
 
1134
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
 
1135
        """See Branch.store_revision_signature."""
 
1136
        self.revision_store.add(StringIO(gpg_strategy.sign(plaintext)), 
 
1137
                                revision_id, "sig")
 
1138
 
 
1139
    def fileid_involved_between_revs(self, from_revid, to_revid):
 
1140
        """Find file_id(s) which are involved in the changes between revisions.
 
1141
 
 
1142
        This determines the set of revisions which are involved, and then
 
1143
        finds all file ids affected by those revisions.
 
1144
        """
 
1145
        # TODO: jam 20060119 This code assumes that w.inclusions will
 
1146
        #       always be correct. But because of the presence of ghosts
 
1147
        #       it is possible to be wrong.
 
1148
        #       One specific example from Robert Collins:
 
1149
        #       Two branches, with revisions ABC, and AD
 
1150
        #       C is a ghost merge of D.
 
1151
        #       Inclusions doesn't recognize D as an ancestor.
 
1152
        #       If D is ever merged in the future, the weave
 
1153
        #       won't be fixed, because AD never saw revision C
 
1154
        #       to cause a conflict which would force a reweave.
 
1155
        w = self._get_inventory_weave( )
 
1156
        from_set = set(w.inclusions([w.lookup(from_revid)]))
 
1157
        to_set = set(w.inclusions([w.lookup(to_revid)]))
 
1158
        included = to_set.difference(from_set)
 
1159
        changed = map(w.idx_to_name,included)
 
1160
        return self._fileid_involved_by_set(changed)
 
1161
 
 
1162
    def fileid_involved(self, last_revid=None):
 
1163
        """Find all file_ids modified in the ancestry of last_revid.
 
1164
 
 
1165
        :param last_revid: If None, last_revision() will be used.
 
1166
        """
 
1167
        w = self._get_inventory_weave( )
 
1168
        if not last_revid:
 
1169
            changed = set(w._names)
621
1170
        else:
622
 
            return RevisionTree(self.text_store, self.get_revision_inventory(r))
623
 
 
624
 
 
625
 
 
626
 
    def write_log(self, show_timezone='original'):
627
 
        """Write out human-readable log of commits to this branch
628
 
 
629
 
        :param utc: If true, show dates in universal time, not local time."""
630
 
        ## TODO: Option to choose either original, utc or local timezone
631
 
        revno = 1
632
 
        precursor = None
633
 
        for p in self.revision_history():
634
 
            print '-' * 40
635
 
            print 'revno:', revno
636
 
            ## TODO: Show hash if --id is given.
637
 
            ##print 'revision-hash:', p
638
 
            rev = self.get_revision(p)
639
 
            print 'committer:', rev.committer
640
 
            print 'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
641
 
                                                 show_timezone))
642
 
 
643
 
            ## opportunistic consistency check, same as check_patch_chaining
644
 
            if rev.precursor != precursor:
645
 
                bailout("mismatched precursor!")
646
 
 
647
 
            print 'message:'
648
 
            if not rev.message:
649
 
                print '  (no message)'
650
 
            else:
651
 
                for l in rev.message.split('\n'):
652
 
                    print '  ' + l
653
 
 
654
 
            revno += 1
655
 
            precursor = p
656
 
 
657
 
 
658
 
 
659
 
    def show_status(branch, show_all=False):
660
 
        """Display single-line status for non-ignored working files.
661
 
 
662
 
        The list is show sorted in order by file name.
663
 
 
664
 
        >>> b = ScratchBranch(files=['foo', 'foo~'])
665
 
        >>> b.show_status()
666
 
        ?       foo
667
 
        >>> b.add('foo')
668
 
        >>> b.show_status()
669
 
        A       foo
670
 
        >>> b.commit("add foo")
671
 
        >>> b.show_status()
672
 
        >>> os.unlink(b._rel('foo'))
673
 
        >>> b.show_status()
674
 
        D       foo
 
1171
            included = w.inclusions([w.lookup(last_revid)])
 
1172
            changed = map(w.idx_to_name, included)
 
1173
        return self._fileid_involved_by_set(changed)
 
1174
 
 
1175
    def fileid_involved_by_set(self, changes):
 
1176
        """Find all file_ids modified by the set of revisions passed in.
 
1177
 
 
1178
        :param changes: A set() of revision ids
 
1179
        """
 
1180
        # TODO: jam 20060119 This line does *nothing*, remove it.
 
1181
        #       or better yet, change _fileid_involved_by_set so
 
1182
        #       that it takes the inventory weave, rather than
 
1183
        #       pulling it out by itself.
 
1184
        w = self._get_inventory_weave( )
 
1185
        return self._fileid_involved_by_set(changes)
 
1186
 
 
1187
    def _fileid_involved_by_set(self, changes):
 
1188
        """Find the set of file-ids affected by the set of revisions.
 
1189
 
 
1190
        :param changes: A set() of revision ids.
 
1191
        :return: A set() of file ids.
675
1192
        
676
 
 
677
 
        :todo: Get state for single files.
678
 
 
679
 
        :todo: Perhaps show a slash at the end of directory names.        
680
 
 
 
1193
        This peaks at the Weave, interpreting each line, looking to
 
1194
        see if it mentions one of the revisions. And if so, includes
 
1195
        the file id mentioned.
 
1196
        This expects both the Weave format, and the serialization
 
1197
        to have a single line per file/directory, and to have
 
1198
        fileid="" and revision="" on that line.
681
1199
        """
682
 
 
683
 
        # We have to build everything into a list first so that it can
684
 
        # sorted by name, incorporating all the different sources.
685
 
 
686
 
        # FIXME: Rather than getting things in random order and then sorting,
687
 
        # just step through in order.
688
 
 
689
 
        # Interesting case: the old ID for a file has been removed,
690
 
        # but a new file has been created under that name.
691
 
 
692
 
        old = branch.basis_tree()
693
 
        old_inv = old.inventory
694
 
        new = branch.working_tree()
695
 
        new_inv = new.inventory
696
 
 
697
 
        for fs, fid, oldname, newname, kind in diff_trees(old, new):
698
 
            if fs == 'R':
699
 
                show_status(fs, kind,
700
 
                            oldname + ' => ' + newname)
701
 
            elif fs == 'A' or fs == 'M':
702
 
                show_status(fs, kind, newname)
703
 
            elif fs == 'D':
704
 
                show_status(fs, kind, oldname)
705
 
            elif fs == '.':
706
 
                if show_all:
707
 
                    show_status(fs, kind, newname)
708
 
            elif fs == 'I':
709
 
                if show_all:
710
 
                    show_status(fs, kind, newname)
711
 
            elif fs == '?':
712
 
                show_status(fs, kind, newname)
713
 
            else:
714
 
                bailout("wierd file state %r" % ((fs, fid),))
715
 
                
716
 
 
717
 
 
718
 
class ScratchBranch(Branch):
 
1200
        assert self._branch_format in (5,6), \
 
1201
            "fileid_involved only supported for branches which store inventory as xml"
 
1202
 
 
1203
        w = self._get_inventory_weave( )
 
1204
        file_ids = set( )
 
1205
        for line in w._weave:
 
1206
 
 
1207
            # it is ugly, but it is due to the weave structure
 
1208
            if not isinstance(line,basestring): continue
 
1209
 
 
1210
            start = line.find('file_id="')+9
 
1211
            if start < 9: continue
 
1212
            end = line.find('"',start)
 
1213
            assert end>= 0
 
1214
            file_id = xml.sax.saxutils.unescape(line[start:end])
 
1215
 
 
1216
            # check if file_id is already present
 
1217
            if file_id in file_ids: continue
 
1218
 
 
1219
            start = line.find('revision="')+10
 
1220
            if start < 10: continue
 
1221
            end = line.find('"',start)
 
1222
            assert end>= 0
 
1223
            revision_id = xml.sax.saxutils.unescape(line[start:end])
 
1224
 
 
1225
            if revision_id in changes:
 
1226
                file_ids.add(file_id)
 
1227
 
 
1228
        return file_ids
 
1229
 
 
1230
 
 
1231
class ScratchBranch(BzrBranch):
719
1232
    """Special test class: a branch that cleans up after itself.
720
1233
 
721
1234
    >>> b = ScratchBranch()
722
1235
    >>> isdir(b.base)
723
1236
    True
724
1237
    >>> bd = b.base
725
 
    >>> del b
 
1238
    >>> b._transport.__del__()
726
1239
    >>> isdir(bd)
727
1240
    False
728
1241
    """
729
 
    def __init__(self, files = []):
 
1242
 
 
1243
    def __init__(self, files=[], dirs=[], transport=None):
730
1244
        """Make a test branch.
731
1245
 
732
1246
        This creates a temporary directory and runs init-tree in it.
733
1247
 
734
1248
        If any files are listed, they are created in the working copy.
735
1249
        """
736
 
        Branch.__init__(self, tempfile.mkdtemp(), init=True)
 
1250
        if transport is None:
 
1251
            transport = bzrlib.transport.local.ScratchTransport()
 
1252
            super(ScratchBranch, self).__init__(transport, init=True)
 
1253
        else:
 
1254
            super(ScratchBranch, self).__init__(transport)
 
1255
 
 
1256
        for d in dirs:
 
1257
            self._transport.mkdir(d)
 
1258
            
737
1259
        for f in files:
738
 
            file(os.path.join(self.base, f), 'w').write('content of %s' % f)
739
 
 
740
 
 
741
 
    def __del__(self):
742
 
        """Destroy the test branch, removing the scratch directory."""
743
 
        shutil.rmtree(self.base)
744
 
 
 
1260
            self._transport.put(f, 'content of %s' % f)
 
1261
 
 
1262
 
 
1263
    def clone(self):
 
1264
        """
 
1265
        >>> orig = ScratchBranch(files=["file1", "file2"])
 
1266
        >>> clone = orig.clone()
 
1267
        >>> if os.name != 'nt':
 
1268
        ...   os.path.samefile(orig.base, clone.base)
 
1269
        ... else:
 
1270
        ...   orig.base == clone.base
 
1271
        ...
 
1272
        False
 
1273
        >>> os.path.isfile(pathjoin(clone.base, "file1"))
 
1274
        True
 
1275
        """
 
1276
        from shutil import copytree
 
1277
        from bzrlib.osutils import mkdtemp
 
1278
        base = mkdtemp()
 
1279
        os.rmdir(base)
 
1280
        copytree(self.base, base, symlinks=True)
 
1281
        return ScratchBranch(
 
1282
            transport=bzrlib.transport.local.ScratchTransport(base))
745
1283
    
746
1284
 
747
1285
######################################################################
750
1288
 
751
1289
def is_control_file(filename):
752
1290
    ## FIXME: better check
753
 
    filename = os.path.normpath(filename)
 
1291
    filename = normpath(filename)
754
1292
    while filename != '':
755
1293
        head, tail = os.path.split(filename)
756
1294
        ## mutter('check %r for control file' % ((head, tail), ))
757
1295
        if tail == bzrlib.BZRDIR:
758
1296
            return True
 
1297
        if filename == head:
 
1298
            break
759
1299
        filename = head
760
1300
    return False
761
 
 
762
 
 
763
 
 
764
 
def _gen_revision_id(when):
765
 
    """Return new revision-id."""
766
 
    s = '%s-%s-' % (user_email(), compact_date(when))
767
 
    s += hexlify(rand_bytes(8))
768
 
    return s
769
 
 
770
 
 
771
 
def _gen_file_id(name):
772
 
    """Return new file id.
773
 
 
774
 
    This should probably generate proper UUIDs, but for the moment we
775
 
    cope with just randomness because running uuidgen every time is
776
 
    slow."""
777
 
    assert '/' not in name
778
 
    while name[0] == '.':
779
 
        name = name[1:]
780
 
    s = hexlify(rand_bytes(8))
781
 
    return '-'.join((name, compact_date(time.time()), s))
782
 
 
783