~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Martin Pool
  • Date: 2005-04-28 10:01:44 UTC
  • Revision ID: mbp@sourcefrog.net-20050428100144-e9d4ccfe5fb236df
- new 'bzr ignored' command!

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
 
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
 
from cStringIO import StringIO
 
18
from sets import Set
19
19
 
20
 
from bzrlib.lazy_import import lazy_import
21
 
lazy_import(globals(), """
22
 
from copy import deepcopy
23
 
from unittest import TestSuite
24
 
from warnings import warn
 
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
25
23
 
26
24
import bzrlib
27
 
from bzrlib import (
28
 
        bzrdir,
29
 
        cache_utf8,
30
 
        config as _mod_config,
31
 
        errors,
32
 
        lockdir,
33
 
        lockable_files,
34
 
        osutils,
35
 
        revision as _mod_revision,
36
 
        transport,
37
 
        tree,
38
 
        ui,
39
 
        urlutils,
40
 
        )
41
 
from bzrlib.config import BranchConfig, TreeConfig
42
 
from bzrlib.lockable_files import LockableFiles, TransportLock
43
 
""")
44
 
 
45
 
from bzrlib.decorators import needs_read_lock, needs_write_lock
46
 
from bzrlib.errors import (BzrError, BzrCheckError, DivergedBranches,
47
 
                           HistoryMissing, InvalidRevisionId,
48
 
                           InvalidRevisionNumber, LockError, NoSuchFile,
49
 
                           NoSuchRevision, NoWorkingTree, NotVersionedError,
50
 
                           NotBranchError, UninitializableFormat,
51
 
                           UnlistableStore, UnlistableBranch,
52
 
                           )
53
 
from bzrlib.symbol_versioning import (deprecated_function,
54
 
                                      deprecated_method,
55
 
                                      DEPRECATED_PARAMETER,
56
 
                                      deprecated_passed,
57
 
                                      zero_eight, zero_nine,
58
 
                                      )
59
 
from bzrlib.trace import mutter, note
60
 
 
61
 
 
62
 
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
63
 
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
64
 
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
65
 
 
66
 
 
67
 
# TODO: Maybe include checks for common corruption of newlines, etc?
68
 
 
69
 
# TODO: Some operations like log might retrieve the same revisions
70
 
# repeatedly to calculate deltas.  We could perhaps have a weakref
71
 
# cache in memory to make this faster.  In general anything can be
72
 
# cached in memory between lock and unlock operations. .. nb thats
73
 
# what the transaction identity map provides
 
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
    
74
68
 
75
69
 
76
70
######################################################################
77
71
# branch objects
78
72
 
79
 
class Branch(object):
 
73
class Branch:
80
74
    """Branch holding a history of revisions.
81
75
 
82
 
    base
83
 
        Base directory/url of the branch.
 
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.
84
88
    """
85
 
    # this is really an instance variable - FIXME move it there
86
 
    # - RBC 20060112
87
 
    base = None
88
 
 
89
 
    def __init__(self, *ignored, **ignored_too):
90
 
        raise NotImplementedError('The Branch class is abstract')
91
 
 
92
 
    def break_lock(self):
93
 
        """Break a lock if one is present from another instance.
94
 
 
95
 
        Uses the ui factory to ask for confirmation if the lock may be from
96
 
        an active process.
97
 
 
98
 
        This will probe the repository for its lock as well.
99
 
        """
100
 
        self.control_files.break_lock()
101
 
        self.repository.break_lock()
102
 
        master = self.get_master_branch()
103
 
        if master is not None:
104
 
            master.break_lock()
105
 
 
106
 
    @staticmethod
107
 
    @deprecated_method(zero_eight)
108
 
    def open_downlevel(base):
109
 
        """Open a branch which may be of an old format."""
110
 
        return Branch.open(base, _unsupported=True)
111
 
        
112
 
    @staticmethod
113
 
    def open(base, _unsupported=False):
114
 
        """Open the branch rooted at base.
115
 
 
116
 
        For instance, if the branch is at URL/.bzr/branch,
117
 
        Branch.open(URL) -> a Branch instance.
118
 
        """
119
 
        control = bzrdir.BzrDir.open(base, _unsupported)
120
 
        return control.open_branch(_unsupported)
121
 
 
122
 
    @staticmethod
123
 
    def open_containing(url):
124
 
        """Open an existing branch which contains url.
125
 
        
126
 
        This probes for a branch at url, and searches upwards from there.
127
 
 
128
 
        Basically we keep looking up until we find the control directory or
129
 
        run into the root.  If there isn't one, raises NotBranchError.
130
 
        If there is one and it is either an unrecognised format or an unsupported 
131
 
        format, UnknownFormatError or UnsupportedFormatError are raised.
132
 
        If there is one, it is returned, along with the unused portion of url.
133
 
        """
134
 
        control, relpath = bzrdir.BzrDir.open_containing(url)
135
 
        return control.open_branch(), relpath
136
 
 
137
 
    @staticmethod
138
 
    @deprecated_function(zero_eight)
139
 
    def initialize(base):
140
 
        """Create a new working tree and branch, rooted at 'base' (url)
141
 
 
142
 
        NOTE: This will soon be deprecated in favour of creation
143
 
        through a BzrDir.
144
 
        """
145
 
        return bzrdir.BzrDir.create_standalone_workingtree(base).branch
146
 
 
147
 
    @deprecated_function(zero_eight)
148
 
    def setup_caching(self, cache_root):
149
 
        """Subclasses that care about caching should override this, and set
150
 
        up cached stores located under cache_root.
151
 
        
152
 
        NOTE: This is unused.
153
 
        """
154
 
        pass
155
 
 
156
 
    def get_config(self):
157
 
        return BranchConfig(self)
158
 
 
159
 
    def _get_nick(self):
160
 
        return self.get_config().get_nickname()
161
 
 
162
 
    def _set_nick(self, nick):
163
 
        self.get_config().set_user_option('nickname', nick)
164
 
 
165
 
    nick = property(_get_nick, _set_nick)
166
 
 
167
 
    def is_locked(self):
168
 
        raise NotImplementedError(self.is_locked)
169
 
 
170
 
    def lock_write(self):
171
 
        raise NotImplementedError(self.lock_write)
172
 
 
173
 
    def lock_read(self):
174
 
        raise NotImplementedError(self.lock_read)
175
 
 
176
 
    def unlock(self):
177
 
        raise NotImplementedError(self.unlock)
178
 
 
179
 
    def peek_lock_mode(self):
180
 
        """Return lock mode for the Branch: 'r', 'w' or None"""
181
 
        raise NotImplementedError(self.peek_lock_mode)
182
 
 
183
 
    def get_physical_lock_status(self):
184
 
        raise NotImplementedError(self.get_physical_lock_status)
 
89
    def __init__(self, base, init=False, find_root=True):
 
90
        """Create new branch object at a particular location.
 
91
 
 
92
        base -- Base directory for the branch.
 
93
        
 
94
        init -- If True, create new control files in a previously
 
95
             unversioned directory.  If False, the branch must already
 
96
             be versioned.
 
97
 
 
98
        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
 
185
128
 
186
129
    def abspath(self, name):
187
 
        """Return absolute filename for something in the branch
188
 
        
189
 
        XXX: Robert Collins 20051017 what is this used for? why is it a branch
190
 
        method and not a tree method.
191
 
        """
192
 
        raise NotImplementedError(self.abspath)
193
 
 
194
 
    def bind(self, other):
195
 
        """Bind the local branch the other branch.
196
 
 
197
 
        :param other: The branch to bind to
198
 
        :type other: Branch
199
 
        """
200
 
        raise errors.UpgradeRequired(self.base)
201
 
 
202
 
    @needs_write_lock
203
 
    def fetch(self, from_branch, last_revision=None, pb=None):
204
 
        """Copy revisions from from_branch into this branch.
205
 
 
206
 
        :param from_branch: Where to copy from.
207
 
        :param last_revision: What revision to stop at (None for at the end
208
 
                              of the branch.
209
 
        :param pb: An optional progress bar to use.
210
 
 
211
 
        Returns the copied revision count and the failed revisions in a tuple:
212
 
        (copied, failures).
213
 
        """
214
 
        if self.base == from_branch.base:
215
 
            return (0, [])
216
 
        if pb is None:
217
 
            nested_pb = ui.ui_factory.nested_progress_bar()
218
 
            pb = nested_pb
 
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
 
 
157
        There are two classes of file in the control directory: text
 
158
        and binary.  binary files are untranslated byte streams.  Text
 
159
        control files are stored with Unix newlines and in UTF-8, even
 
160
        if the platform or locale defaults are different.
 
161
        """
 
162
 
 
163
        fn = self.controlfilename(file_or_path)
 
164
 
 
165
        if mode == 'rb' or mode == 'wb':
 
166
            return file(fn, mode)
 
167
        elif mode == 'r' or mode == 'w':
 
168
            # open in binary mode anyhow so there's no newline translation;
 
169
            # codecs uses line buffering by default; don't want that.
 
170
            import codecs
 
171
            return codecs.open(fn, mode + 'b', 'utf-8',
 
172
                               buffering=60000)
219
173
        else:
220
 
            nested_pb = None
221
 
 
222
 
        from_branch.lock_read()
223
 
        try:
224
 
            if last_revision is None:
225
 
                pb.update('get source history')
226
 
                from_history = from_branch.revision_history()
227
 
                if from_history:
228
 
                    last_revision = from_history[-1]
229
 
                else:
230
 
                    # no history in the source branch
231
 
                    last_revision = _mod_revision.NULL_REVISION
232
 
            return self.repository.fetch(from_branch.repository,
233
 
                                         revision_id=last_revision,
234
 
                                         pb=nested_pb)
235
 
        finally:
236
 
            if nested_pb is not None:
237
 
                nested_pb.finished()
238
 
            from_branch.unlock()
239
 
 
240
 
    def get_bound_location(self):
241
 
        """Return the URL of the branch we are bound to.
242
 
 
243
 
        Older format branches cannot bind, please be sure to use a metadir
244
 
        branch.
245
 
        """
246
 
        return None
247
 
    
248
 
    def get_commit_builder(self, parents, config=None, timestamp=None, 
249
 
                           timezone=None, committer=None, revprops=None, 
250
 
                           revision_id=None):
251
 
        """Obtain a CommitBuilder for this branch.
252
 
        
253
 
        :param parents: Revision ids of the parents of the new revision.
254
 
        :param config: Optional configuration to use.
255
 
        :param timestamp: Optional timestamp recorded for commit.
256
 
        :param timezone: Optional timezone for timestamp.
257
 
        :param committer: Optional committer to set for commit.
258
 
        :param revprops: Optional dictionary of revision properties.
259
 
        :param revision_id: Optional revision id.
260
 
        """
261
 
 
262
 
        if config is None:
263
 
            config = self.get_config()
264
 
        
265
 
        return self.repository.get_commit_builder(self, parents, config, 
266
 
            timestamp, timezone, committer, revprops, revision_id)
267
 
 
268
 
    def get_master_branch(self):
269
 
        """Return the branch we are bound to.
270
 
        
271
 
        :return: Either a Branch, or None
272
 
        """
273
 
        return None
274
 
 
275
 
    def get_revision_delta(self, revno):
276
 
        """Return the delta for one revision.
277
 
 
278
 
        The delta is relative to its mainline predecessor, or the
279
 
        empty tree for revision 1.
280
 
        """
281
 
        assert isinstance(revno, int)
282
 
        rh = self.revision_history()
283
 
        if not (1 <= revno <= len(rh)):
284
 
            raise InvalidRevisionNumber(revno)
285
 
        return self.repository.get_revision_delta(rh[revno-1])
286
 
 
287
 
    def get_root_id(self):
288
 
        """Return the id of this branches root"""
289
 
        raise NotImplementedError(self.get_root_id)
290
 
 
291
 
    def print_file(self, file, revision_id):
 
174
            raise BzrError("invalid controlfile mode %r" % mode)
 
175
 
 
176
 
 
177
 
 
178
    def _make_control(self):
 
179
        os.mkdir(self.controlfilename([]))
 
180
        self.controlfile('README', 'w').write(
 
181
            "This is a Bazaar-NG control directory.\n"
 
182
            "Do not change any files in this directory.")
 
183
        self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
 
184
        for d in ('text-store', 'inventory-store', 'revision-store'):
 
185
            os.mkdir(self.controlfilename(d))
 
186
        for f in ('revision-history', 'merged-patches',
 
187
                  'pending-merged-patches', 'branch-name'):
 
188
            self.controlfile(f, 'w').write('')
 
189
        mutter('created control directory in ' + self.base)
 
190
        Inventory().write_xml(self.controlfile('inventory','w'))
 
191
 
 
192
 
 
193
    def _check_format(self):
 
194
        """Check this branch format is supported.
 
195
 
 
196
        The current tool only supports the current unstable format.
 
197
 
 
198
        In the future, we might need different in-memory Branch
 
199
        classes to support downlevel branches.  But not yet.
 
200
        """
 
201
        # This ignores newlines so that we can open branches created
 
202
        # on Windows from Linux and so on.  I think it might be better
 
203
        # to always make all internal files in unix format.
 
204
        fmt = self.controlfile('branch-format', 'r').read()
 
205
        fmt.replace('\r\n', '')
 
206
        if fmt != BZR_BRANCH_FORMAT:
 
207
            bailout('sorry, branch format %r not supported' % fmt,
 
208
                    ['use a different bzr version',
 
209
                     'or remove the .bzr directory and "bzr init" again'])
 
210
 
 
211
 
 
212
    def read_working_inventory(self):
 
213
        """Read the working inventory."""
 
214
        before = time.time()
 
215
        # ElementTree does its own conversion from UTF-8, so open in
 
216
        # binary.
 
217
        inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
 
218
        mutter("loaded inventory of %d items in %f"
 
219
               % (len(inv), time.time() - before))
 
220
        return inv
 
221
 
 
222
 
 
223
    def _write_inventory(self, inv):
 
224
        """Update the working inventory.
 
225
 
 
226
        That is to say, the inventory describing changes underway, that
 
227
        will be committed to the next revision.
 
228
        """
 
229
        ## TODO: factor out to atomicfile?  is rename safe on windows?
 
230
        ## TODO: Maybe some kind of clean/dirty marker on inventory?
 
231
        tmpfname = self.controlfilename('inventory.tmp')
 
232
        tmpf = file(tmpfname, 'wb')
 
233
        inv.write_xml(tmpf)
 
234
        tmpf.close()
 
235
        inv_fname = self.controlfilename('inventory')
 
236
        if sys.platform == 'win32':
 
237
            os.remove(inv_fname)
 
238
        os.rename(tmpfname, inv_fname)
 
239
        mutter('wrote working inventory')
 
240
 
 
241
 
 
242
    inventory = property(read_working_inventory, _write_inventory, None,
 
243
                         """Inventory for the working copy.""")
 
244
 
 
245
 
 
246
    def add(self, files, verbose=False):
 
247
        """Make files versioned.
 
248
 
 
249
        Note that the command line normally calls smart_add instead.
 
250
 
 
251
        This puts the files in the Added state, so that they will be
 
252
        recorded by the next commit.
 
253
 
 
254
        TODO: Perhaps have an option to add the ids even if the files do
 
255
               not (yet) exist.
 
256
 
 
257
        TODO: Perhaps return the ids of the files?  But then again it
 
258
               is easy to retrieve them if they're needed.
 
259
 
 
260
        TODO: Option to specify file id.
 
261
 
 
262
        TODO: Adding a directory should optionally recurse down and
 
263
               add all non-ignored children.  Perhaps do that in a
 
264
               higher-level method.
 
265
 
 
266
        >>> b = ScratchBranch(files=['foo'])
 
267
        >>> 'foo' in b.unknowns()
 
268
        True
 
269
        >>> b.show_status()
 
270
        ?       foo
 
271
        >>> b.add('foo')
 
272
        >>> 'foo' in b.unknowns()
 
273
        False
 
274
        >>> bool(b.inventory.path2id('foo'))
 
275
        True
 
276
        >>> b.show_status()
 
277
        A       foo
 
278
 
 
279
        >>> b.add('foo')
 
280
        Traceback (most recent call last):
 
281
        ...
 
282
        BzrError: ('foo is already versioned', [])
 
283
 
 
284
        >>> b.add(['nothere'])
 
285
        Traceback (most recent call last):
 
286
        BzrError: ('cannot add: not a regular file or directory: nothere', [])
 
287
        """
 
288
 
 
289
        # TODO: Re-adding a file that is removed in the working copy
 
290
        # should probably put it back with the previous ID.
 
291
        if isinstance(files, types.StringTypes):
 
292
            files = [files]
 
293
        
 
294
        inv = self.read_working_inventory()
 
295
        for f in files:
 
296
            if is_control_file(f):
 
297
                bailout("cannot add control file %s" % quotefn(f))
 
298
 
 
299
            fp = splitpath(f)
 
300
 
 
301
            if len(fp) == 0:
 
302
                bailout("cannot add top-level %r" % f)
 
303
                
 
304
            fullpath = os.path.normpath(self.abspath(f))
 
305
 
 
306
            try:
 
307
                kind = file_kind(fullpath)
 
308
            except OSError:
 
309
                # maybe something better?
 
310
                bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
 
311
            
 
312
            if kind != 'file' and kind != 'directory':
 
313
                bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
 
314
 
 
315
            file_id = gen_file_id(f)
 
316
            inv.add_path(f, kind=kind, file_id=file_id)
 
317
 
 
318
            if verbose:
 
319
                show_status('A', kind, quotefn(f))
 
320
                
 
321
            mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
 
322
            
 
323
        self._write_inventory(inv)
 
324
 
 
325
 
 
326
    def print_file(self, file, revno):
292
327
        """Print `file` to stdout."""
293
 
        raise NotImplementedError(self.print_file)
294
 
 
295
 
    def append_revision(self, *revision_ids):
296
 
        raise NotImplementedError(self.append_revision)
297
 
 
298
 
    def set_revision_history(self, rev_history):
299
 
        raise NotImplementedError(self.set_revision_history)
 
328
        tree = self.revision_tree(self.lookup_revision(revno))
 
329
        # use inventory as it was in that revision
 
330
        file_id = tree.inventory.path2id(file)
 
331
        if not file_id:
 
332
            bailout("%r is not present in revision %d" % (file, revno))
 
333
        tree.print_file(file_id)
 
334
        
 
335
 
 
336
    def remove(self, files, verbose=False):
 
337
        """Mark nominated files for removal from the inventory.
 
338
 
 
339
        This does not remove their text.  This does not run on 
 
340
 
 
341
        TODO: Refuse to remove modified files unless --force is given?
 
342
 
 
343
        >>> b = ScratchBranch(files=['foo'])
 
344
        >>> b.add('foo')
 
345
        >>> b.inventory.has_filename('foo')
 
346
        True
 
347
        >>> b.remove('foo')
 
348
        >>> b.working_tree().has_filename('foo')
 
349
        True
 
350
        >>> b.inventory.has_filename('foo')
 
351
        False
 
352
        
 
353
        >>> b = ScratchBranch(files=['foo'])
 
354
        >>> b.add('foo')
 
355
        >>> b.commit('one')
 
356
        >>> b.remove('foo')
 
357
        >>> b.commit('two')
 
358
        >>> b.inventory.has_filename('foo') 
 
359
        False
 
360
        >>> b.basis_tree().has_filename('foo') 
 
361
        False
 
362
        >>> b.working_tree().has_filename('foo') 
 
363
        True
 
364
 
 
365
        TODO: Do something useful with directories.
 
366
 
 
367
        TODO: Should this remove the text or not?  Tough call; not
 
368
        removing may be useful and the user can just use use rm, and
 
369
        is the opposite of add.  Removing it is consistent with most
 
370
        other tools.  Maybe an option.
 
371
        """
 
372
        ## TODO: Normalize names
 
373
        ## TODO: Remove nested loops; better scalability
 
374
 
 
375
        if isinstance(files, types.StringTypes):
 
376
            files = [files]
 
377
        
 
378
        tree = self.working_tree()
 
379
        inv = tree.inventory
 
380
 
 
381
        # do this before any modifications
 
382
        for f in files:
 
383
            fid = inv.path2id(f)
 
384
            if not fid:
 
385
                bailout("cannot remove unversioned file %s" % quotefn(f))
 
386
            mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
 
387
            if verbose:
 
388
                # having remove it, it must be either ignored or unknown
 
389
                if tree.is_ignored(f):
 
390
                    new_status = 'I'
 
391
                else:
 
392
                    new_status = '?'
 
393
                show_status(new_status, inv[fid].kind, quotefn(f))
 
394
            del inv[fid]
 
395
 
 
396
        self._write_inventory(inv)
 
397
 
 
398
 
 
399
    def unknowns(self):
 
400
        """Return all unknown files.
 
401
 
 
402
        These are files in the working directory that are not versioned or
 
403
        control files or ignored.
 
404
        
 
405
        >>> b = ScratchBranch(files=['foo', 'foo~'])
 
406
        >>> list(b.unknowns())
 
407
        ['foo']
 
408
        >>> b.add('foo')
 
409
        >>> list(b.unknowns())
 
410
        []
 
411
        >>> b.remove('foo')
 
412
        >>> list(b.unknowns())
 
413
        ['foo']
 
414
        """
 
415
        return self.working_tree().unknowns()
 
416
 
 
417
 
 
418
    def commit(self, message, timestamp=None, timezone=None,
 
419
               committer=None,
 
420
               verbose=False):
 
421
        """Commit working copy as a new revision.
 
422
        
 
423
        The basic approach is to add all the file texts into the
 
424
        store, then the inventory, then make a new revision pointing
 
425
        to that inventory and store that.
 
426
        
 
427
        This is not quite safe if the working copy changes during the
 
428
        commit; for the moment that is simply not allowed.  A better
 
429
        approach is to make a temporary copy of the files before
 
430
        computing their hashes, and then add those hashes in turn to
 
431
        the inventory.  This should mean at least that there are no
 
432
        broken hash pointers.  There is no way we can get a snapshot
 
433
        of the whole directory at an instant.  This would also have to
 
434
        be robust against files disappearing, moving, etc.  So the
 
435
        whole thing is a bit hard.
 
436
 
 
437
        timestamp -- if not None, seconds-since-epoch for a
 
438
             postdated/predated commit.
 
439
        """
 
440
 
 
441
        ## TODO: Show branch names
 
442
 
 
443
        # TODO: Don't commit if there are no changes, unless forced?
 
444
 
 
445
        # First walk over the working inventory; and both update that
 
446
        # and also build a new revision inventory.  The revision
 
447
        # inventory needs to hold the text-id, sha1 and size of the
 
448
        # actual file versions committed in the revision.  (These are
 
449
        # not present in the working inventory.)  We also need to
 
450
        # detect missing/deleted files, and remove them from the
 
451
        # working inventory.
 
452
 
 
453
        work_inv = self.read_working_inventory()
 
454
        inv = Inventory()
 
455
        basis = self.basis_tree()
 
456
        basis_inv = basis.inventory
 
457
        missing_ids = []
 
458
        for path, entry in work_inv.iter_entries():
 
459
            ## TODO: Cope with files that have gone missing.
 
460
 
 
461
            ## TODO: Check that the file kind has not changed from the previous
 
462
            ## revision of this file (if any).
 
463
 
 
464
            entry = entry.copy()
 
465
 
 
466
            p = self.abspath(path)
 
467
            file_id = entry.file_id
 
468
            mutter('commit prep file %s, id %r ' % (p, file_id))
 
469
 
 
470
            if not os.path.exists(p):
 
471
                mutter("    file is missing, removing from inventory")
 
472
                if verbose:
 
473
                    show_status('D', entry.kind, quotefn(path))
 
474
                missing_ids.append(file_id)
 
475
                continue
 
476
 
 
477
            # TODO: Handle files that have been deleted
 
478
 
 
479
            # TODO: Maybe a special case for empty files?  Seems a
 
480
            # waste to store them many times.
 
481
 
 
482
            inv.add(entry)
 
483
 
 
484
            if basis_inv.has_id(file_id):
 
485
                old_kind = basis_inv[file_id].kind
 
486
                if old_kind != entry.kind:
 
487
                    bailout("entry %r changed kind from %r to %r"
 
488
                            % (file_id, old_kind, entry.kind))
 
489
 
 
490
            if entry.kind == 'directory':
 
491
                if not isdir(p):
 
492
                    bailout("%s is entered as directory but not a directory" % quotefn(p))
 
493
            elif entry.kind == 'file':
 
494
                if not isfile(p):
 
495
                    bailout("%s is entered as file but is not a file" % quotefn(p))
 
496
 
 
497
                content = file(p, 'rb').read()
 
498
 
 
499
                entry.text_sha1 = sha_string(content)
 
500
                entry.text_size = len(content)
 
501
 
 
502
                old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
 
503
                if (old_ie
 
504
                    and (old_ie.text_size == entry.text_size)
 
505
                    and (old_ie.text_sha1 == entry.text_sha1)):
 
506
                    ## assert content == basis.get_file(file_id).read()
 
507
                    entry.text_id = basis_inv[file_id].text_id
 
508
                    mutter('    unchanged from previous text_id {%s}' %
 
509
                           entry.text_id)
 
510
                    
 
511
                else:
 
512
                    entry.text_id = gen_file_id(entry.name)
 
513
                    self.text_store.add(content, entry.text_id)
 
514
                    mutter('    stored with text_id {%s}' % entry.text_id)
 
515
                    if verbose:
 
516
                        if not old_ie:
 
517
                            state = 'A'
 
518
                        elif (old_ie.name == entry.name
 
519
                              and old_ie.parent_id == entry.parent_id):
 
520
                            state = 'M'
 
521
                        else:
 
522
                            state = 'R'
 
523
 
 
524
                        show_status(state, entry.kind, quotefn(path))
 
525
 
 
526
        for file_id in missing_ids:
 
527
            # have to do this later so we don't mess up the iterator.
 
528
            # since parents may be removed before their children we
 
529
            # have to test.
 
530
 
 
531
            # FIXME: There's probably a better way to do this; perhaps
 
532
            # the workingtree should know how to filter itself.
 
533
            if work_inv.has_id(file_id):
 
534
                del work_inv[file_id]
 
535
 
 
536
 
 
537
        inv_id = rev_id = _gen_revision_id(time.time())
 
538
        
 
539
        inv_tmp = tempfile.TemporaryFile()
 
540
        inv.write_xml(inv_tmp)
 
541
        inv_tmp.seek(0)
 
542
        self.inventory_store.add(inv_tmp, inv_id)
 
543
        mutter('new inventory_id is {%s}' % inv_id)
 
544
 
 
545
        self._write_inventory(work_inv)
 
546
 
 
547
        if timestamp == None:
 
548
            timestamp = time.time()
 
549
 
 
550
        if committer == None:
 
551
            committer = username()
 
552
 
 
553
        if timezone == None:
 
554
            timezone = local_time_offset()
 
555
 
 
556
        mutter("building commit log message")
 
557
        rev = Revision(timestamp=timestamp,
 
558
                       timezone=timezone,
 
559
                       committer=committer,
 
560
                       precursor = self.last_patch(),
 
561
                       message = message,
 
562
                       inventory_id=inv_id,
 
563
                       revision_id=rev_id)
 
564
 
 
565
        rev_tmp = tempfile.TemporaryFile()
 
566
        rev.write_xml(rev_tmp)
 
567
        rev_tmp.seek(0)
 
568
        self.revision_store.add(rev_tmp, rev_id)
 
569
        mutter("new revision_id is {%s}" % rev_id)
 
570
        
 
571
        ## XXX: Everything up to here can simply be orphaned if we abort
 
572
        ## the commit; it will leave junk files behind but that doesn't
 
573
        ## matter.
 
574
 
 
575
        ## TODO: Read back the just-generated changeset, and make sure it
 
576
        ## applies and recreates the right state.
 
577
 
 
578
        ## TODO: Also calculate and store the inventory SHA1
 
579
        mutter("committing patch r%d" % (self.revno() + 1))
 
580
 
 
581
 
 
582
        self.append_revision(rev_id)
 
583
        
 
584
        if verbose:
 
585
            note("commited r%d" % self.revno())
 
586
 
 
587
 
 
588
    def append_revision(self, revision_id):
 
589
        mutter("add {%s} to revision-history" % revision_id)
 
590
        rev_history = self.revision_history()
 
591
 
 
592
        tmprhname = self.controlfilename('revision-history.tmp')
 
593
        rhname = self.controlfilename('revision-history')
 
594
        
 
595
        f = file(tmprhname, 'wt')
 
596
        rev_history.append(revision_id)
 
597
        f.write('\n'.join(rev_history))
 
598
        f.write('\n')
 
599
        f.close()
 
600
 
 
601
        if sys.platform == 'win32':
 
602
            os.remove(rhname)
 
603
        os.rename(tmprhname, rhname)
 
604
        
 
605
 
 
606
 
 
607
    def get_revision(self, revision_id):
 
608
        """Return the Revision object for a named revision"""
 
609
        r = Revision.read_xml(self.revision_store[revision_id])
 
610
        assert r.revision_id == revision_id
 
611
        return r
 
612
 
 
613
 
 
614
    def get_inventory(self, inventory_id):
 
615
        """Get Inventory object by hash.
 
616
 
 
617
        TODO: Perhaps for this and similar methods, take a revision
 
618
               parameter which can be either an integer revno or a
 
619
               string hash."""
 
620
        i = Inventory.read_xml(self.inventory_store[inventory_id])
 
621
        return i
 
622
 
 
623
 
 
624
    def get_revision_inventory(self, revision_id):
 
625
        """Return inventory of a past revision."""
 
626
        if revision_id == None:
 
627
            return Inventory()
 
628
        else:
 
629
            return self.get_inventory(self.get_revision(revision_id).inventory_id)
 
630
 
300
631
 
301
632
    def revision_history(self):
302
 
        """Return sequence of revision hashes on to this branch."""
303
 
        raise NotImplementedError(self.revision_history)
 
633
        """Return sequence of revision hashes on to this branch.
 
634
 
 
635
        >>> ScratchBranch().revision_history()
 
636
        []
 
637
        """
 
638
        return [chomp(l) for l in self.controlfile('revision-history', 'r').readlines()]
 
639
 
304
640
 
305
641
    def revno(self):
306
642
        """Return current revision number for this branch.
307
643
 
308
644
        That is equivalent to the number of revisions committed to
309
645
        this branch.
 
646
 
 
647
        >>> b = ScratchBranch()
 
648
        >>> b.revno()
 
649
        0
 
650
        >>> b.commit('no foo')
 
651
        >>> b.revno()
 
652
        1
310
653
        """
311
654
        return len(self.revision_history())
312
655
 
313
 
    def unbind(self):
314
 
        """Older format branches cannot bind or unbind."""
315
 
        raise errors.UpgradeRequired(self.base)
316
 
 
317
 
    def last_revision(self):
318
 
        """Return last revision id, or None"""
 
656
 
 
657
    def last_patch(self):
 
658
        """Return last patch hash, or None if no history.
 
659
 
 
660
        >>> ScratchBranch().last_patch() == None
 
661
        True
 
662
        """
319
663
        ph = self.revision_history()
320
664
        if ph:
321
665
            return ph[-1]
322
666
        else:
323
667
            return None
324
 
 
325
 
    def missing_revisions(self, other, stop_revision=None):
326
 
        """Return a list of new revisions that would perfectly fit.
327
668
        
328
 
        If self and other have not diverged, return a list of the revisions
329
 
        present in other, but missing from self.
330
 
        """
331
 
        self_history = self.revision_history()
332
 
        self_len = len(self_history)
333
 
        other_history = other.revision_history()
334
 
        other_len = len(other_history)
335
 
        common_index = min(self_len, other_len) -1
336
 
        if common_index >= 0 and \
337
 
            self_history[common_index] != other_history[common_index]:
338
 
            raise DivergedBranches(self, other)
339
 
 
340
 
        if stop_revision is None:
341
 
            stop_revision = other_len
342
 
        else:
343
 
            assert isinstance(stop_revision, int)
344
 
            if stop_revision > other_len:
345
 
                raise errors.NoSuchRevision(self, stop_revision)
346
 
        return other_history[self_len:stop_revision]
347
 
 
348
 
    def update_revisions(self, other, stop_revision=None):
349
 
        """Pull in new perfect-fit revisions.
350
 
 
351
 
        :param other: Another Branch to pull from
352
 
        :param stop_revision: Updated until the given revision
353
 
        :return: None
354
 
        """
355
 
        raise NotImplementedError(self.update_revisions)
356
 
 
357
 
    def revision_id_to_revno(self, revision_id):
358
 
        """Given a revision id, return its revno"""
359
 
        if revision_id is None:
360
 
            return 0
361
 
        history = self.revision_history()
362
 
        try:
363
 
            return history.index(revision_id) + 1
364
 
        except ValueError:
365
 
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
366
 
 
367
 
    def get_rev_id(self, revno, history=None):
368
 
        """Find the revision id of the specified revno."""
 
669
 
 
670
    def lookup_revision(self, revno):
 
671
        """Return revision hash for revision number."""
369
672
        if revno == 0:
370
673
            return None
371
 
        if history is None:
372
 
            history = self.revision_history()
373
 
        if revno <= 0 or revno > len(history):
374
 
            raise bzrlib.errors.NoSuchRevision(self, revno)
375
 
        return history[revno - 1]
376
 
 
377
 
    def pull(self, source, overwrite=False, stop_revision=None):
378
 
        raise NotImplementedError(self.pull)
 
674
 
 
675
        try:
 
676
            # list is 0-based; revisions are 1-based
 
677
            return self.revision_history()[revno-1]
 
678
        except IndexError:
 
679
            raise BzrError("no such revision %s" % revno)
 
680
 
 
681
 
 
682
    def revision_tree(self, revision_id):
 
683
        """Return Tree for a revision on this branch.
 
684
 
 
685
        `revision_id` may be None for the null revision, in which case
 
686
        an `EmptyTree` is returned."""
 
687
 
 
688
        if revision_id == None:
 
689
            return EmptyTree()
 
690
        else:
 
691
            inv = self.get_revision_inventory(revision_id)
 
692
            return RevisionTree(self.text_store, inv)
 
693
 
 
694
 
 
695
    def working_tree(self):
 
696
        """Return a `Tree` for the working copy."""
 
697
        return WorkingTree(self.base, self.read_working_inventory())
 
698
 
379
699
 
380
700
    def basis_tree(self):
381
 
        """Return `Tree` object for last revision."""
382
 
        return self.repository.revision_tree(self.last_revision())
 
701
        """Return `Tree` object for last revision.
 
702
 
 
703
        If there are no revisions yet, return an `EmptyTree`.
 
704
 
 
705
        >>> b = ScratchBranch(files=['foo'])
 
706
        >>> b.basis_tree().has_filename('foo')
 
707
        False
 
708
        >>> b.working_tree().has_filename('foo')
 
709
        True
 
710
        >>> b.add('foo')
 
711
        >>> b.commit('add foo')
 
712
        >>> b.basis_tree().has_filename('foo')
 
713
        True
 
714
        """
 
715
        r = self.last_patch()
 
716
        if r == None:
 
717
            return EmptyTree()
 
718
        else:
 
719
            return RevisionTree(self.text_store, self.get_revision_inventory(r))
 
720
 
 
721
 
 
722
 
 
723
    def write_log(self, show_timezone='original', verbose=False):
 
724
        """Write out human-readable log of commits to this branch
 
725
 
 
726
        utc -- If true, show dates in universal time, not local time."""
 
727
        ## TODO: Option to choose either original, utc or local timezone
 
728
        revno = 1
 
729
        precursor = None
 
730
        for p in self.revision_history():
 
731
            print '-' * 40
 
732
            print 'revno:', revno
 
733
            ## TODO: Show hash if --id is given.
 
734
            ##print 'revision-hash:', p
 
735
            rev = self.get_revision(p)
 
736
            print 'committer:', rev.committer
 
737
            print 'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
 
738
                                                 show_timezone))
 
739
 
 
740
            ## opportunistic consistency check, same as check_patch_chaining
 
741
            if rev.precursor != precursor:
 
742
                bailout("mismatched precursor!")
 
743
 
 
744
            print 'message:'
 
745
            if not rev.message:
 
746
                print '  (no message)'
 
747
            else:
 
748
                for l in rev.message.split('\n'):
 
749
                    print '  ' + l
 
750
 
 
751
            if verbose == True and precursor != None:
 
752
                print 'changed files:'
 
753
                tree = self.revision_tree(p)
 
754
                prevtree = self.revision_tree(precursor)
 
755
                
 
756
                for file_state, fid, old_name, new_name, kind in \
 
757
                                        diff_trees(prevtree, tree, ):
 
758
                    if file_state == 'A' or file_state == 'M':
 
759
                        show_status(file_state, kind, new_name)
 
760
                    elif file_state == 'D':
 
761
                        show_status(file_state, kind, old_name)
 
762
                    elif file_state == 'R':
 
763
                        show_status(file_state, kind,
 
764
                            old_name + ' => ' + new_name)
 
765
                
 
766
            revno += 1
 
767
            precursor = p
 
768
 
383
769
 
384
770
    def rename_one(self, from_rel, to_rel):
385
771
        """Rename one file.
386
772
 
387
773
        This can change the directory or the filename or both.
388
 
        """
389
 
        raise NotImplementedError(self.rename_one)
 
774
         """
 
775
        tree = self.working_tree()
 
776
        inv = tree.inventory
 
777
        if not tree.has_filename(from_rel):
 
778
            bailout("can't rename: old working file %r does not exist" % from_rel)
 
779
        if tree.has_filename(to_rel):
 
780
            bailout("can't rename: new working file %r already exists" % to_rel)
 
781
            
 
782
        file_id = inv.path2id(from_rel)
 
783
        if file_id == None:
 
784
            bailout("can't rename: old name %r is not versioned" % from_rel)
 
785
 
 
786
        if inv.path2id(to_rel):
 
787
            bailout("can't rename: new name %r is already versioned" % to_rel)
 
788
 
 
789
        to_dir, to_tail = os.path.split(to_rel)
 
790
        to_dir_id = inv.path2id(to_dir)
 
791
        if to_dir_id == None and to_dir != '':
 
792
            bailout("can't determine destination directory id for %r" % to_dir)
 
793
 
 
794
        mutter("rename_one:")
 
795
        mutter("  file_id    {%s}" % file_id)
 
796
        mutter("  from_rel   %r" % from_rel)
 
797
        mutter("  to_rel     %r" % to_rel)
 
798
        mutter("  to_dir     %r" % to_dir)
 
799
        mutter("  to_dir_id  {%s}" % to_dir_id)
 
800
            
 
801
        inv.rename(file_id, to_dir_id, to_tail)
 
802
 
 
803
        print "%s => %s" % (from_rel, to_rel)
 
804
        
 
805
        from_abs = self.abspath(from_rel)
 
806
        to_abs = self.abspath(to_rel)
 
807
        try:
 
808
            os.rename(from_abs, to_abs)
 
809
        except OSError, e:
 
810
            bailout("failed to rename %r to %r: %s"
 
811
                    % (from_abs, to_abs, e[1]),
 
812
                    ["rename rolled back"])
 
813
 
 
814
        self._write_inventory(inv)
 
815
            
 
816
 
390
817
 
391
818
    def move(self, from_paths, to_name):
392
819
        """Rename files.
398
825
 
399
826
        Note that to_name is only the last component of the new name;
400
827
        this doesn't change the directory.
401
 
 
402
 
        This returns a list of (from_path, to_path) pairs for each
403
 
        entry that is moved.
404
 
        """
405
 
        raise NotImplementedError(self.move)
406
 
 
407
 
    def get_parent(self):
408
 
        """Return the parent location of the branch.
409
 
 
410
 
        This is the default location for push/pull/missing.  The usual
411
 
        pattern is that the user can override it by specifying a
412
 
        location.
413
 
        """
414
 
        raise NotImplementedError(self.get_parent)
415
 
 
416
 
    def get_submit_branch(self):
417
 
        """Return the submit location of the branch.
418
 
 
419
 
        This is the default location for bundle.  The usual
420
 
        pattern is that the user can override it by specifying a
421
 
        location.
422
 
        """
423
 
        return self.get_config().get_user_option('submit_branch')
424
 
 
425
 
    def set_submit_branch(self, location):
426
 
        """Return the submit location of the branch.
427
 
 
428
 
        This is the default location for bundle.  The usual
429
 
        pattern is that the user can override it by specifying a
430
 
        location.
431
 
        """
432
 
        self.get_config().set_user_option('submit_branch', location)
433
 
 
434
 
    def get_push_location(self):
435
 
        """Return the None or the location to push this branch to."""
436
 
        raise NotImplementedError(self.get_push_location)
437
 
 
438
 
    def set_push_location(self, location):
439
 
        """Set a new push location for this branch."""
440
 
        raise NotImplementedError(self.set_push_location)
441
 
 
442
 
    def set_parent(self, url):
443
 
        raise NotImplementedError(self.set_parent)
444
 
 
445
 
    @needs_write_lock
446
 
    def update(self):
447
 
        """Synchronise this branch with the master branch if any. 
448
 
 
449
 
        :return: None or the last_revision pivoted out during the update.
450
 
        """
451
 
        return None
452
 
 
453
 
    def check_revno(self, revno):
454
 
        """\
455
 
        Check whether a revno corresponds to any revision.
456
 
        Zero (the NULL revision) is considered valid.
457
 
        """
458
 
        if revno != 0:
459
 
            self.check_real_revno(revno)
 
828
        """
 
829
        ## TODO: Option to move IDs only
 
830
        assert not isinstance(from_paths, basestring)
 
831
        tree = self.working_tree()
 
832
        inv = tree.inventory
 
833
        to_abs = self.abspath(to_name)
 
834
        if not isdir(to_abs):
 
835
            bailout("destination %r is not a directory" % to_abs)
 
836
        if not tree.has_filename(to_name):
 
837
            bailout("destination %r not in working directory" % to_abs)
 
838
        to_dir_id = inv.path2id(to_name)
 
839
        if to_dir_id == None and to_name != '':
 
840
            bailout("destination %r is not a versioned directory" % to_name)
 
841
        to_dir_ie = inv[to_dir_id]
 
842
        if to_dir_ie.kind not in ('directory', 'root_directory'):
 
843
            bailout("destination %r is not a directory" % to_abs)
 
844
 
 
845
        to_idpath = Set(inv.get_idpath(to_dir_id))
 
846
 
 
847
        for f in from_paths:
 
848
            if not tree.has_filename(f):
 
849
                bailout("%r does not exist in working tree" % f)
 
850
            f_id = inv.path2id(f)
 
851
            if f_id == None:
 
852
                bailout("%r is not versioned" % f)
 
853
            name_tail = splitpath(f)[-1]
 
854
            dest_path = appendpath(to_name, name_tail)
 
855
            if tree.has_filename(dest_path):
 
856
                bailout("destination %r already exists" % dest_path)
 
857
            if f_id in to_idpath:
 
858
                bailout("can't move %r to a subdirectory of itself" % f)
 
859
 
 
860
        # OK, so there's a race here, it's possible that someone will
 
861
        # create a file in this interval and then the rename might be
 
862
        # left half-done.  But we should have caught most problems.
 
863
 
 
864
        for f in from_paths:
 
865
            name_tail = splitpath(f)[-1]
 
866
            dest_path = appendpath(to_name, name_tail)
 
867
            print "%s => %s" % (f, dest_path)
 
868
            inv.rename(inv.path2id(f), to_dir_id, name_tail)
 
869
            try:
 
870
                os.rename(self.abspath(f), self.abspath(dest_path))
 
871
            except OSError, e:
 
872
                bailout("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
 
873
                        ["rename rolled back"])
 
874
 
 
875
        self._write_inventory(inv)
 
876
 
 
877
 
 
878
 
 
879
    def show_status(self, show_all=False):
 
880
        """Display single-line status for non-ignored working files.
 
881
 
 
882
        The list is show sorted in order by file name.
 
883
 
 
884
        >>> b = ScratchBranch(files=['foo', 'foo~'])
 
885
        >>> b.show_status()
 
886
        ?       foo
 
887
        >>> b.add('foo')
 
888
        >>> b.show_status()
 
889
        A       foo
 
890
        >>> b.commit("add foo")
 
891
        >>> b.show_status()
 
892
        >>> os.unlink(b.abspath('foo'))
 
893
        >>> b.show_status()
 
894
        D       foo
 
895
        
 
896
        TODO: Get state for single files.
 
897
        """
 
898
 
 
899
        # We have to build everything into a list first so that it can
 
900
        # sorted by name, incorporating all the different sources.
 
901
 
 
902
        # FIXME: Rather than getting things in random order and then sorting,
 
903
        # just step through in order.
 
904
 
 
905
        # Interesting case: the old ID for a file has been removed,
 
906
        # but a new file has been created under that name.
 
907
 
 
908
        old = self.basis_tree()
 
909
        new = self.working_tree()
 
910
 
 
911
        for fs, fid, oldname, newname, kind in diff_trees(old, new):
 
912
            if fs == 'R':
 
913
                show_status(fs, kind,
 
914
                            oldname + ' => ' + newname)
 
915
            elif fs == 'A' or fs == 'M':
 
916
                show_status(fs, kind, newname)
 
917
            elif fs == 'D':
 
918
                show_status(fs, kind, oldname)
 
919
            elif fs == '.':
 
920
                if show_all:
 
921
                    show_status(fs, kind, newname)
 
922
            elif fs == 'I':
 
923
                if show_all:
 
924
                    show_status(fs, kind, newname)
 
925
            elif fs == '?':
 
926
                show_status(fs, kind, newname)
 
927
            else:
 
928
                bailout("weird file state %r" % ((fs, fid),))
 
929
                
 
930
 
 
931
 
 
932
class ScratchBranch(Branch):
 
933
    """Special test class: a branch that cleans up after itself.
 
934
 
 
935
    >>> b = ScratchBranch()
 
936
    >>> isdir(b.base)
 
937
    True
 
938
    >>> bd = b.base
 
939
    >>> del b
 
940
    >>> isdir(bd)
 
941
    False
 
942
    """
 
943
    def __init__(self, files=[], dirs=[]):
 
944
        """Make a test branch.
 
945
 
 
946
        This creates a temporary directory and runs init-tree in it.
 
947
 
 
948
        If any files are listed, they are created in the working copy.
 
949
        """
 
950
        Branch.__init__(self, tempfile.mkdtemp(), init=True)
 
951
        for d in dirs:
 
952
            os.mkdir(self.abspath(d))
460
953
            
461
 
    def check_real_revno(self, revno):
462
 
        """\
463
 
        Check whether a revno corresponds to a real revision.
464
 
        Zero (the NULL revision) is considered invalid
465
 
        """
466
 
        if revno < 1 or revno > self.revno():
467
 
            raise InvalidRevisionNumber(revno)
468
 
 
469
 
    @needs_read_lock
470
 
    def clone(self, *args, **kwargs):
471
 
        """Clone this branch into to_bzrdir preserving all semantic values.
472
 
        
473
 
        revision_id: if not None, the revision history in the new branch will
474
 
                     be truncated to end with revision_id.
475
 
        """
476
 
        # for API compatibility, until 0.8 releases we provide the old api:
477
 
        # def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
478
 
        # after 0.8 releases, the *args and **kwargs should be changed:
479
 
        # def clone(self, to_bzrdir, revision_id=None):
480
 
        if (kwargs.get('to_location', None) or
481
 
            kwargs.get('revision', None) or
482
 
            kwargs.get('basis_branch', None) or
483
 
            (len(args) and isinstance(args[0], basestring))):
484
 
            # backwards compatibility api:
485
 
            warn("Branch.clone() has been deprecated for BzrDir.clone() from"
486
 
                 " bzrlib 0.8.", DeprecationWarning, stacklevel=3)
487
 
            # get basis_branch
488
 
            if len(args) > 2:
489
 
                basis_branch = args[2]
490
 
            else:
491
 
                basis_branch = kwargs.get('basis_branch', None)
492
 
            if basis_branch:
493
 
                basis = basis_branch.bzrdir
494
 
            else:
495
 
                basis = None
496
 
            # get revision
497
 
            if len(args) > 1:
498
 
                revision_id = args[1]
499
 
            else:
500
 
                revision_id = kwargs.get('revision', None)
501
 
            # get location
502
 
            if len(args):
503
 
                url = args[0]
504
 
            else:
505
 
                # no default to raise if not provided.
506
 
                url = kwargs.get('to_location')
507
 
            return self.bzrdir.clone(url,
508
 
                                     revision_id=revision_id,
509
 
                                     basis=basis).open_branch()
510
 
        # new cleaner api.
511
 
        # generate args by hand 
512
 
        if len(args) > 1:
513
 
            revision_id = args[1]
514
 
        else:
515
 
            revision_id = kwargs.get('revision_id', None)
516
 
        if len(args):
517
 
            to_bzrdir = args[0]
518
 
        else:
519
 
            # no default to raise if not provided.
520
 
            to_bzrdir = kwargs.get('to_bzrdir')
521
 
        result = self._format.initialize(to_bzrdir)
522
 
        self.copy_content_into(result, revision_id=revision_id)
523
 
        return  result
524
 
 
525
 
    @needs_read_lock
526
 
    def sprout(self, to_bzrdir, revision_id=None):
527
 
        """Create a new line of development from the branch, into to_bzrdir.
528
 
        
529
 
        revision_id: if not None, the revision history in the new branch will
530
 
                     be truncated to end with revision_id.
531
 
        """
532
 
        result = self._format.initialize(to_bzrdir)
533
 
        self.copy_content_into(result, revision_id=revision_id)
534
 
        result.set_parent(self.bzrdir.root_transport.base)
535
 
        return result
536
 
 
537
 
    @needs_read_lock
538
 
    def copy_content_into(self, destination, revision_id=None):
539
 
        """Copy the content of self into destination.
540
 
 
541
 
        revision_id: if not None, the revision history in the new branch will
542
 
                     be truncated to end with revision_id.
543
 
        """
544
 
        new_history = self.revision_history()
545
 
        if revision_id is not None:
546
 
            try:
547
 
                new_history = new_history[:new_history.index(revision_id) + 1]
548
 
            except ValueError:
549
 
                rev = self.repository.get_revision(revision_id)
550
 
                new_history = rev.get_history(self.repository)[1:]
551
 
        destination.set_revision_history(new_history)
552
 
        try:
553
 
            parent = self.get_parent()
554
 
        except errors.InaccessibleParent, e:
555
 
            mutter('parent was not accessible to copy: %s', e)
556
 
        else:
557
 
            if parent:
558
 
                destination.set_parent(parent)
559
 
 
560
 
    @needs_read_lock
561
 
    def check(self):
562
 
        """Check consistency of the branch.
563
 
 
564
 
        In particular this checks that revisions given in the revision-history
565
 
        do actually match up in the revision graph, and that they're all 
566
 
        present in the repository.
567
 
        
568
 
        Callers will typically also want to check the repository.
569
 
 
570
 
        :return: A BranchCheckResult.
571
 
        """
572
 
        mainline_parent_id = None
573
 
        for revision_id in self.revision_history():
574
 
            try:
575
 
                revision = self.repository.get_revision(revision_id)
576
 
            except errors.NoSuchRevision, e:
577
 
                raise errors.BzrCheckError("mainline revision {%s} not in repository"
578
 
                            % revision_id)
579
 
            # In general the first entry on the revision history has no parents.
580
 
            # But it's not illegal for it to have parents listed; this can happen
581
 
            # in imports from Arch when the parents weren't reachable.
582
 
            if mainline_parent_id is not None:
583
 
                if mainline_parent_id not in revision.parent_ids:
584
 
                    raise errors.BzrCheckError("previous revision {%s} not listed among "
585
 
                                        "parents of {%s}"
586
 
                                        % (mainline_parent_id, revision_id))
587
 
            mainline_parent_id = revision_id
588
 
        return BranchCheckResult(self)
589
 
 
590
 
    def _get_checkout_format(self):
591
 
        """Return the most suitable metadir for a checkout of this branch.
592
 
        Weaves are used if this branch's repostory uses weaves.
593
 
        """
594
 
        if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
595
 
            from bzrlib import repository
596
 
            format = bzrdir.BzrDirMetaFormat1()
597
 
            format.repository_format = repository.RepositoryFormat7()
598
 
        else:
599
 
            format = self.repository.bzrdir.cloning_metadir()
600
 
        return format
601
 
 
602
 
    def create_checkout(self, to_location, revision_id=None, 
603
 
                        lightweight=False):
604
 
        """Create a checkout of a branch.
605
 
        
606
 
        :param to_location: The url to produce the checkout at
607
 
        :param revision_id: The revision to check out
608
 
        :param lightweight: If True, produce a lightweight checkout, otherwise,
609
 
        produce a bound branch (heavyweight checkout)
610
 
        :return: The tree of the created checkout
611
 
        """
612
 
        t = transport.get_transport(to_location)
613
 
        try:
614
 
            t.mkdir('.')
615
 
        except errors.FileExists:
616
 
            pass
617
 
        if lightweight:
618
 
            checkout = bzrdir.BzrDirMetaFormat1().initialize_on_transport(t)
619
 
            BranchReferenceFormat().initialize(checkout, self)
620
 
        else:
621
 
            format = self._get_checkout_format()
622
 
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
623
 
                to_location, force_new_tree=False, format=format)
624
 
            checkout = checkout_branch.bzrdir
625
 
            checkout_branch.bind(self)
626
 
            # pull up to the specified revision_id to set the initial 
627
 
            # branch tip correctly, and seed it with history.
628
 
            checkout_branch.pull(self, stop_revision=revision_id)
629
 
        return checkout.create_workingtree(revision_id)
630
 
 
631
 
 
632
 
class BranchFormat(object):
633
 
    """An encapsulation of the initialization and open routines for a format.
634
 
 
635
 
    Formats provide three things:
636
 
     * An initialization routine,
637
 
     * a format string,
638
 
     * an open routine.
639
 
 
640
 
    Formats are placed in an dict by their format string for reference 
641
 
    during branch opening. Its not required that these be instances, they
642
 
    can be classes themselves with class methods - it simply depends on 
643
 
    whether state is needed for a given format or not.
644
 
 
645
 
    Once a format is deprecated, just deprecate the initialize and open
646
 
    methods on the format class. Do not deprecate the object, as the 
647
 
    object will be created every time regardless.
648
 
    """
649
 
 
650
 
    _default_format = None
651
 
    """The default format used for new branches."""
652
 
 
653
 
    _formats = {}
654
 
    """The known formats."""
655
 
 
656
 
    @classmethod
657
 
    def find_format(klass, a_bzrdir):
658
 
        """Return the format for the branch object in a_bzrdir."""
659
 
        try:
660
 
            transport = a_bzrdir.get_branch_transport(None)
661
 
            format_string = transport.get("format").read()
662
 
            return klass._formats[format_string]
663
 
        except NoSuchFile:
664
 
            raise NotBranchError(path=transport.base)
665
 
        except KeyError:
666
 
            raise errors.UnknownFormatError(format=format_string)
667
 
 
668
 
    @classmethod
669
 
    def get_default_format(klass):
670
 
        """Return the current default format."""
671
 
        return klass._default_format
672
 
 
673
 
    def get_format_string(self):
674
 
        """Return the ASCII format string that identifies this format."""
675
 
        raise NotImplementedError(self.get_format_string)
676
 
 
677
 
    def get_format_description(self):
678
 
        """Return the short format description for this format."""
679
 
        raise NotImplementedError(self.get_format_string)
680
 
 
681
 
    def initialize(self, a_bzrdir):
682
 
        """Create a branch of this format in a_bzrdir."""
683
 
        raise NotImplementedError(self.initialize)
684
 
 
685
 
    def is_supported(self):
686
 
        """Is this format supported?
687
 
 
688
 
        Supported formats can be initialized and opened.
689
 
        Unsupported formats may not support initialization or committing or 
690
 
        some other features depending on the reason for not being supported.
691
 
        """
692
 
        return True
693
 
 
694
 
    def open(self, a_bzrdir, _found=False):
695
 
        """Return the branch object for a_bzrdir
696
 
 
697
 
        _found is a private parameter, do not use it. It is used to indicate
698
 
               if format probing has already be done.
699
 
        """
700
 
        raise NotImplementedError(self.open)
701
 
 
702
 
    @classmethod
703
 
    def register_format(klass, format):
704
 
        klass._formats[format.get_format_string()] = format
705
 
 
706
 
    @classmethod
707
 
    def set_default_format(klass, format):
708
 
        klass._default_format = format
709
 
 
710
 
    @classmethod
711
 
    def unregister_format(klass, format):
712
 
        assert klass._formats[format.get_format_string()] is format
713
 
        del klass._formats[format.get_format_string()]
714
 
 
715
 
    def __str__(self):
716
 
        return self.get_format_string().rstrip()
717
 
 
718
 
 
719
 
class BzrBranchFormat4(BranchFormat):
720
 
    """Bzr branch format 4.
721
 
 
722
 
    This format has:
723
 
     - a revision-history file.
724
 
     - a branch-lock lock file [ to be shared with the bzrdir ]
725
 
    """
726
 
 
727
 
    def get_format_description(self):
728
 
        """See BranchFormat.get_format_description()."""
729
 
        return "Branch format 4"
730
 
 
731
 
    def initialize(self, a_bzrdir):
732
 
        """Create a branch of this format in a_bzrdir."""
733
 
        mutter('creating branch in %s', a_bzrdir.transport.base)
734
 
        branch_transport = a_bzrdir.get_branch_transport(self)
735
 
        utf8_files = [('revision-history', ''),
736
 
                      ('branch-name', ''),
737
 
                      ]
738
 
        control_files = lockable_files.LockableFiles(branch_transport,
739
 
                             'branch-lock', lockable_files.TransportLock)
740
 
        control_files.create_lock()
741
 
        control_files.lock_write()
742
 
        try:
743
 
            for file, content in utf8_files:
744
 
                control_files.put_utf8(file, content)
745
 
        finally:
746
 
            control_files.unlock()
747
 
        return self.open(a_bzrdir, _found=True)
748
 
 
749
 
    def __init__(self):
750
 
        super(BzrBranchFormat4, self).__init__()
751
 
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
752
 
 
753
 
    def open(self, a_bzrdir, _found=False):
754
 
        """Return the branch object for a_bzrdir
755
 
 
756
 
        _found is a private parameter, do not use it. It is used to indicate
757
 
               if format probing has already be done.
758
 
        """
759
 
        if not _found:
760
 
            # we are being called directly and must probe.
761
 
            raise NotImplementedError
762
 
        return BzrBranch(_format=self,
763
 
                         _control_files=a_bzrdir._control_files,
764
 
                         a_bzrdir=a_bzrdir,
765
 
                         _repository=a_bzrdir.open_repository())
766
 
 
767
 
    def __str__(self):
768
 
        return "Bazaar-NG branch format 4"
769
 
 
770
 
 
771
 
class BzrBranchFormat5(BranchFormat):
772
 
    """Bzr branch format 5.
773
 
 
774
 
    This format has:
775
 
     - a revision-history file.
776
 
     - a format string
777
 
     - a lock dir guarding the branch itself
778
 
     - all of this stored in a branch/ subdirectory
779
 
     - works with shared repositories.
780
 
 
781
 
    This format is new in bzr 0.8.
782
 
    """
783
 
 
784
 
    def get_format_string(self):
785
 
        """See BranchFormat.get_format_string()."""
786
 
        return "Bazaar-NG branch format 5\n"
787
 
 
788
 
    def get_format_description(self):
789
 
        """See BranchFormat.get_format_description()."""
790
 
        return "Branch format 5"
791
 
        
792
 
    def initialize(self, a_bzrdir):
793
 
        """Create a branch of this format in a_bzrdir."""
794
 
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
795
 
        branch_transport = a_bzrdir.get_branch_transport(self)
796
 
        utf8_files = [('revision-history', ''),
797
 
                      ('branch-name', ''),
798
 
                      ]
799
 
        control_files = lockable_files.LockableFiles(branch_transport, 'lock',
800
 
                                                     lockdir.LockDir)
801
 
        control_files.create_lock()
802
 
        control_files.lock_write()
803
 
        control_files.put_utf8('format', self.get_format_string())
804
 
        try:
805
 
            for file, content in utf8_files:
806
 
                control_files.put_utf8(file, content)
807
 
        finally:
808
 
            control_files.unlock()
809
 
        return self.open(a_bzrdir, _found=True, )
810
 
 
811
 
    def __init__(self):
812
 
        super(BzrBranchFormat5, self).__init__()
813
 
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
814
 
 
815
 
    def open(self, a_bzrdir, _found=False):
816
 
        """Return the branch object for a_bzrdir
817
 
 
818
 
        _found is a private parameter, do not use it. It is used to indicate
819
 
               if format probing has already be done.
820
 
        """
821
 
        if not _found:
822
 
            format = BranchFormat.find_format(a_bzrdir)
823
 
            assert format.__class__ == self.__class__
824
 
        transport = a_bzrdir.get_branch_transport(None)
825
 
        control_files = lockable_files.LockableFiles(transport, 'lock',
826
 
                                                     lockdir.LockDir)
827
 
        return BzrBranch5(_format=self,
828
 
                          _control_files=control_files,
829
 
                          a_bzrdir=a_bzrdir,
830
 
                          _repository=a_bzrdir.find_repository())
831
 
 
832
 
    def __str__(self):
833
 
        return "Bazaar-NG Metadir branch format 5"
834
 
 
835
 
 
836
 
class BranchReferenceFormat(BranchFormat):
837
 
    """Bzr branch reference format.
838
 
 
839
 
    Branch references are used in implementing checkouts, they
840
 
    act as an alias to the real branch which is at some other url.
841
 
 
842
 
    This format has:
843
 
     - A location file
844
 
     - a format string
845
 
    """
846
 
 
847
 
    def get_format_string(self):
848
 
        """See BranchFormat.get_format_string()."""
849
 
        return "Bazaar-NG Branch Reference Format 1\n"
850
 
 
851
 
    def get_format_description(self):
852
 
        """See BranchFormat.get_format_description()."""
853
 
        return "Checkout reference format 1"
854
 
        
855
 
    def initialize(self, a_bzrdir, target_branch=None):
856
 
        """Create a branch of this format in a_bzrdir."""
857
 
        if target_branch is None:
858
 
            # this format does not implement branch itself, thus the implicit
859
 
            # creation contract must see it as uninitializable
860
 
            raise errors.UninitializableFormat(self)
861
 
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
862
 
        branch_transport = a_bzrdir.get_branch_transport(self)
863
 
        branch_transport.put_bytes('location',
864
 
            target_branch.bzrdir.root_transport.base)
865
 
        branch_transport.put_bytes('format', self.get_format_string())
866
 
        return self.open(a_bzrdir, _found=True)
867
 
 
868
 
    def __init__(self):
869
 
        super(BranchReferenceFormat, self).__init__()
870
 
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
871
 
 
872
 
    def _make_reference_clone_function(format, a_branch):
873
 
        """Create a clone() routine for a branch dynamically."""
874
 
        def clone(to_bzrdir, revision_id=None):
875
 
            """See Branch.clone()."""
876
 
            return format.initialize(to_bzrdir, a_branch)
877
 
            # cannot obey revision_id limits when cloning a reference ...
878
 
            # FIXME RBC 20060210 either nuke revision_id for clone, or
879
 
            # emit some sort of warning/error to the caller ?!
880
 
        return clone
881
 
 
882
 
    def open(self, a_bzrdir, _found=False):
883
 
        """Return the branch that the branch reference in a_bzrdir points at.
884
 
 
885
 
        _found is a private parameter, do not use it. It is used to indicate
886
 
               if format probing has already be done.
887
 
        """
888
 
        if not _found:
889
 
            format = BranchFormat.find_format(a_bzrdir)
890
 
            assert format.__class__ == self.__class__
891
 
        transport = a_bzrdir.get_branch_transport(None)
892
 
        real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
893
 
        result = real_bzrdir.open_branch()
894
 
        # this changes the behaviour of result.clone to create a new reference
895
 
        # rather than a copy of the content of the branch.
896
 
        # I did not use a proxy object because that needs much more extensive
897
 
        # testing, and we are only changing one behaviour at the moment.
898
 
        # If we decide to alter more behaviours - i.e. the implicit nickname
899
 
        # then this should be refactored to introduce a tested proxy branch
900
 
        # and a subclass of that for use in overriding clone() and ....
901
 
        # - RBC 20060210
902
 
        result.clone = self._make_reference_clone_function(result)
903
 
        return result
904
 
 
905
 
 
906
 
# formats which have no format string are not discoverable
907
 
# and not independently creatable, so are not registered.
908
 
__default_format = BzrBranchFormat5()
909
 
BranchFormat.register_format(__default_format)
910
 
BranchFormat.register_format(BranchReferenceFormat())
911
 
BranchFormat.set_default_format(__default_format)
912
 
_legacy_formats = [BzrBranchFormat4(),
913
 
                   ]
914
 
 
915
 
class BzrBranch(Branch):
916
 
    """A branch stored in the actual filesystem.
917
 
 
918
 
    Note that it's "local" in the context of the filesystem; it doesn't
919
 
    really matter if it's on an nfs/smb/afs/coda/... share, as long as
920
 
    it's writable, and can be accessed via the normal filesystem API.
921
 
    """
 
954
        for f in files:
 
955
            file(os.path.join(self.base, f), 'w').write('content of %s' % f)
 
956
 
 
957
 
 
958
    def __del__(self):
 
959
        """Destroy the test branch, removing the scratch directory."""
 
960
        try:
 
961
            shutil.rmtree(self.base)
 
962
        except OSError:
 
963
            # Work around for shutil.rmtree failing on Windows when
 
964
            # readonly files are encountered
 
965
            for root, dirs, files in os.walk(self.base, topdown=False):
 
966
                for name in files:
 
967
                    os.chmod(os.path.join(root, name), 0700)
 
968
            shutil.rmtree(self.base)
 
969
 
922
970
    
923
 
    def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
924
 
                 relax_version_check=DEPRECATED_PARAMETER, _format=None,
925
 
                 _control_files=None, a_bzrdir=None, _repository=None):
926
 
        """Create new branch object at a particular location.
927
 
 
928
 
        transport -- A Transport object, defining how to access files.
929
 
        
930
 
        init -- If True, create new control files in a previously
931
 
             unversioned directory.  If False, the branch must already
932
 
             be versioned.
933
 
 
934
 
        relax_version_check -- If true, the usual check for the branch
935
 
            version is not applied.  This is intended only for
936
 
            upgrade/recovery type use; it's not guaranteed that
937
 
            all operations will work on old format branches.
938
 
        """
939
 
        if a_bzrdir is None:
940
 
            self.bzrdir = bzrdir.BzrDir.open(transport.base)
941
 
        else:
942
 
            self.bzrdir = a_bzrdir
943
 
        self._transport = self.bzrdir.transport.clone('..')
944
 
        self._base = self._transport.base
945
 
        self._format = _format
946
 
        if _control_files is None:
947
 
            raise ValueError('BzrBranch _control_files is None')
948
 
        self.control_files = _control_files
949
 
        if deprecated_passed(init):
950
 
            warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
951
 
                 "deprecated as of bzr 0.8. Please use Branch.create().",
952
 
                 DeprecationWarning,
953
 
                 stacklevel=2)
954
 
            if init:
955
 
                # this is slower than before deprecation, oh well never mind.
956
 
                # -> its deprecated.
957
 
                self._initialize(transport.base)
958
 
        self._check_format(_format)
959
 
        if deprecated_passed(relax_version_check):
960
 
            warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
961
 
                 "relax_version_check parameter is deprecated as of bzr 0.8. "
962
 
                 "Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
963
 
                 "open() method.",
964
 
                 DeprecationWarning,
965
 
                 stacklevel=2)
966
 
            if (not relax_version_check
967
 
                and not self._format.is_supported()):
968
 
                raise errors.UnsupportedFormatError(format=fmt)
969
 
        if deprecated_passed(transport):
970
 
            warn("BzrBranch.__init__(transport=XXX...): The transport "
971
 
                 "parameter is deprecated as of bzr 0.8. "
972
 
                 "Please use Branch.open, or bzrdir.open_branch().",
973
 
                 DeprecationWarning,
974
 
                 stacklevel=2)
975
 
        self.repository = _repository
976
 
 
977
 
    def __str__(self):
978
 
        return '%s(%r)' % (self.__class__.__name__, self.base)
979
 
 
980
 
    __repr__ = __str__
981
 
 
982
 
    def _get_base(self):
983
 
        return self._base
984
 
 
985
 
    base = property(_get_base, doc="The URL for the root of this branch.")
986
 
 
987
 
    def _finish_transaction(self):
988
 
        """Exit the current transaction."""
989
 
        return self.control_files._finish_transaction()
990
 
 
991
 
    def get_transaction(self):
992
 
        """Return the current active transaction.
993
 
 
994
 
        If no transaction is active, this returns a passthrough object
995
 
        for which all data is immediately flushed and no caching happens.
996
 
        """
997
 
        # this is an explicit function so that we can do tricky stuff
998
 
        # when the storage in rev_storage is elsewhere.
999
 
        # we probably need to hook the two 'lock a location' and 
1000
 
        # 'have a transaction' together more delicately, so that
1001
 
        # we can have two locks (branch and storage) and one transaction
1002
 
        # ... and finishing the transaction unlocks both, but unlocking
1003
 
        # does not. - RBC 20051121
1004
 
        return self.control_files.get_transaction()
1005
 
 
1006
 
    def _set_transaction(self, transaction):
1007
 
        """Set a new active transaction."""
1008
 
        return self.control_files._set_transaction(transaction)
1009
 
 
1010
 
    def abspath(self, name):
1011
 
        """See Branch.abspath."""
1012
 
        return self.control_files._transport.abspath(name)
1013
 
 
1014
 
    def _check_format(self, format):
1015
 
        """Identify the branch format if needed.
1016
 
 
1017
 
        The format is stored as a reference to the format object in
1018
 
        self._format for code that needs to check it later.
1019
 
 
1020
 
        The format parameter is either None or the branch format class
1021
 
        used to open this branch.
1022
 
 
1023
 
        FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
1024
 
        """
1025
 
        if format is None:
1026
 
            format = BranchFormat.find_format(self.bzrdir)
1027
 
        self._format = format
1028
 
        mutter("got branch format %s", self._format)
1029
 
 
1030
 
    @needs_read_lock
1031
 
    def get_root_id(self):
1032
 
        """See Branch.get_root_id."""
1033
 
        tree = self.repository.revision_tree(self.last_revision())
1034
 
        return tree.inventory.root.file_id
1035
 
 
1036
 
    def is_locked(self):
1037
 
        return self.control_files.is_locked()
1038
 
 
1039
 
    def lock_write(self):
1040
 
        self.repository.lock_write()
1041
 
        try:
1042
 
            self.control_files.lock_write()
1043
 
        except:
1044
 
            self.repository.unlock()
1045
 
            raise
1046
 
 
1047
 
    def lock_read(self):
1048
 
        self.repository.lock_read()
1049
 
        try:
1050
 
            self.control_files.lock_read()
1051
 
        except:
1052
 
            self.repository.unlock()
1053
 
            raise
1054
 
 
1055
 
    def unlock(self):
1056
 
        # TODO: test for failed two phase locks. This is known broken.
1057
 
        try:
1058
 
            self.control_files.unlock()
1059
 
        finally:
1060
 
            self.repository.unlock()
1061
 
        
1062
 
    def peek_lock_mode(self):
1063
 
        if self.control_files._lock_count == 0:
1064
 
            return None
1065
 
        else:
1066
 
            return self.control_files._lock_mode
1067
 
 
1068
 
    def get_physical_lock_status(self):
1069
 
        return self.control_files.get_physical_lock_status()
1070
 
 
1071
 
    @needs_read_lock
1072
 
    def print_file(self, file, revision_id):
1073
 
        """See Branch.print_file."""
1074
 
        return self.repository.print_file(file, revision_id)
1075
 
 
1076
 
    @needs_write_lock
1077
 
    def append_revision(self, *revision_ids):
1078
 
        """See Branch.append_revision."""
1079
 
        for revision_id in revision_ids:
1080
 
            mutter("add {%s} to revision-history" % revision_id)
1081
 
        rev_history = self.revision_history()
1082
 
        rev_history.extend(revision_ids)
1083
 
        self.set_revision_history(rev_history)
1084
 
 
1085
 
    @needs_write_lock
1086
 
    def set_revision_history(self, rev_history):
1087
 
        """See Branch.set_revision_history."""
1088
 
        self.control_files.put_utf8(
1089
 
            'revision-history', '\n'.join(rev_history))
1090
 
        transaction = self.get_transaction()
1091
 
        history = transaction.map.find_revision_history()
1092
 
        if history is not None:
1093
 
            # update the revision history in the identity map.
1094
 
            history[:] = list(rev_history)
1095
 
            # this call is disabled because revision_history is 
1096
 
            # not really an object yet, and the transaction is for objects.
1097
 
            # transaction.register_dirty(history)
1098
 
        else:
1099
 
            transaction.map.add_revision_history(rev_history)
1100
 
            # this call is disabled because revision_history is 
1101
 
            # not really an object yet, and the transaction is for objects.
1102
 
            # transaction.register_clean(history)
1103
 
 
1104
 
    @needs_read_lock
1105
 
    def revision_history(self):
1106
 
        """See Branch.revision_history."""
1107
 
        transaction = self.get_transaction()
1108
 
        history = transaction.map.find_revision_history()
1109
 
        if history is not None:
1110
 
            # mutter("cache hit for revision-history in %s", self)
1111
 
            return list(history)
1112
 
        decode_utf8 = cache_utf8.decode
1113
 
        history = [decode_utf8(l.rstrip('\r\n')) for l in
1114
 
                self.control_files.get('revision-history').readlines()]
1115
 
        transaction.map.add_revision_history(history)
1116
 
        # this call is disabled because revision_history is 
1117
 
        # not really an object yet, and the transaction is for objects.
1118
 
        # transaction.register_clean(history, precious=True)
1119
 
        return list(history)
1120
 
 
1121
 
    @needs_write_lock
1122
 
    def generate_revision_history(self, revision_id, last_rev=None, 
1123
 
        other_branch=None):
1124
 
        """Create a new revision history that will finish with revision_id.
1125
 
        
1126
 
        :param revision_id: the new tip to use.
1127
 
        :param last_rev: The previous last_revision. If not None, then this
1128
 
            must be a ancestory of revision_id, or DivergedBranches is raised.
1129
 
        :param other_branch: The other branch that DivergedBranches should
1130
 
            raise with respect to.
1131
 
        """
1132
 
        # stop_revision must be a descendant of last_revision
1133
 
        stop_graph = self.repository.get_revision_graph(revision_id)
1134
 
        if last_rev is not None and last_rev not in stop_graph:
1135
 
            # our previous tip is not merged into stop_revision
1136
 
            raise errors.DivergedBranches(self, other_branch)
1137
 
        # make a new revision history from the graph
1138
 
        current_rev_id = revision_id
1139
 
        new_history = []
1140
 
        while current_rev_id not in (None, _mod_revision.NULL_REVISION):
1141
 
            new_history.append(current_rev_id)
1142
 
            current_rev_id_parents = stop_graph[current_rev_id]
1143
 
            try:
1144
 
                current_rev_id = current_rev_id_parents[0]
1145
 
            except IndexError:
1146
 
                current_rev_id = None
1147
 
        new_history.reverse()
1148
 
        self.set_revision_history(new_history)
1149
 
 
1150
 
    @needs_write_lock
1151
 
    def update_revisions(self, other, stop_revision=None):
1152
 
        """See Branch.update_revisions."""
1153
 
        other.lock_read()
1154
 
        try:
1155
 
            if stop_revision is None:
1156
 
                stop_revision = other.last_revision()
1157
 
                if stop_revision is None:
1158
 
                    # if there are no commits, we're done.
1159
 
                    return
1160
 
            # whats the current last revision, before we fetch [and change it
1161
 
            # possibly]
1162
 
            last_rev = self.last_revision()
1163
 
            # we fetch here regardless of whether we need to so that we pickup
1164
 
            # filled in ghosts.
1165
 
            self.fetch(other, stop_revision)
1166
 
            my_ancestry = self.repository.get_ancestry(last_rev)
1167
 
            if stop_revision in my_ancestry:
1168
 
                # last_revision is a descendant of stop_revision
1169
 
                return
1170
 
            self.generate_revision_history(stop_revision, last_rev=last_rev,
1171
 
                other_branch=other)
1172
 
        finally:
1173
 
            other.unlock()
1174
 
 
1175
 
    def basis_tree(self):
1176
 
        """See Branch.basis_tree."""
1177
 
        return self.repository.revision_tree(self.last_revision())
1178
 
 
1179
 
    @deprecated_method(zero_eight)
1180
 
    def working_tree(self):
1181
 
        """Create a Working tree object for this branch."""
1182
 
 
1183
 
        from bzrlib.transport.local import LocalTransport
1184
 
        if (self.base.find('://') != -1 or 
1185
 
            not isinstance(self._transport, LocalTransport)):
1186
 
            raise NoWorkingTree(self.base)
1187
 
        return self.bzrdir.open_workingtree()
1188
 
 
1189
 
    @needs_write_lock
1190
 
    def pull(self, source, overwrite=False, stop_revision=None):
1191
 
        """See Branch.pull."""
1192
 
        source.lock_read()
1193
 
        try:
1194
 
            old_count = len(self.revision_history())
1195
 
            try:
1196
 
                self.update_revisions(source, stop_revision)
1197
 
            except DivergedBranches:
1198
 
                if not overwrite:
1199
 
                    raise
1200
 
            if overwrite:
1201
 
                self.set_revision_history(source.revision_history())
1202
 
            new_count = len(self.revision_history())
1203
 
            return new_count - old_count
1204
 
        finally:
1205
 
            source.unlock()
1206
 
 
1207
 
    def get_parent(self):
1208
 
        """See Branch.get_parent."""
1209
 
 
1210
 
        _locs = ['parent', 'pull', 'x-pull']
1211
 
        assert self.base[-1] == '/'
1212
 
        for l in _locs:
1213
 
            try:
1214
 
                parent = self.control_files.get(l).read().strip('\n')
1215
 
            except NoSuchFile:
1216
 
                continue
1217
 
            # This is an old-format absolute path to a local branch
1218
 
            # turn it into a url
1219
 
            if parent.startswith('/'):
1220
 
                parent = urlutils.local_path_to_url(parent.decode('utf8'))
1221
 
            try:
1222
 
                return urlutils.join(self.base[:-1], parent)
1223
 
            except errors.InvalidURLJoin, e:
1224
 
                raise errors.InaccessibleParent(parent, self.base)
1225
 
        return None
1226
 
 
1227
 
    def get_push_location(self):
1228
 
        """See Branch.get_push_location."""
1229
 
        push_loc = self.get_config().get_user_option('push_location')
1230
 
        return push_loc
1231
 
 
1232
 
    def set_push_location(self, location):
1233
 
        """See Branch.set_push_location."""
1234
 
        self.get_config().set_user_option(
1235
 
            'push_location', location,
1236
 
            store=_mod_config.STORE_LOCATION_NORECURSE)
1237
 
 
1238
 
    @needs_write_lock
1239
 
    def set_parent(self, url):
1240
 
        """See Branch.set_parent."""
1241
 
        # TODO: Maybe delete old location files?
1242
 
        # URLs should never be unicode, even on the local fs,
1243
 
        # FIXUP this and get_parent in a future branch format bump:
1244
 
        # read and rewrite the file, and have the new format code read
1245
 
        # using .get not .get_utf8. RBC 20060125
1246
 
        if url is None:
1247
 
            self.control_files._transport.delete('parent')
1248
 
        else:
1249
 
            if isinstance(url, unicode):
1250
 
                try: 
1251
 
                    url = url.encode('ascii')
1252
 
                except UnicodeEncodeError:
1253
 
                    raise bzrlib.errors.InvalidURL(url,
1254
 
                        "Urls must be 7-bit ascii, "
1255
 
                        "use bzrlib.urlutils.escape")
1256
 
                    
1257
 
            url = urlutils.relative_url(self.base, url)
1258
 
            self.control_files.put('parent', StringIO(url + '\n'))
1259
 
 
1260
 
    @deprecated_function(zero_nine)
1261
 
    def tree_config(self):
1262
 
        """DEPRECATED; call get_config instead.  
1263
 
        TreeConfig has become part of BranchConfig."""
1264
 
        return TreeConfig(self)
1265
 
 
1266
 
 
1267
 
class BzrBranch5(BzrBranch):
1268
 
    """A format 5 branch. This supports new features over plan branches.
1269
 
 
1270
 
    It has support for a master_branch which is the data for bound branches.
1271
 
    """
1272
 
 
1273
 
    def __init__(self,
1274
 
                 _format,
1275
 
                 _control_files,
1276
 
                 a_bzrdir,
1277
 
                 _repository):
1278
 
        super(BzrBranch5, self).__init__(_format=_format,
1279
 
                                         _control_files=_control_files,
1280
 
                                         a_bzrdir=a_bzrdir,
1281
 
                                         _repository=_repository)
1282
 
        
1283
 
    @needs_write_lock
1284
 
    def pull(self, source, overwrite=False, stop_revision=None):
1285
 
        """Updates branch.pull to be bound branch aware."""
1286
 
        bound_location = self.get_bound_location()
1287
 
        if source.base != bound_location:
1288
 
            # not pulling from master, so we need to update master.
1289
 
            master_branch = self.get_master_branch()
1290
 
            if master_branch:
1291
 
                master_branch.pull(source)
1292
 
                source = master_branch
1293
 
        return super(BzrBranch5, self).pull(source, overwrite, stop_revision)
1294
 
 
1295
 
    def get_bound_location(self):
1296
 
        try:
1297
 
            return self.control_files.get_utf8('bound').read()[:-1]
1298
 
        except errors.NoSuchFile:
1299
 
            return None
1300
 
 
1301
 
    @needs_read_lock
1302
 
    def get_master_branch(self):
1303
 
        """Return the branch we are bound to.
1304
 
        
1305
 
        :return: Either a Branch, or None
1306
 
 
1307
 
        This could memoise the branch, but if thats done
1308
 
        it must be revalidated on each new lock.
1309
 
        So for now we just don't memoise it.
1310
 
        # RBC 20060304 review this decision.
1311
 
        """
1312
 
        bound_loc = self.get_bound_location()
1313
 
        if not bound_loc:
1314
 
            return None
1315
 
        try:
1316
 
            return Branch.open(bound_loc)
1317
 
        except (errors.NotBranchError, errors.ConnectionError), e:
1318
 
            raise errors.BoundBranchConnectionFailure(
1319
 
                    self, bound_loc, e)
1320
 
 
1321
 
    @needs_write_lock
1322
 
    def set_bound_location(self, location):
1323
 
        """Set the target where this branch is bound to.
1324
 
 
1325
 
        :param location: URL to the target branch
1326
 
        """
1327
 
        if location:
1328
 
            self.control_files.put_utf8('bound', location+'\n')
1329
 
        else:
1330
 
            try:
1331
 
                self.control_files._transport.delete('bound')
1332
 
            except NoSuchFile:
1333
 
                return False
 
971
 
 
972
######################################################################
 
973
# predicates
 
974
 
 
975
 
 
976
def is_control_file(filename):
 
977
    ## FIXME: better check
 
978
    filename = os.path.normpath(filename)
 
979
    while filename != '':
 
980
        head, tail = os.path.split(filename)
 
981
        ## mutter('check %r for control file' % ((head, tail), ))
 
982
        if tail == bzrlib.BZRDIR:
1334
983
            return True
1335
 
 
1336
 
    @needs_write_lock
1337
 
    def bind(self, other):
1338
 
        """Bind this branch to the branch other.
1339
 
 
1340
 
        This does not push or pull data between the branches, though it does
1341
 
        check for divergence to raise an error when the branches are not
1342
 
        either the same, or one a prefix of the other. That behaviour may not
1343
 
        be useful, so that check may be removed in future.
1344
 
        
1345
 
        :param other: The branch to bind to
1346
 
        :type other: Branch
1347
 
        """
1348
 
        # TODO: jam 20051230 Consider checking if the target is bound
1349
 
        #       It is debatable whether you should be able to bind to
1350
 
        #       a branch which is itself bound.
1351
 
        #       Committing is obviously forbidden,
1352
 
        #       but binding itself may not be.
1353
 
        #       Since we *have* to check at commit time, we don't
1354
 
        #       *need* to check here
1355
 
 
1356
 
        # we want to raise diverged if:
1357
 
        # last_rev is not in the other_last_rev history, AND
1358
 
        # other_last_rev is not in our history, and do it without pulling
1359
 
        # history around
1360
 
        last_rev = self.last_revision()
1361
 
        if last_rev is not None:
1362
 
            other.lock_read()
1363
 
            try:
1364
 
                other_last_rev = other.last_revision()
1365
 
                if other_last_rev is not None:
1366
 
                    # neither branch is new, we have to do some work to
1367
 
                    # ascertain diversion.
1368
 
                    remote_graph = other.repository.get_revision_graph(
1369
 
                        other_last_rev)
1370
 
                    local_graph = self.repository.get_revision_graph(last_rev)
1371
 
                    if (last_rev not in remote_graph and
1372
 
                        other_last_rev not in local_graph):
1373
 
                        raise errors.DivergedBranches(self, other)
1374
 
            finally:
1375
 
                other.unlock()
1376
 
        self.set_bound_location(other.base)
1377
 
 
1378
 
    @needs_write_lock
1379
 
    def unbind(self):
1380
 
        """If bound, unbind"""
1381
 
        return self.set_bound_location(None)
1382
 
 
1383
 
    @needs_write_lock
1384
 
    def update(self):
1385
 
        """Synchronise this branch with the master branch if any. 
1386
 
 
1387
 
        :return: None or the last_revision that was pivoted out during the
1388
 
                 update.
1389
 
        """
1390
 
        master = self.get_master_branch()
1391
 
        if master is not None:
1392
 
            old_tip = self.last_revision()
1393
 
            self.pull(master, overwrite=True)
1394
 
            if old_tip in self.repository.get_ancestry(self.last_revision()):
1395
 
                return None
1396
 
            return old_tip
1397
 
        return None
1398
 
 
1399
 
 
1400
 
class BranchTestProviderAdapter(object):
1401
 
    """A tool to generate a suite testing multiple branch formats at once.
1402
 
 
1403
 
    This is done by copying the test once for each transport and injecting
1404
 
    the transport_server, transport_readonly_server, and branch_format
1405
 
    classes into each copy. Each copy is also given a new id() to make it
1406
 
    easy to identify.
1407
 
    """
1408
 
 
1409
 
    def __init__(self, transport_server, transport_readonly_server, formats):
1410
 
        self._transport_server = transport_server
1411
 
        self._transport_readonly_server = transport_readonly_server
1412
 
        self._formats = formats
1413
 
    
1414
 
    def adapt(self, test):
1415
 
        result = TestSuite()
1416
 
        for branch_format, bzrdir_format in self._formats:
1417
 
            new_test = deepcopy(test)
1418
 
            new_test.transport_server = self._transport_server
1419
 
            new_test.transport_readonly_server = self._transport_readonly_server
1420
 
            new_test.bzrdir_format = bzrdir_format
1421
 
            new_test.branch_format = branch_format
1422
 
            def make_new_test_id():
1423
 
                new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1424
 
                return lambda: new_id
1425
 
            new_test.id = make_new_test_id()
1426
 
            result.addTest(new_test)
1427
 
        return result
1428
 
 
1429
 
 
1430
 
class BranchCheckResult(object):
1431
 
    """Results of checking branch consistency.
1432
 
 
1433
 
    :see: Branch.check
1434
 
    """
1435
 
 
1436
 
    def __init__(self, branch):
1437
 
        self.branch = branch
1438
 
 
1439
 
    def report_results(self, verbose):
1440
 
        """Report the check results via trace.note.
1441
 
        
1442
 
        :param verbose: Requests more detailed display of what was checked,
1443
 
            if any.
1444
 
        """
1445
 
        note('checked branch %s format %s',
1446
 
             self.branch.base,
1447
 
             self.branch._format)
1448
 
 
1449
 
 
1450
 
######################################################################
1451
 
# predicates
1452
 
 
1453
 
 
1454
 
@deprecated_function(zero_eight)
1455
 
def is_control_file(*args, **kwargs):
1456
 
    """See bzrlib.workingtree.is_control_file."""
1457
 
    from bzrlib import workingtree
1458
 
    return workingtree.is_control_file(*args, **kwargs)
 
984
        if filename == head:
 
985
            break
 
986
        filename = head
 
987
    return False
 
988
 
 
989
 
 
990
 
 
991
def _gen_revision_id(when):
 
992
    """Return new revision-id."""
 
993
    s = '%s-%s-' % (user_email(), compact_date(when))
 
994
    s += hexlify(rand_bytes(8))
 
995
    return s
 
996
 
 
997
 
 
998
def gen_file_id(name):
 
999
    """Return new file id.
 
1000
 
 
1001
    This should probably generate proper UUIDs, but for the moment we
 
1002
    cope with just randomness because running uuidgen every time is
 
1003
    slow."""
 
1004
    idx = name.rfind('/')
 
1005
    if idx != -1:
 
1006
        name = name[idx+1 : ]
 
1007
    idx = name.rfind('\\')
 
1008
    if idx != -1:
 
1009
        name = name[idx+1 : ]
 
1010
 
 
1011
    name = name.lstrip('.')
 
1012
 
 
1013
    s = hexlify(rand_bytes(8))
 
1014
    return '-'.join((name, compact_date(time.time()), s))