~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Martin Pool
  • Date: 2005-08-19 21:34:32 UTC
  • Revision ID: mbp@sourcefrog.net-20050819213432-4fa923a97c45d845
- add schema and example for new inventory form

Show diffs side-by-side

added added

removed removed

Lines of Context:
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
 
from copy import deepcopy
19
 
from cStringIO import StringIO
20
 
import errno
 
18
import sys
21
19
import os
22
 
import shutil
23
 
import sys
24
 
from unittest import TestSuite
25
 
from warnings import warn
26
 
 
27
20
 
28
21
import bzrlib
29
 
from bzrlib.config import TreeConfig
 
22
from bzrlib.trace import mutter, note
 
23
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, \
 
24
     splitpath, \
 
25
     sha_file, appendpath, file_kind
 
26
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId
 
27
import bzrlib.errors
 
28
from bzrlib.textui import show_status
 
29
from bzrlib.revision import Revision
 
30
from bzrlib.xml import unpack_xml
30
31
from bzrlib.delta import compare_trees
31
 
import bzrlib.errors as errors
32
 
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
33
 
                           NoSuchRevision, HistoryMissing, NotBranchError,
34
 
                           DivergedBranches, LockError, 
35
 
                           UninitializableFormat,
36
 
                           UnlistableStore,
37
 
                           UnlistableBranch, NoSuchFile, NotVersionedError,
38
 
                           NoWorkingTree)
39
 
import bzrlib.inventory as inventory
40
 
from bzrlib.inventory import Inventory
41
 
from bzrlib.osutils import (isdir, quotefn,
42
 
                            rename, splitpath, sha_file,
43
 
                            file_kind, abspath, normpath, pathjoin,
44
 
                            safe_unicode,
45
 
                            )
46
 
from bzrlib.textui import show_status
47
 
from bzrlib.trace import mutter, note
48
32
from bzrlib.tree import EmptyTree, RevisionTree
49
 
from bzrlib.revision import (Revision, is_ancestor, get_intervening_revisions,
50
 
                             NULL_REVISION)
51
 
from bzrlib.store import copy_all
52
 
from bzrlib.store.text import TextStore
53
 
from bzrlib.store.weave import WeaveStore
54
 
from bzrlib.symbol_versioning import deprecated_nonce, deprecated_passed
55
 
from bzrlib.testament import Testament
56
 
import bzrlib.transactions as transactions
57
 
from bzrlib.transport import Transport, get_transport
58
 
import bzrlib.xml5
59
 
import bzrlib.ui
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"
 
33
        
 
34
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
65
35
## TODO: Maybe include checks for common corruption of newlines, etc?
66
36
 
67
37
 
68
38
# TODO: Some operations like log might retrieve the same revisions
69
39
# repeatedly to calculate deltas.  We could perhaps have a weakref
70
 
# cache in memory to make this faster.  In general anything can be
71
 
# cached in memory between lock and unlock operations.
72
 
 
73
 
def find_branch(*ignored, **ignored_too):
74
 
    # XXX: leave this here for about one release, then remove it
75
 
    raise NotImplementedError('find_branch() is not supported anymore, '
76
 
                              'please use one of the new branch constructors')
77
 
 
78
 
 
79
 
def needs_read_lock(unbound):
80
 
    """Decorate unbound to take out and release a read lock."""
81
 
    def decorated(self, *args, **kwargs):
82
 
        self.lock_read()
83
 
        try:
84
 
            return unbound(self, *args, **kwargs)
85
 
        finally:
86
 
            self.unlock()
87
 
    return decorated
88
 
 
89
 
 
90
 
def needs_write_lock(unbound):
91
 
    """Decorate unbound to take out and release a write lock."""
92
 
    def decorated(self, *args, **kwargs):
93
 
        self.lock_write()
94
 
        try:
95
 
            return unbound(self, *args, **kwargs)
96
 
        finally:
97
 
            self.unlock()
98
 
    return decorated
 
40
# cache in memory to make this faster.
 
41
 
 
42
# TODO: please move the revision-string syntax stuff out of the branch
 
43
# object; it's clutter
 
44
 
 
45
 
 
46
def find_branch(f, **args):
 
47
    if f and (f.startswith('http://') or f.startswith('https://')):
 
48
        import remotebranch 
 
49
        return remotebranch.RemoteBranch(f, **args)
 
50
    else:
 
51
        return Branch(f, **args)
 
52
 
 
53
 
 
54
def find_cached_branch(f, cache_root, **args):
 
55
    from remotebranch import RemoteBranch
 
56
    br = find_branch(f, **args)
 
57
    def cacheify(br, store_name):
 
58
        from meta_store import CachedStore
 
59
        cache_path = os.path.join(cache_root, store_name)
 
60
        os.mkdir(cache_path)
 
61
        new_store = CachedStore(getattr(br, store_name), cache_path)
 
62
        setattr(br, store_name, new_store)
 
63
 
 
64
    if isinstance(br, RemoteBranch):
 
65
        cacheify(br, 'inventory_store')
 
66
        cacheify(br, 'text_store')
 
67
        cacheify(br, 'revision_store')
 
68
    return br
 
69
 
 
70
 
 
71
def _relpath(base, path):
 
72
    """Return path relative to base, or raise exception.
 
73
 
 
74
    The path may be either an absolute path or a path relative to the
 
75
    current working directory.
 
76
 
 
77
    Lifted out of Branch.relpath for ease of testing.
 
78
 
 
79
    os.path.commonprefix (python2.4) has a bad bug that it works just
 
80
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
 
81
    avoids that problem."""
 
82
    rp = os.path.abspath(path)
 
83
 
 
84
    s = []
 
85
    head = rp
 
86
    while len(head) >= len(base):
 
87
        if head == base:
 
88
            break
 
89
        head, tail = os.path.split(head)
 
90
        if tail:
 
91
            s.insert(0, tail)
 
92
    else:
 
93
        from errors import NotBranchError
 
94
        raise NotBranchError("path %r is not within branch %r" % (rp, base))
 
95
 
 
96
    return os.sep.join(s)
 
97
        
 
98
 
 
99
def find_branch_root(f=None):
 
100
    """Find the branch root enclosing f, or pwd.
 
101
 
 
102
    f may be a filename or a URL.
 
103
 
 
104
    It is not necessary that f exists.
 
105
 
 
106
    Basically we keep looking up until we find the control directory or
 
107
    run into the root.  If there isn't one, raises NotBranchError.
 
108
    """
 
109
    if f == None:
 
110
        f = os.getcwd()
 
111
    elif hasattr(os.path, 'realpath'):
 
112
        f = os.path.realpath(f)
 
113
    else:
 
114
        f = os.path.abspath(f)
 
115
    if not os.path.exists(f):
 
116
        raise BzrError('%r does not exist' % f)
 
117
        
 
118
 
 
119
    orig_f = f
 
120
 
 
121
    while True:
 
122
        if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
 
123
            return f
 
124
        head, tail = os.path.split(f)
 
125
        if head == f:
 
126
            # reached the root, whatever that may be
 
127
            raise bzrlib.errors.NotBranchError('%r is not in a branch' % orig_f)
 
128
        f = head
 
129
 
 
130
 
 
131
 
 
132
# XXX: move into bzrlib.errors; subclass BzrError    
 
133
class DivergedBranches(Exception):
 
134
    def __init__(self, branch1, branch2):
 
135
        self.branch1 = branch1
 
136
        self.branch2 = branch2
 
137
        Exception.__init__(self, "These branches have diverged.")
 
138
 
99
139
 
100
140
######################################################################
101
141
# branch objects
104
144
    """Branch holding a history of revisions.
105
145
 
106
146
    base
107
 
        Base directory/url of the branch.
 
147
        Base directory of the branch.
 
148
 
 
149
    _lock_mode
 
150
        None, or 'r' or 'w'
 
151
 
 
152
    _lock_count
 
153
        If _lock_mode is true, a positive count of the number of times the
 
154
        lock has been taken.
 
155
 
 
156
    _lock
 
157
        Lock object from bzrlib.lock.
108
158
    """
109
 
    # this is really an instance variable - FIXME move it there
110
 
    # - RBC 20060112
111
159
    base = None
112
 
 
113
 
    _default_initializer = None
114
 
    """The default initializer for making new branches."""
115
 
 
116
 
    def __init__(self, *ignored, **ignored_too):
117
 
        raise NotImplementedError('The Branch class is abstract')
118
 
 
119
 
    @staticmethod
120
 
    def open_downlevel(base):
121
 
        """Open a branch which may be of an old format."""
122
 
        return Branch.open(base, _unsupported=True)
123
 
        
124
 
    @staticmethod
125
 
    def open(base, _unsupported=False):
126
 
        """Open an existing branch, rooted at 'base' (url)
127
 
        
128
 
        _unsupported is a private parameter to the Branch class.
129
 
        """
130
 
        t = get_transport(base)
131
 
        mutter("trying to open %r with transport %r", base, t)
132
 
        format = BzrBranchFormat.find_format(t)
133
 
        if not _unsupported and not format.is_supported():
134
 
            # see open_downlevel to open legacy branches.
135
 
            raise errors.UnsupportedFormatError(
136
 
                    'sorry, branch format %s not supported' % format,
137
 
                    ['use a different bzr version',
138
 
                     'or remove the .bzr directory'
139
 
                     ' and "bzr init" again'])
140
 
        return format.open(t)
141
 
 
142
 
    @staticmethod
143
 
    def open_containing(url):
144
 
        """Open an existing branch which contains url.
145
 
        
146
 
        This probes for a branch at url, and searches upwards from there.
147
 
 
148
 
        Basically we keep looking up until we find the control directory or
149
 
        run into the root.  If there isn't one, raises NotBranchError.
150
 
        If there is one, it is returned, along with the unused portion of url.
151
 
        """
152
 
        t = get_transport(url)
153
 
        url = t.base
154
 
        while True:
155
 
            try:
156
 
                format = BzrBranchFormat.find_format(t)
157
 
                return format.open(t), t.relpath(url)
158
 
            # TODO FIXME, distinguish between formats that cannot be
159
 
            # identified, and a lack of format.
160
 
            except NotBranchError, e:
161
 
                mutter('not a branch in: %r %s', t.base, e)
162
 
            new_t = t.clone('..')
163
 
            if new_t.base == t.base:
164
 
                # reached the root, whatever that may be
165
 
                raise NotBranchError(path=url)
166
 
            t = new_t
167
 
 
168
 
    @staticmethod
169
 
    def initialize(base):
170
 
        """Create a new branch, rooted at 'base' (url)
171
 
        
172
 
        This will call the current default initializer with base
173
 
        as the only parameter.
174
 
        """
175
 
        return Branch._default_initializer(safe_unicode(base))
176
 
 
177
 
    @staticmethod
178
 
    def get_default_initializer():
179
 
        """Return the initializer being used for new branches."""
180
 
        return Branch._default_initializer
181
 
 
182
 
    @staticmethod
183
 
    def set_default_initializer(initializer):
184
 
        """Set the initializer to be used for new branches."""
185
 
        Branch._default_initializer = staticmethod(initializer)
186
 
 
187
 
    def setup_caching(self, cache_root):
188
 
        """Subclasses that care about caching should override this, and set
189
 
        up cached stores located under cache_root.
190
 
        """
191
 
        self.cache_root = cache_root
192
 
 
193
 
    def _get_nick(self):
194
 
        cfg = self.tree_config()
195
 
        return cfg.get_option(u"nickname", default=self.base.split('/')[-2])
196
 
 
197
 
    def _set_nick(self, nick):
198
 
        cfg = self.tree_config()
199
 
        cfg.set_option(nick, "nickname")
200
 
        assert cfg.get_option("nickname") == nick
201
 
 
202
 
    nick = property(_get_nick, _set_nick)
203
 
        
204
 
    def push_stores(self, branch_to):
205
 
        """Copy the content of this branches store to branch_to."""
206
 
        raise NotImplementedError('push_stores is abstract')
207
 
 
208
 
    def get_transaction(self):
209
 
        """Return the current active transaction.
210
 
 
211
 
        If no transaction is active, this returns a passthrough object
212
 
        for which all data is immediately flushed and no caching happens.
213
 
        """
214
 
        raise NotImplementedError('get_transaction is abstract')
 
160
    _lock_mode = None
 
161
    _lock_count = None
 
162
    _lock = None
 
163
    
 
164
    # Map some sort of prefix into a namespace
 
165
    # stuff like "revno:10", "revid:", etc.
 
166
    # This should match a prefix with a function which accepts
 
167
    REVISION_NAMESPACES = {}
 
168
 
 
169
    def __init__(self, base, init=False, find_root=True):
 
170
        """Create new branch object at a particular location.
 
171
 
 
172
        base -- Base directory for the branch.
 
173
        
 
174
        init -- If True, create new control files in a previously
 
175
             unversioned directory.  If False, the branch must already
 
176
             be versioned.
 
177
 
 
178
        find_root -- If true and init is false, find the root of the
 
179
             existing branch containing base.
 
180
 
 
181
        In the test suite, creation of new trees is tested using the
 
182
        `ScratchBranch` class.
 
183
        """
 
184
        from bzrlib.store import ImmutableStore
 
185
        if init:
 
186
            self.base = os.path.realpath(base)
 
187
            self._make_control()
 
188
        elif find_root:
 
189
            self.base = find_branch_root(base)
 
190
        else:
 
191
            self.base = os.path.realpath(base)
 
192
            if not isdir(self.controlfilename('.')):
 
193
                from errors import NotBranchError
 
194
                raise NotBranchError("not a bzr branch: %s" % quotefn(base),
 
195
                                     ['use "bzr init" to initialize a new working tree',
 
196
                                      'current bzr can only operate from top-of-tree'])
 
197
        self._check_format()
 
198
 
 
199
        self.text_store = ImmutableStore(self.controlfilename('text-store'))
 
200
        self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
 
201
        self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
 
202
 
 
203
 
 
204
    def __str__(self):
 
205
        return '%s(%r)' % (self.__class__.__name__, self.base)
 
206
 
 
207
 
 
208
    __repr__ = __str__
 
209
 
 
210
 
 
211
    def __del__(self):
 
212
        if self._lock_mode or self._lock:
 
213
            from warnings import warn
 
214
            warn("branch %r was not explicitly unlocked" % self)
 
215
            self._lock.unlock()
 
216
 
 
217
 
215
218
 
216
219
    def lock_write(self):
217
 
        raise NotImplementedError('lock_write is abstract')
218
 
        
 
220
        if self._lock_mode:
 
221
            if self._lock_mode != 'w':
 
222
                from errors import LockError
 
223
                raise LockError("can't upgrade to a write lock from %r" %
 
224
                                self._lock_mode)
 
225
            self._lock_count += 1
 
226
        else:
 
227
            from bzrlib.lock import WriteLock
 
228
 
 
229
            self._lock = WriteLock(self.controlfilename('branch-lock'))
 
230
            self._lock_mode = 'w'
 
231
            self._lock_count = 1
 
232
 
 
233
 
 
234
 
219
235
    def lock_read(self):
220
 
        raise NotImplementedError('lock_read is abstract')
221
 
 
 
236
        if self._lock_mode:
 
237
            assert self._lock_mode in ('r', 'w'), \
 
238
                   "invalid lock mode %r" % self._lock_mode
 
239
            self._lock_count += 1
 
240
        else:
 
241
            from bzrlib.lock import ReadLock
 
242
 
 
243
            self._lock = ReadLock(self.controlfilename('branch-lock'))
 
244
            self._lock_mode = 'r'
 
245
            self._lock_count = 1
 
246
                        
 
247
 
 
248
            
222
249
    def unlock(self):
223
 
        raise NotImplementedError('unlock is abstract')
 
250
        if not self._lock_mode:
 
251
            from errors import LockError
 
252
            raise LockError('branch %r is not locked' % (self))
 
253
 
 
254
        if self._lock_count > 1:
 
255
            self._lock_count -= 1
 
256
        else:
 
257
            self._lock.unlock()
 
258
            self._lock = None
 
259
            self._lock_mode = self._lock_count = None
 
260
 
224
261
 
225
262
    def abspath(self, name):
226
 
        """Return absolute filename for something in the branch
227
 
        
228
 
        XXX: Robert Collins 20051017 what is this used for? why is it a branch
229
 
        method and not a tree method.
230
 
        """
231
 
        raise NotImplementedError('abspath is abstract')
 
263
        """Return absolute filename for something in the branch"""
 
264
        return os.path.join(self.base, name)
 
265
 
 
266
 
 
267
    def relpath(self, path):
 
268
        """Return path relative to this branch of something inside it.
 
269
 
 
270
        Raises an error if path is not in this branch."""
 
271
        return _relpath(self.base, path)
 
272
 
232
273
 
233
274
    def controlfilename(self, file_or_path):
234
275
        """Return location relative to branch."""
235
 
        raise NotImplementedError('controlfilename is abstract')
 
276
        if isinstance(file_or_path, basestring):
 
277
            file_or_path = [file_or_path]
 
278
        return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
 
279
 
236
280
 
237
281
    def controlfile(self, file_or_path, mode='r'):
238
282
        """Open a control file for this branch.
245
289
        Controlfiles should almost never be opened in write mode but
246
290
        rather should be atomically copied and replaced using atomicfile.
247
291
        """
248
 
        raise NotImplementedError('controlfile is abstract')
249
 
 
250
 
    def put_controlfile(self, path, f, encode=True):
251
 
        """Write an entry as a controlfile.
252
 
 
253
 
        :param path: The path to put the file, relative to the .bzr control
254
 
                     directory
255
 
        :param f: A file-like or string object whose contents should be copied.
256
 
        :param encode:  If true, encode the contents as utf-8
257
 
        """
258
 
        raise NotImplementedError('put_controlfile is abstract')
259
 
 
260
 
    def put_controlfiles(self, files, encode=True):
261
 
        """Write several entries as controlfiles.
262
 
 
263
 
        :param files: A list of [(path, file)] pairs, where the path is the directory
264
 
                      underneath the bzr control directory
265
 
        :param encode:  If true, encode the contents as utf-8
266
 
        """
267
 
        raise NotImplementedError('put_controlfiles is abstract')
 
292
 
 
293
        fn = self.controlfilename(file_or_path)
 
294
 
 
295
        if mode == 'rb' or mode == 'wb':
 
296
            return file(fn, mode)
 
297
        elif mode == 'r' or mode == 'w':
 
298
            # open in binary mode anyhow so there's no newline translation;
 
299
            # codecs uses line buffering by default; don't want that.
 
300
            import codecs
 
301
            return codecs.open(fn, mode + 'b', 'utf-8',
 
302
                               buffering=60000)
 
303
        else:
 
304
            raise BzrError("invalid controlfile mode %r" % mode)
 
305
 
 
306
 
 
307
 
 
308
    def _make_control(self):
 
309
        from bzrlib.inventory import Inventory
 
310
        from bzrlib.xml import pack_xml
 
311
        
 
312
        os.mkdir(self.controlfilename([]))
 
313
        self.controlfile('README', 'w').write(
 
314
            "This is a Bazaar-NG control directory.\n"
 
315
            "Do not change any files in this directory.\n")
 
316
        self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
 
317
        for d in ('text-store', 'inventory-store', 'revision-store'):
 
318
            os.mkdir(self.controlfilename(d))
 
319
        for f in ('revision-history', 'merged-patches',
 
320
                  'pending-merged-patches', 'branch-name',
 
321
                  'branch-lock',
 
322
                  'pending-merges'):
 
323
            self.controlfile(f, 'w').write('')
 
324
        mutter('created control directory in ' + self.base)
 
325
 
 
326
        # if we want per-tree root ids then this is the place to set
 
327
        # them; they're not needed for now and so ommitted for
 
328
        # simplicity.
 
329
        pack_xml(Inventory(), self.controlfile('inventory','w'))
 
330
 
 
331
 
 
332
    def _check_format(self):
 
333
        """Check this branch format is supported.
 
334
 
 
335
        The current tool only supports the current unstable format.
 
336
 
 
337
        In the future, we might need different in-memory Branch
 
338
        classes to support downlevel branches.  But not yet.
 
339
        """
 
340
        # This ignores newlines so that we can open branches created
 
341
        # on Windows from Linux and so on.  I think it might be better
 
342
        # to always make all internal files in unix format.
 
343
        fmt = self.controlfile('branch-format', 'r').read()
 
344
        fmt.replace('\r\n', '')
 
345
        if fmt != BZR_BRANCH_FORMAT:
 
346
            raise BzrError('sorry, branch format %r not supported' % fmt,
 
347
                           ['use a different bzr version',
 
348
                            'or remove the .bzr directory and "bzr init" again'])
268
349
 
269
350
    def get_root_id(self):
270
351
        """Return the id of this branches root"""
271
 
        raise NotImplementedError('get_root_id is abstract')
 
352
        inv = self.read_working_inventory()
 
353
        return inv.root.file_id
272
354
 
273
355
    def set_root_id(self, file_id):
274
 
        raise NotImplementedError('set_root_id is abstract')
275
 
 
276
 
    def print_file(self, file, revision_id):
 
356
        inv = self.read_working_inventory()
 
357
        orig_root_id = inv.root.file_id
 
358
        del inv._byid[inv.root.file_id]
 
359
        inv.root.file_id = file_id
 
360
        inv._byid[inv.root.file_id] = inv.root
 
361
        for fid in inv:
 
362
            entry = inv[fid]
 
363
            if entry.parent_id in (None, orig_root_id):
 
364
                entry.parent_id = inv.root.file_id
 
365
        self._write_inventory(inv)
 
366
 
 
367
    def read_working_inventory(self):
 
368
        """Read the working inventory."""
 
369
        from bzrlib.inventory import Inventory
 
370
        from bzrlib.xml import unpack_xml
 
371
        from time import time
 
372
        before = time()
 
373
        self.lock_read()
 
374
        try:
 
375
            # ElementTree does its own conversion from UTF-8, so open in
 
376
            # binary.
 
377
            inv = unpack_xml(Inventory,
 
378
                             self.controlfile('inventory', 'rb'))
 
379
            mutter("loaded inventory of %d items in %f"
 
380
                   % (len(inv), time() - before))
 
381
            return inv
 
382
        finally:
 
383
            self.unlock()
 
384
            
 
385
 
 
386
    def _write_inventory(self, inv):
 
387
        """Update the working inventory.
 
388
 
 
389
        That is to say, the inventory describing changes underway, that
 
390
        will be committed to the next revision.
 
391
        """
 
392
        from bzrlib.atomicfile import AtomicFile
 
393
        from bzrlib.xml import pack_xml
 
394
        
 
395
        self.lock_write()
 
396
        try:
 
397
            f = AtomicFile(self.controlfilename('inventory'), 'wb')
 
398
            try:
 
399
                pack_xml(inv, f)
 
400
                f.commit()
 
401
            finally:
 
402
                f.close()
 
403
        finally:
 
404
            self.unlock()
 
405
        
 
406
        mutter('wrote working inventory')
 
407
            
 
408
 
 
409
    inventory = property(read_working_inventory, _write_inventory, None,
 
410
                         """Inventory for the working copy.""")
 
411
 
 
412
 
 
413
    def add(self, files, verbose=False, ids=None):
 
414
        """Make files versioned.
 
415
 
 
416
        Note that the command line normally calls smart_add instead.
 
417
 
 
418
        This puts the files in the Added state, so that they will be
 
419
        recorded by the next commit.
 
420
 
 
421
        files
 
422
            List of paths to add, relative to the base of the tree.
 
423
 
 
424
        ids
 
425
            If set, use these instead of automatically generated ids.
 
426
            Must be the same length as the list of files, but may
 
427
            contain None for ids that are to be autogenerated.
 
428
 
 
429
        TODO: Perhaps have an option to add the ids even if the files do
 
430
              not (yet) exist.
 
431
 
 
432
        TODO: Perhaps return the ids of the files?  But then again it
 
433
              is easy to retrieve them if they're needed.
 
434
 
 
435
        TODO: Adding a directory should optionally recurse down and
 
436
              add all non-ignored children.  Perhaps do that in a
 
437
              higher-level method.
 
438
        """
 
439
        # TODO: Re-adding a file that is removed in the working copy
 
440
        # should probably put it back with the previous ID.
 
441
        if isinstance(files, basestring):
 
442
            assert(ids is None or isinstance(ids, basestring))
 
443
            files = [files]
 
444
            if ids is not None:
 
445
                ids = [ids]
 
446
 
 
447
        if ids is None:
 
448
            ids = [None] * len(files)
 
449
        else:
 
450
            assert(len(ids) == len(files))
 
451
 
 
452
        self.lock_write()
 
453
        try:
 
454
            inv = self.read_working_inventory()
 
455
            for f,file_id in zip(files, ids):
 
456
                if is_control_file(f):
 
457
                    raise BzrError("cannot add control file %s" % quotefn(f))
 
458
 
 
459
                fp = splitpath(f)
 
460
 
 
461
                if len(fp) == 0:
 
462
                    raise BzrError("cannot add top-level %r" % f)
 
463
 
 
464
                fullpath = os.path.normpath(self.abspath(f))
 
465
 
 
466
                try:
 
467
                    kind = file_kind(fullpath)
 
468
                except OSError:
 
469
                    # maybe something better?
 
470
                    raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
 
471
 
 
472
                if kind != 'file' and kind != 'directory':
 
473
                    raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
 
474
 
 
475
                if file_id is None:
 
476
                    file_id = gen_file_id(f)
 
477
                inv.add_path(f, kind=kind, file_id=file_id)
 
478
 
 
479
                if verbose:
 
480
                    print 'added', quotefn(f)
 
481
 
 
482
                mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
 
483
 
 
484
            self._write_inventory(inv)
 
485
        finally:
 
486
            self.unlock()
 
487
            
 
488
 
 
489
    def print_file(self, file, revno):
277
490
        """Print `file` to stdout."""
278
 
        raise NotImplementedError('print_file is abstract')
 
491
        self.lock_read()
 
492
        try:
 
493
            tree = self.revision_tree(self.lookup_revision(revno))
 
494
            # use inventory as it was in that revision
 
495
            file_id = tree.inventory.path2id(file)
 
496
            if not file_id:
 
497
                raise BzrError("%r is not present in revision %s" % (file, revno))
 
498
            tree.print_file(file_id)
 
499
        finally:
 
500
            self.unlock()
 
501
 
 
502
 
 
503
    def remove(self, files, verbose=False):
 
504
        """Mark nominated files for removal from the inventory.
 
505
 
 
506
        This does not remove their text.  This does not run on 
 
507
 
 
508
        TODO: Refuse to remove modified files unless --force is given?
 
509
 
 
510
        TODO: Do something useful with directories.
 
511
 
 
512
        TODO: Should this remove the text or not?  Tough call; not
 
513
        removing may be useful and the user can just use use rm, and
 
514
        is the opposite of add.  Removing it is consistent with most
 
515
        other tools.  Maybe an option.
 
516
        """
 
517
        ## TODO: Normalize names
 
518
        ## TODO: Remove nested loops; better scalability
 
519
        if isinstance(files, basestring):
 
520
            files = [files]
 
521
 
 
522
        self.lock_write()
 
523
 
 
524
        try:
 
525
            tree = self.working_tree()
 
526
            inv = tree.inventory
 
527
 
 
528
            # do this before any modifications
 
529
            for f in files:
 
530
                fid = inv.path2id(f)
 
531
                if not fid:
 
532
                    raise BzrError("cannot remove unversioned file %s" % quotefn(f))
 
533
                mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
 
534
                if verbose:
 
535
                    # having remove it, it must be either ignored or unknown
 
536
                    if tree.is_ignored(f):
 
537
                        new_status = 'I'
 
538
                    else:
 
539
                        new_status = '?'
 
540
                    show_status(new_status, inv[fid].kind, quotefn(f))
 
541
                del inv[fid]
 
542
 
 
543
            self._write_inventory(inv)
 
544
        finally:
 
545
            self.unlock()
 
546
 
 
547
 
 
548
    # FIXME: this doesn't need to be a branch method
 
549
    def set_inventory(self, new_inventory_list):
 
550
        from bzrlib.inventory import Inventory, InventoryEntry
 
551
        inv = Inventory(self.get_root_id())
 
552
        for path, file_id, parent, kind in new_inventory_list:
 
553
            name = os.path.basename(path)
 
554
            if name == "":
 
555
                continue
 
556
            inv.add(InventoryEntry(file_id, name, kind, parent))
 
557
        self._write_inventory(inv)
 
558
 
 
559
 
 
560
    def unknowns(self):
 
561
        """Return all unknown files.
 
562
 
 
563
        These are files in the working directory that are not versioned or
 
564
        control files or ignored.
 
565
        
 
566
        >>> b = ScratchBranch(files=['foo', 'foo~'])
 
567
        >>> list(b.unknowns())
 
568
        ['foo']
 
569
        >>> b.add('foo')
 
570
        >>> list(b.unknowns())
 
571
        []
 
572
        >>> b.remove('foo')
 
573
        >>> list(b.unknowns())
 
574
        ['foo']
 
575
        """
 
576
        return self.working_tree().unknowns()
 
577
 
279
578
 
280
579
    def append_revision(self, *revision_ids):
281
 
        raise NotImplementedError('append_revision is abstract')
282
 
 
283
 
    def set_revision_history(self, rev_history):
284
 
        raise NotImplementedError('set_revision_history is abstract')
285
 
 
286
 
    def has_revision(self, revision_id):
287
 
        """True if this branch has a copy of the revision.
288
 
 
289
 
        This does not necessarily imply the revision is merge
290
 
        or on the mainline."""
291
 
        raise NotImplementedError('has_revision is abstract')
 
580
        from bzrlib.atomicfile import AtomicFile
 
581
 
 
582
        for revision_id in revision_ids:
 
583
            mutter("add {%s} to revision-history" % revision_id)
 
584
 
 
585
        rev_history = self.revision_history()
 
586
        rev_history.extend(revision_ids)
 
587
 
 
588
        f = AtomicFile(self.controlfilename('revision-history'))
 
589
        try:
 
590
            for rev_id in rev_history:
 
591
                print >>f, rev_id
 
592
            f.commit()
 
593
        finally:
 
594
            f.close()
 
595
 
292
596
 
293
597
    def get_revision_xml(self, revision_id):
294
 
        raise NotImplementedError('get_revision_xml is abstract')
 
598
        """Return XML file object for revision object."""
 
599
        if not revision_id or not isinstance(revision_id, basestring):
 
600
            raise InvalidRevisionId(revision_id)
 
601
 
 
602
        self.lock_read()
 
603
        try:
 
604
            try:
 
605
                return self.revision_store[revision_id]
 
606
            except IndexError:
 
607
                raise bzrlib.errors.NoSuchRevision(self, revision_id)
 
608
        finally:
 
609
            self.unlock()
 
610
 
295
611
 
296
612
    def get_revision(self, revision_id):
297
613
        """Return the Revision object for a named revision"""
298
 
        raise NotImplementedError('get_revision is abstract')
 
614
        xml_file = self.get_revision_xml(revision_id)
 
615
 
 
616
        try:
 
617
            r = unpack_xml(Revision, xml_file)
 
618
        except SyntaxError, e:
 
619
            raise bzrlib.errors.BzrError('failed to unpack revision_xml',
 
620
                                         [revision_id,
 
621
                                          str(e)])
 
622
            
 
623
        assert r.revision_id == revision_id
 
624
        return r
 
625
 
299
626
 
300
627
    def get_revision_delta(self, revno):
301
628
        """Return the delta for one revision.
318
645
 
319
646
        return compare_trees(old_tree, new_tree)
320
647
 
 
648
        
 
649
 
321
650
    def get_revision_sha1(self, revision_id):
322
651
        """Hash the stored value of a revision, and return it."""
323
 
        raise NotImplementedError('get_revision_sha1 is abstract')
324
 
 
325
 
    def get_ancestry(self, revision_id):
326
 
        """Return a list of revision-ids integrated by a revision.
327
 
        
328
 
        This currently returns a list, but the ordering is not guaranteed:
329
 
        treat it as a set.
330
 
        """
331
 
        raise NotImplementedError('get_ancestry is abstract')
332
 
 
333
 
    def get_inventory(self, revision_id):
334
 
        """Get Inventory object by hash."""
335
 
        raise NotImplementedError('get_inventory is abstract')
336
 
 
337
 
    def get_inventory_xml(self, revision_id):
 
652
        # In the future, revision entries will be signed. At that
 
653
        # point, it is probably best *not* to include the signature
 
654
        # in the revision hash. Because that lets you re-sign
 
655
        # the revision, (add signatures/remove signatures) and still
 
656
        # have all hash pointers stay consistent.
 
657
        # But for now, just hash the contents.
 
658
        return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
 
659
 
 
660
 
 
661
    def get_inventory(self, inventory_id):
 
662
        """Get Inventory object by hash.
 
663
 
 
664
        TODO: Perhaps for this and similar methods, take a revision
 
665
               parameter which can be either an integer revno or a
 
666
               string hash."""
 
667
        from bzrlib.inventory import Inventory
 
668
        from bzrlib.xml import unpack_xml
 
669
 
 
670
        return unpack_xml(Inventory, self.get_inventory_xml(inventory_id))
 
671
 
 
672
 
 
673
    def get_inventory_xml(self, inventory_id):
338
674
        """Get inventory XML as a file object."""
339
 
        raise NotImplementedError('get_inventory_xml is abstract')
340
 
 
341
 
    def get_inventory_sha1(self, revision_id):
342
 
        """Return the sha1 hash of the inventory entry."""
343
 
        raise NotImplementedError('get_inventory_sha1 is abstract')
 
675
        return self.inventory_store[inventory_id]
 
676
            
 
677
 
 
678
    def get_inventory_sha1(self, inventory_id):
 
679
        """Return the sha1 hash of the inventory entry
 
680
        """
 
681
        return sha_file(self.get_inventory_xml(inventory_id))
 
682
 
344
683
 
345
684
    def get_revision_inventory(self, revision_id):
346
685
        """Return inventory of a past revision."""
347
 
        raise NotImplementedError('get_revision_inventory is abstract')
 
686
        # bzr 0.0.6 imposes the constraint that the inventory_id
 
687
        # must be the same as its revision, so this is trivial.
 
688
        if revision_id == None:
 
689
            from bzrlib.inventory import Inventory
 
690
            return Inventory(self.get_root_id())
 
691
        else:
 
692
            return self.get_inventory(revision_id)
 
693
 
348
694
 
349
695
    def revision_history(self):
350
 
        """Return sequence of revision hashes on to this branch."""
351
 
        raise NotImplementedError('revision_history is abstract')
 
696
        """Return sequence of revision hashes on to this branch.
 
697
 
 
698
        >>> ScratchBranch().revision_history()
 
699
        []
 
700
        """
 
701
        self.lock_read()
 
702
        try:
 
703
            return [l.rstrip('\r\n') for l in
 
704
                    self.controlfile('revision-history', 'r').readlines()]
 
705
        finally:
 
706
            self.unlock()
 
707
 
 
708
 
 
709
    def common_ancestor(self, other, self_revno=None, other_revno=None):
 
710
        """
 
711
        >>> import commit
 
712
        >>> sb = ScratchBranch(files=['foo', 'foo~'])
 
713
        >>> sb.common_ancestor(sb) == (None, None)
 
714
        True
 
715
        >>> commit.commit(sb, "Committing first revision", verbose=False)
 
716
        >>> sb.common_ancestor(sb)[0]
 
717
        1
 
718
        >>> clone = sb.clone()
 
719
        >>> commit.commit(sb, "Committing second revision", verbose=False)
 
720
        >>> sb.common_ancestor(sb)[0]
 
721
        2
 
722
        >>> sb.common_ancestor(clone)[0]
 
723
        1
 
724
        >>> commit.commit(clone, "Committing divergent second revision", 
 
725
        ...               verbose=False)
 
726
        >>> sb.common_ancestor(clone)[0]
 
727
        1
 
728
        >>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
 
729
        True
 
730
        >>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
 
731
        True
 
732
        >>> clone2 = sb.clone()
 
733
        >>> sb.common_ancestor(clone2)[0]
 
734
        2
 
735
        >>> sb.common_ancestor(clone2, self_revno=1)[0]
 
736
        1
 
737
        >>> sb.common_ancestor(clone2, other_revno=1)[0]
 
738
        1
 
739
        """
 
740
        my_history = self.revision_history()
 
741
        other_history = other.revision_history()
 
742
        if self_revno is None:
 
743
            self_revno = len(my_history)
 
744
        if other_revno is None:
 
745
            other_revno = len(other_history)
 
746
        indices = range(min((self_revno, other_revno)))
 
747
        indices.reverse()
 
748
        for r in indices:
 
749
            if my_history[r] == other_history[r]:
 
750
                return r+1, my_history[r]
 
751
        return None, None
 
752
 
352
753
 
353
754
    def revno(self):
354
755
        """Return current revision number for this branch.
358
759
        """
359
760
        return len(self.revision_history())
360
761
 
361
 
    def last_revision(self):
362
 
        """Return last patch hash, or None if no history."""
 
762
 
 
763
    def last_patch(self):
 
764
        """Return last patch hash, or None if no history.
 
765
        """
363
766
        ph = self.revision_history()
364
767
        if ph:
365
768
            return ph[-1]
366
769
        else:
367
770
            return None
368
771
 
369
 
    def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
370
 
        """Return a list of new revisions that would perfectly fit.
371
 
        
 
772
 
 
773
    def missing_revisions(self, other, stop_revision=None):
 
774
        """
372
775
        If self and other have not diverged, return a list of the revisions
373
776
        present in other, but missing from self.
374
777
 
392
795
        >>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
393
796
        >>> br1.missing_revisions(br2)
394
797
        Traceback (most recent call last):
395
 
        DivergedBranches: These branches have diverged.  Try merge.
 
798
        DivergedBranches: These branches have diverged.
396
799
        """
397
800
        self_history = self.revision_history()
398
801
        self_len = len(self_history)
405
808
 
406
809
        if stop_revision is None:
407
810
            stop_revision = other_len
408
 
        else:
409
 
            assert isinstance(stop_revision, int)
410
 
            if stop_revision > other_len:
411
 
                raise bzrlib.errors.NoSuchRevision(self, stop_revision)
 
811
        elif stop_revision > other_len:
 
812
            raise NoSuchRevision(self, stop_revision)
 
813
        
412
814
        return other_history[self_len:stop_revision]
413
 
    
 
815
 
 
816
 
414
817
    def update_revisions(self, other, stop_revision=None):
415
 
        """Pull in new perfect-fit revisions."""
416
 
        raise NotImplementedError('update_revisions is abstract')
417
 
 
418
 
    def pullable_revisions(self, other, stop_revision):
419
 
        raise NotImplementedError('pullable_revisions is abstract')
420
 
        
421
 
    def revision_id_to_revno(self, revision_id):
422
 
        """Given a revision id, return its revno"""
423
 
        if revision_id is None:
424
 
            return 0
425
 
        history = self.revision_history()
426
 
        try:
427
 
            return history.index(revision_id) + 1
428
 
        except ValueError:
429
 
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
430
 
 
431
 
    def get_rev_id(self, revno, history=None):
432
 
        """Find the revision id of the specified revno."""
433
 
        if revno == 0:
434
 
            return None
435
 
        if history is None:
436
 
            history = self.revision_history()
437
 
        elif revno <= 0 or revno > len(history):
438
 
            raise bzrlib.errors.NoSuchRevision(self, revno)
439
 
        return history[revno - 1]
 
818
        """Pull in all new revisions from other branch.
 
819
        
 
820
        >>> from bzrlib.commit import commit
 
821
        >>> bzrlib.trace.silent = True
 
822
        >>> br1 = ScratchBranch(files=['foo', 'bar'])
 
823
        >>> br1.add('foo')
 
824
        >>> br1.add('bar')
 
825
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
 
826
        >>> br2 = ScratchBranch()
 
827
        >>> br2.update_revisions(br1)
 
828
        Added 2 texts.
 
829
        Added 1 inventories.
 
830
        Added 1 revisions.
 
831
        >>> br2.revision_history()
 
832
        [u'REVISION-ID-1']
 
833
        >>> br2.update_revisions(br1)
 
834
        Added 0 texts.
 
835
        Added 0 inventories.
 
836
        Added 0 revisions.
 
837
        >>> br1.text_store.total_size() == br2.text_store.total_size()
 
838
        True
 
839
        """
 
840
        from bzrlib.progress import ProgressBar
 
841
 
 
842
        pb = ProgressBar()
 
843
 
 
844
        pb.update('comparing histories')
 
845
        revision_ids = self.missing_revisions(other, stop_revision)
 
846
 
 
847
        if hasattr(other.revision_store, "prefetch"):
 
848
            other.revision_store.prefetch(revision_ids)
 
849
        if hasattr(other.inventory_store, "prefetch"):
 
850
            inventory_ids = [other.get_revision(r).inventory_id
 
851
                             for r in revision_ids]
 
852
            other.inventory_store.prefetch(inventory_ids)
 
853
                
 
854
        revisions = []
 
855
        needed_texts = set()
 
856
        i = 0
 
857
        for rev_id in revision_ids:
 
858
            i += 1
 
859
            pb.update('fetching revision', i, len(revision_ids))
 
860
            rev = other.get_revision(rev_id)
 
861
            revisions.append(rev)
 
862
            inv = other.get_inventory(str(rev.inventory_id))
 
863
            for key, entry in inv.iter_entries():
 
864
                if entry.text_id is None:
 
865
                    continue
 
866
                if entry.text_id not in self.text_store:
 
867
                    needed_texts.add(entry.text_id)
 
868
 
 
869
        pb.clear()
 
870
                    
 
871
        count = self.text_store.copy_multi(other.text_store, needed_texts)
 
872
        print "Added %d texts." % count 
 
873
        inventory_ids = [ f.inventory_id for f in revisions ]
 
874
        count = self.inventory_store.copy_multi(other.inventory_store, 
 
875
                                                inventory_ids)
 
876
        print "Added %d inventories." % count 
 
877
        revision_ids = [ f.revision_id for f in revisions]
 
878
        count = self.revision_store.copy_multi(other.revision_store, 
 
879
                                               revision_ids)
 
880
        for revision_id in revision_ids:
 
881
            self.append_revision(revision_id)
 
882
        print "Added %d revisions." % count
 
883
                    
 
884
        
 
885
    def commit(self, *args, **kw):
 
886
        from bzrlib.commit import commit
 
887
        commit(self, *args, **kw)
 
888
        
 
889
 
 
890
    def lookup_revision(self, revision):
 
891
        """Return the revision identifier for a given revision information."""
 
892
        revno, info = self.get_revision_info(revision)
 
893
        return info
 
894
 
 
895
    def get_revision_info(self, revision):
 
896
        """Return (revno, revision id) for revision identifier.
 
897
 
 
898
        revision can be an integer, in which case it is assumed to be revno (though
 
899
            this will translate negative values into positive ones)
 
900
        revision can also be a string, in which case it is parsed for something like
 
901
            'date:' or 'revid:' etc.
 
902
        """
 
903
        if revision is None:
 
904
            return 0, None
 
905
        revno = None
 
906
        try:# Convert to int if possible
 
907
            revision = int(revision)
 
908
        except ValueError:
 
909
            pass
 
910
        revs = self.revision_history()
 
911
        if isinstance(revision, int):
 
912
            if revision == 0:
 
913
                return 0, None
 
914
            # Mabye we should do this first, but we don't need it if revision == 0
 
915
            if revision < 0:
 
916
                revno = len(revs) + revision + 1
 
917
            else:
 
918
                revno = revision
 
919
        elif isinstance(revision, basestring):
 
920
            for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
 
921
                if revision.startswith(prefix):
 
922
                    revno = func(self, revs, revision)
 
923
                    break
 
924
            else:
 
925
                raise BzrError('No namespace registered for string: %r' % revision)
 
926
 
 
927
        if revno is None or revno <= 0 or revno > len(revs):
 
928
            raise BzrError("no such revision %s" % revision)
 
929
        return revno, revs[revno-1]
 
930
 
 
931
    def _namespace_revno(self, revs, revision):
 
932
        """Lookup a revision by revision number"""
 
933
        assert revision.startswith('revno:')
 
934
        try:
 
935
            return int(revision[6:])
 
936
        except ValueError:
 
937
            return None
 
938
    REVISION_NAMESPACES['revno:'] = _namespace_revno
 
939
 
 
940
    def _namespace_revid(self, revs, revision):
 
941
        assert revision.startswith('revid:')
 
942
        try:
 
943
            return revs.index(revision[6:]) + 1
 
944
        except ValueError:
 
945
            return None
 
946
    REVISION_NAMESPACES['revid:'] = _namespace_revid
 
947
 
 
948
    def _namespace_last(self, revs, revision):
 
949
        assert revision.startswith('last:')
 
950
        try:
 
951
            offset = int(revision[5:])
 
952
        except ValueError:
 
953
            return None
 
954
        else:
 
955
            if offset <= 0:
 
956
                raise BzrError('You must supply a positive value for --revision last:XXX')
 
957
            return len(revs) - offset + 1
 
958
    REVISION_NAMESPACES['last:'] = _namespace_last
 
959
 
 
960
    def _namespace_tag(self, revs, revision):
 
961
        assert revision.startswith('tag:')
 
962
        raise BzrError('tag: namespace registered, but not implemented.')
 
963
    REVISION_NAMESPACES['tag:'] = _namespace_tag
 
964
 
 
965
    def _namespace_date(self, revs, revision):
 
966
        assert revision.startswith('date:')
 
967
        import datetime
 
968
        # Spec for date revisions:
 
969
        #   date:value
 
970
        #   value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
 
971
        #   it can also start with a '+/-/='. '+' says match the first
 
972
        #   entry after the given date. '-' is match the first entry before the date
 
973
        #   '=' is match the first entry after, but still on the given date.
 
974
        #
 
975
        #   +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
 
976
        #   -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
 
977
        #   =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
 
978
        #       May 13th, 2005 at 0:00
 
979
        #
 
980
        #   So the proper way of saying 'give me all entries for today' is:
 
981
        #       -r {date:+today}:{date:-tomorrow}
 
982
        #   The default is '=' when not supplied
 
983
        val = revision[5:]
 
984
        match_style = '='
 
985
        if val[:1] in ('+', '-', '='):
 
986
            match_style = val[:1]
 
987
            val = val[1:]
 
988
 
 
989
        today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
 
990
        if val.lower() == 'yesterday':
 
991
            dt = today - datetime.timedelta(days=1)
 
992
        elif val.lower() == 'today':
 
993
            dt = today
 
994
        elif val.lower() == 'tomorrow':
 
995
            dt = today + datetime.timedelta(days=1)
 
996
        else:
 
997
            import re
 
998
            # This should be done outside the function to avoid recompiling it.
 
999
            _date_re = re.compile(
 
1000
                    r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
 
1001
                    r'(,|T)?\s*'
 
1002
                    r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
 
1003
                )
 
1004
            m = _date_re.match(val)
 
1005
            if not m or (not m.group('date') and not m.group('time')):
 
1006
                raise BzrError('Invalid revision date %r' % revision)
 
1007
 
 
1008
            if m.group('date'):
 
1009
                year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
 
1010
            else:
 
1011
                year, month, day = today.year, today.month, today.day
 
1012
            if m.group('time'):
 
1013
                hour = int(m.group('hour'))
 
1014
                minute = int(m.group('minute'))
 
1015
                if m.group('second'):
 
1016
                    second = int(m.group('second'))
 
1017
                else:
 
1018
                    second = 0
 
1019
            else:
 
1020
                hour, minute, second = 0,0,0
 
1021
 
 
1022
            dt = datetime.datetime(year=year, month=month, day=day,
 
1023
                    hour=hour, minute=minute, second=second)
 
1024
        first = dt
 
1025
        last = None
 
1026
        reversed = False
 
1027
        if match_style == '-':
 
1028
            reversed = True
 
1029
        elif match_style == '=':
 
1030
            last = dt + datetime.timedelta(days=1)
 
1031
 
 
1032
        if reversed:
 
1033
            for i in range(len(revs)-1, -1, -1):
 
1034
                r = self.get_revision(revs[i])
 
1035
                # TODO: Handle timezone.
 
1036
                dt = datetime.datetime.fromtimestamp(r.timestamp)
 
1037
                if first >= dt and (last is None or dt >= last):
 
1038
                    return i+1
 
1039
        else:
 
1040
            for i in range(len(revs)):
 
1041
                r = self.get_revision(revs[i])
 
1042
                # TODO: Handle timezone.
 
1043
                dt = datetime.datetime.fromtimestamp(r.timestamp)
 
1044
                if first <= dt and (last is None or dt <= last):
 
1045
                    return i+1
 
1046
    REVISION_NAMESPACES['date:'] = _namespace_date
440
1047
 
441
1048
    def revision_tree(self, revision_id):
442
1049
        """Return Tree for a revision on this branch.
443
1050
 
444
1051
        `revision_id` may be None for the null revision, in which case
445
1052
        an `EmptyTree` is returned."""
446
 
        raise NotImplementedError('revision_tree is abstract')
 
1053
        # TODO: refactor this to use an existing revision object
 
1054
        # so we don't need to read it in twice.
 
1055
        if revision_id == None:
 
1056
            return EmptyTree()
 
1057
        else:
 
1058
            inv = self.get_revision_inventory(revision_id)
 
1059
            return RevisionTree(self.text_store, inv)
 
1060
 
447
1061
 
448
1062
    def working_tree(self):
449
 
        """Return a `Tree` for the working copy if this is a local branch."""
450
 
        raise NotImplementedError('working_tree is abstract')
 
1063
        """Return a `Tree` for the working copy."""
 
1064
        from workingtree import WorkingTree
 
1065
        return WorkingTree(self.base, self.read_working_inventory())
451
1066
 
452
 
    def pull(self, source, overwrite=False):
453
 
        raise NotImplementedError('pull is abstract')
454
1067
 
455
1068
    def basis_tree(self):
456
1069
        """Return `Tree` object for last revision.
457
1070
 
458
1071
        If there are no revisions yet, return an `EmptyTree`.
459
1072
        """
460
 
        return self.revision_tree(self.last_revision())
 
1073
        r = self.last_patch()
 
1074
        if r == None:
 
1075
            return EmptyTree()
 
1076
        else:
 
1077
            return RevisionTree(self.text_store, self.get_revision_inventory(r))
 
1078
 
 
1079
 
461
1080
 
462
1081
    def rename_one(self, from_rel, to_rel):
463
1082
        """Rename one file.
464
1083
 
465
1084
        This can change the directory or the filename or both.
466
1085
        """
467
 
        raise NotImplementedError('rename_one is abstract')
 
1086
        self.lock_write()
 
1087
        try:
 
1088
            tree = self.working_tree()
 
1089
            inv = tree.inventory
 
1090
            if not tree.has_filename(from_rel):
 
1091
                raise BzrError("can't rename: old working file %r does not exist" % from_rel)
 
1092
            if tree.has_filename(to_rel):
 
1093
                raise BzrError("can't rename: new working file %r already exists" % to_rel)
 
1094
 
 
1095
            file_id = inv.path2id(from_rel)
 
1096
            if file_id == None:
 
1097
                raise BzrError("can't rename: old name %r is not versioned" % from_rel)
 
1098
 
 
1099
            if inv.path2id(to_rel):
 
1100
                raise BzrError("can't rename: new name %r is already versioned" % to_rel)
 
1101
 
 
1102
            to_dir, to_tail = os.path.split(to_rel)
 
1103
            to_dir_id = inv.path2id(to_dir)
 
1104
            if to_dir_id == None and to_dir != '':
 
1105
                raise BzrError("can't determine destination directory id for %r" % to_dir)
 
1106
 
 
1107
            mutter("rename_one:")
 
1108
            mutter("  file_id    {%s}" % file_id)
 
1109
            mutter("  from_rel   %r" % from_rel)
 
1110
            mutter("  to_rel     %r" % to_rel)
 
1111
            mutter("  to_dir     %r" % to_dir)
 
1112
            mutter("  to_dir_id  {%s}" % to_dir_id)
 
1113
 
 
1114
            inv.rename(file_id, to_dir_id, to_tail)
 
1115
 
 
1116
            print "%s => %s" % (from_rel, to_rel)
 
1117
 
 
1118
            from_abs = self.abspath(from_rel)
 
1119
            to_abs = self.abspath(to_rel)
 
1120
            try:
 
1121
                os.rename(from_abs, to_abs)
 
1122
            except OSError, e:
 
1123
                raise BzrError("failed to rename %r to %r: %s"
 
1124
                        % (from_abs, to_abs, e[1]),
 
1125
                        ["rename rolled back"])
 
1126
 
 
1127
            self._write_inventory(inv)
 
1128
        finally:
 
1129
            self.unlock()
 
1130
 
468
1131
 
469
1132
    def move(self, from_paths, to_name):
470
1133
        """Rename files.
476
1139
 
477
1140
        Note that to_name is only the last component of the new name;
478
1141
        this doesn't change the directory.
479
 
 
480
 
        This returns a list of (from_path, to_path) pairs for each
481
 
        entry that is moved.
482
 
        """
483
 
        raise NotImplementedError('move is abstract')
484
 
 
485
 
    def get_parent(self):
486
 
        """Return the parent location of the branch.
487
 
 
488
 
        This is the default location for push/pull/missing.  The usual
489
 
        pattern is that the user can override it by specifying a
490
 
        location.
491
 
        """
492
 
        raise NotImplementedError('get_parent is abstract')
493
 
 
494
 
    def get_push_location(self):
495
 
        """Return the None or the location to push this branch to."""
496
 
        raise NotImplementedError('get_push_location is abstract')
497
 
 
498
 
    def set_push_location(self, location):
499
 
        """Set a new push location for this branch."""
500
 
        raise NotImplementedError('set_push_location is abstract')
501
 
 
502
 
    def set_parent(self, url):
503
 
        raise NotImplementedError('set_parent is abstract')
504
 
 
505
 
    def check_revno(self, revno):
506
 
        """\
507
 
        Check whether a revno corresponds to any revision.
508
 
        Zero (the NULL revision) is considered valid.
509
 
        """
510
 
        if revno != 0:
511
 
            self.check_real_revno(revno)
512
 
            
513
 
    def check_real_revno(self, revno):
514
 
        """\
515
 
        Check whether a revno corresponds to a real revision.
516
 
        Zero (the NULL revision) is considered invalid
517
 
        """
518
 
        if revno < 1 or revno > self.revno():
519
 
            raise InvalidRevisionNumber(revno)
520
 
        
521
 
    def sign_revision(self, revision_id, gpg_strategy):
522
 
        raise NotImplementedError('sign_revision is abstract')
523
 
 
524
 
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
525
 
        raise NotImplementedError('store_revision_signature is abstract')
526
 
 
527
 
 
528
 
class BzrBranchFormat(object):
529
 
    """An encapsulation of the initialization and open routines for a format.
530
 
 
531
 
    Formats provide three things:
532
 
     * An initialization routine,
533
 
     * a format string,
534
 
     * an open routine.
535
 
 
536
 
    Formats are placed in an dict by their format string for reference 
537
 
    during branch opening. Its not required that these be instances, they
538
 
    can be classes themselves with class methods - it simply depends on 
539
 
    whether state is needed for a given format or not.
540
 
 
541
 
    Once a format is deprecated, just deprecate the initialize and open
542
 
    methods on the format class. Do not deprecate the object, as the 
543
 
    object will be created every time regardless.
544
 
    """
545
 
 
546
 
    _formats = {}
547
 
    """The known formats."""
548
 
 
549
 
    @classmethod
550
 
    def find_format(klass, transport):
551
 
        """Return the format registered for URL."""
552
 
        try:
553
 
            format_string = transport.get(".bzr/branch-format").read()
554
 
            return klass._formats[format_string]
555
 
        except NoSuchFile:
556
 
            raise NotBranchError(path=transport.base)
557
 
        except KeyError:
558
 
            raise errors.UnknownFormatError(format_string)
559
 
 
560
 
    def get_format_string(self):
561
 
        """Return the ASCII format string that identifies this format."""
562
 
        raise NotImplementedError(self.get_format_string)
563
 
 
564
 
    def _find_modes(self, t):
565
 
        """Determine the appropriate modes for files and directories.
566
 
        
567
 
        FIXME: When this merges into, or from storage,
568
 
        this code becomes delgatable to a LockableFiles instance.
569
 
 
570
 
        For now its cribbed and returns (dir_mode, file_mode)
571
 
        """
572
 
        try:
573
 
            st = t.stat('.')
574
 
        except errors.TransportNotPossible:
575
 
            dir_mode = 0755
576
 
            file_mode = 0644
577
 
        else:
578
 
            dir_mode = st.st_mode & 07777
579
 
            # Remove the sticky and execute bits for files
580
 
            file_mode = dir_mode & ~07111
581
 
        if not BzrBranch._set_dir_mode:
582
 
            dir_mode = None
583
 
        if not BzrBranch._set_file_mode:
584
 
            file_mode = None
585
 
        return dir_mode, file_mode
586
 
 
587
 
    def initialize(self, url):
588
 
        """Create a branch of this format at url and return an open branch."""
589
 
        t = get_transport(url)
590
 
        from bzrlib.inventory import Inventory
591
 
        from bzrlib.weavefile import write_weave_v5
592
 
        from bzrlib.weave import Weave
593
 
        
594
 
        # Create an empty inventory
595
 
        sio = StringIO()
596
 
        # if we want per-tree root ids then this is the place to set
597
 
        # them; they're not needed for now and so ommitted for
598
 
        # simplicity.
599
 
        bzrlib.xml5.serializer_v5.write_inventory(Inventory(), sio)
600
 
        empty_inv = sio.getvalue()
601
 
        sio = StringIO()
602
 
        bzrlib.weavefile.write_weave_v5(Weave(), sio)
603
 
        empty_weave = sio.getvalue()
604
 
 
605
 
        # Since we don't have a .bzr directory, inherit the
606
 
        # mode from the root directory
607
 
        dir_mode, file_mode = self._find_modes(t)
608
 
 
609
 
        t.mkdir('.bzr', mode=dir_mode)
610
 
        control = t.clone('.bzr')
611
 
        dirs = ['revision-store', 'weaves']
612
 
        files = [('README', 
613
 
            StringIO("This is a Bazaar-NG control directory.\n"
614
 
            "Do not change any files in this directory.\n")),
615
 
            ('branch-format', StringIO(self.get_format_string())),
616
 
            ('revision-history', StringIO('')),
617
 
            ('branch-name', StringIO('')),
618
 
            ('branch-lock', StringIO('')),
619
 
            ('pending-merges', StringIO('')),
620
 
            ('inventory', StringIO(empty_inv)),
621
 
            ('inventory.weave', StringIO(empty_weave)),
622
 
            ('ancestry.weave', StringIO(empty_weave))
623
 
        ]
624
 
        control.mkdir_multi(dirs, mode=dir_mode)
625
 
        control.put_multi(files, mode=file_mode)
626
 
        mutter('created control directory in ' + t.base)
627
 
        return BzrBranch(t, format=self)
628
 
 
629
 
    def is_supported(self):
630
 
        """Is this format supported?
631
 
 
632
 
        Supported formats can be initialized and opened.
633
 
        Unsupported formats may not support initialization or committing or 
634
 
        some other features depending on the reason for not being supported.
635
 
        """
636
 
        return True
637
 
 
638
 
    def open(self, transport):
639
 
        """Fill out the data in branch for the branch at url."""
640
 
        return BzrBranch(transport, format=self)
641
 
 
642
 
    @classmethod
643
 
    def register_format(klass, format):
644
 
        klass._formats[format.get_format_string()] = format
645
 
 
646
 
    @classmethod
647
 
    def unregister_format(klass, format):
648
 
        assert klass._formats[format.get_format_string()] is format
649
 
        del klass._formats[format.get_format_string()]
650
 
 
651
 
 
652
 
class BzrBranchFormat4(BzrBranchFormat):
653
 
    """Bzr branch format 4.
654
 
 
655
 
    This format has:
656
 
     - flat stores
657
 
     - TextStores for texts, inventories,revisions.
658
 
 
659
 
    This format is deprecated: it indexes texts using a text it which is
660
 
    removed in format 5; write support for this format has been removed.
661
 
    """
662
 
 
663
 
    def get_format_string(self):
664
 
        """See BzrBranchFormat.get_format_string()."""
665
 
        return BZR_BRANCH_FORMAT_4
666
 
 
667
 
    def initialize(self, url):
668
 
        """Format 4 branches cannot be created."""
669
 
        raise UninitializableFormat(self)
670
 
 
671
 
    def is_supported(self):
672
 
        """Format 4 is not supported.
673
 
 
674
 
        It is not supported because the model changed from 4 to 5 and the
675
 
        conversion logic is expensive - so doing it on the fly was not 
676
 
        feasible.
677
 
        """
678
 
        return False
679
 
 
680
 
 
681
 
class BzrBranchFormat5(BzrBranchFormat):
682
 
    """Bzr branch format 5.
683
 
 
684
 
    This format has:
685
 
     - weaves for file texts and inventory
686
 
     - flat stores
687
 
     - TextStores for revisions and signatures.
688
 
    """
689
 
 
690
 
    def get_format_string(self):
691
 
        """See BzrBranchFormat.get_format_string()."""
692
 
        return BZR_BRANCH_FORMAT_5
693
 
 
694
 
 
695
 
class BzrBranchFormat6(BzrBranchFormat):
696
 
    """Bzr branch format 6.
697
 
 
698
 
    This format has:
699
 
     - weaves for file texts and inventory
700
 
     - hash subdirectory based stores.
701
 
     - TextStores for revisions and signatures.
702
 
    """
703
 
 
704
 
    def get_format_string(self):
705
 
        """See BzrBranchFormat.get_format_string()."""
706
 
        return BZR_BRANCH_FORMAT_6
707
 
 
708
 
 
709
 
BzrBranchFormat.register_format(BzrBranchFormat4())
710
 
BzrBranchFormat.register_format(BzrBranchFormat5())
711
 
BzrBranchFormat.register_format(BzrBranchFormat6())
712
 
 
713
 
 
714
 
class BzrBranch(Branch):
715
 
    """A branch stored in the actual filesystem.
716
 
 
717
 
    Note that it's "local" in the context of the filesystem; it doesn't
718
 
    really matter if it's on an nfs/smb/afs/coda/... share, as long as
719
 
    it's writable, and can be accessed via the normal filesystem API.
720
 
 
721
 
    _lock_mode
722
 
        None, or 'r' or 'w'
723
 
 
724
 
    _lock_count
725
 
        If _lock_mode is true, a positive count of the number of times the
726
 
        lock has been taken.
727
 
 
728
 
    _lock
729
 
        Lock object from bzrlib.lock.
730
 
    """
731
 
    # We actually expect this class to be somewhat short-lived; part of its
732
 
    # purpose is to try to isolate what bits of the branch logic are tied to
733
 
    # filesystem access, so that in a later step, we can extricate them to
734
 
    # a separarte ("storage") class.
735
 
    _lock_mode = None
736
 
    _lock_count = None
737
 
    _lock = None
738
 
    _inventory_weave = None
739
 
    # If set to False (by a plugin, etc) BzrBranch will not set the
740
 
    # mode on created files or directories
741
 
    _set_file_mode = True
742
 
    _set_dir_mode = True
743
 
    
744
 
    # Map some sort of prefix into a namespace
745
 
    # stuff like "revno:10", "revid:", etc.
746
 
    # This should match a prefix with a function which accepts
747
 
    REVISION_NAMESPACES = {}
748
 
 
749
 
    def push_stores(self, branch_to):
750
 
        """See Branch.push_stores."""
751
 
        if (not isinstance(self._branch_format, BzrBranchFormat4) or
752
 
            self._branch_format != branch_to._branch_format):
753
 
            from bzrlib.fetch import greedy_fetch
754
 
            mutter("Using fetch logic to push between %s(%s) and %s(%s)",
755
 
                   self, self._branch_format, branch_to, branch_to._branch_format)
756
 
            greedy_fetch(to_branch=branch_to, from_branch=self,
757
 
                         revision=self.last_revision())
758
 
            return
759
 
 
760
 
        # format 4 to format 4 logic only.
761
 
        store_pairs = ((self.text_store,      branch_to.text_store),
762
 
                       (self.inventory_store, branch_to.inventory_store),
763
 
                       (self.revision_store,  branch_to.revision_store))
764
 
        try:
765
 
            for from_store, to_store in store_pairs: 
766
 
                copy_all(from_store, to_store)
767
 
        except UnlistableStore:
768
 
            raise UnlistableBranch(from_store)
769
 
 
770
 
    def __init__(self, transport, init=deprecated_nonce,
771
 
                 relax_version_check=deprecated_nonce, format=None):
772
 
        """Create new branch object at a particular location.
773
 
 
774
 
        transport -- A Transport object, defining how to access files.
775
 
        
776
 
        init -- If True, create new control files in a previously
777
 
             unversioned directory.  If False, the branch must already
778
 
             be versioned.
779
 
 
780
 
        relax_version_check -- If true, the usual check for the branch
781
 
            version is not applied.  This is intended only for
782
 
            upgrade/recovery type use; it's not guaranteed that
783
 
            all operations will work on old format branches.
784
 
 
785
 
        In the test suite, creation of new trees is tested using the
786
 
        `ScratchBranch` class.
787
 
        """
788
 
        assert isinstance(transport, Transport), \
789
 
            "%r is not a Transport" % transport
790
 
        self._transport = transport
791
 
        if deprecated_passed(init):
792
 
            warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
793
 
                 "deprecated as of bzr 0.8. Please use Branch.initialize().",
794
 
                 DeprecationWarning)
795
 
            if init:
796
 
                # this is slower than before deprecation, oh well never mind.
797
 
                # -> its deprecated.
798
 
                self._initialize(transport.base)
799
 
        self._find_modes()
800
 
        self._check_format(format)
801
 
        if deprecated_passed(relax_version_check):
802
 
            warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
803
 
                 "relax_version_check parameter is deprecated as of bzr 0.8. "
804
 
                 "Please use Branch.open_downlevel, or a BzrBranchFormat's "
805
 
                 "open() method.", DeprecationWarning)
806
 
            if (not relax_version_check
807
 
                and not self._branch_format.is_supported()):
808
 
                raise errors.UnsupportedFormatError(
809
 
                        'sorry, branch format %r not supported' % fmt,
810
 
                        ['use a different bzr version',
811
 
                         'or remove the .bzr directory'
812
 
                         ' and "bzr init" again'])
813
 
 
814
 
        def get_store(name, compressed=True, prefixed=False):
815
 
            relpath = self._rel_controlfilename(safe_unicode(name))
816
 
            store = TextStore(self._transport.clone(relpath),
817
 
                              dir_mode=self._dir_mode,
818
 
                              file_mode=self._file_mode,
819
 
                              prefixed=prefixed,
820
 
                              compressed=compressed)
821
 
            return store
822
 
 
823
 
        def get_weave(name, prefixed=False):
824
 
            relpath = self._rel_controlfilename(unicode(name))
825
 
            ws = WeaveStore(self._transport.clone(relpath),
826
 
                            prefixed=prefixed,
827
 
                            dir_mode=self._dir_mode,
828
 
                            file_mode=self._file_mode)
829
 
            if self._transport.should_cache():
830
 
                ws.enable_cache = True
831
 
            return ws
832
 
 
833
 
        if isinstance(self._branch_format, BzrBranchFormat4):
834
 
            self.inventory_store = get_store('inventory-store')
835
 
            self.text_store = get_store('text-store')
836
 
            self.revision_store = get_store('revision-store')
837
 
        elif isinstance(self._branch_format, BzrBranchFormat5):
838
 
            self.control_weaves = get_weave(u'')
839
 
            self.weave_store = get_weave(u'weaves')
840
 
            self.revision_store = get_store(u'revision-store', compressed=False)
841
 
        elif isinstance(self._branch_format, BzrBranchFormat6):
842
 
            self.control_weaves = get_weave(u'')
843
 
            self.weave_store = get_weave(u'weaves', prefixed=True)
844
 
            self.revision_store = get_store(u'revision-store', compressed=False,
845
 
                                            prefixed=True)
846
 
        self.revision_store.register_suffix('sig')
847
 
        self._transaction = None
848
 
 
849
 
    @staticmethod
850
 
    def _initialize(base):
851
 
        """Create a bzr branch in the latest format."""
852
 
        return BzrBranchFormat6().initialize(base)
853
 
 
854
 
    def __str__(self):
855
 
        return '%s(%r)' % (self.__class__.__name__, self._transport.base)
856
 
 
857
 
    __repr__ = __str__
858
 
 
859
 
    def __del__(self):
860
 
        if self._lock_mode or self._lock:
861
 
            # XXX: This should show something every time, and be suitable for
862
 
            # headless operation and embedding
863
 
            warn("branch %r was not explicitly unlocked" % self)
864
 
            self._lock.unlock()
865
 
 
866
 
        # TODO: It might be best to do this somewhere else,
867
 
        # but it is nice for a Branch object to automatically
868
 
        # cache it's information.
869
 
        # Alternatively, we could have the Transport objects cache requests
870
 
        # See the earlier discussion about how major objects (like Branch)
871
 
        # should never expect their __del__ function to run.
872
 
        if hasattr(self, 'cache_root') and self.cache_root is not None:
873
 
            try:
874
 
                shutil.rmtree(self.cache_root)
875
 
            except:
876
 
                pass
877
 
            self.cache_root = None
878
 
 
879
 
    def _get_base(self):
880
 
        if self._transport:
881
 
            return self._transport.base
882
 
        return None
883
 
 
884
 
    base = property(_get_base, doc="The URL for the root of this branch.")
885
 
 
886
 
    def _finish_transaction(self):
887
 
        """Exit the current transaction."""
888
 
        if self._transaction is None:
889
 
            raise errors.LockError('Branch %s is not in a transaction' %
890
 
                                   self)
891
 
        transaction = self._transaction
892
 
        self._transaction = None
893
 
        transaction.finish()
894
 
 
895
 
    def get_transaction(self):
896
 
        """See Branch.get_transaction."""
897
 
        if self._transaction is None:
898
 
            return transactions.PassThroughTransaction()
899
 
        else:
900
 
            return self._transaction
901
 
 
902
 
    def _set_transaction(self, new_transaction):
903
 
        """Set a new active transaction."""
904
 
        if self._transaction is not None:
905
 
            raise errors.LockError('Branch %s is in a transaction already.' %
906
 
                                   self)
907
 
        self._transaction = new_transaction
908
 
 
909
 
    def lock_write(self):
910
 
        #mutter("lock write: %s (%s)", self, self._lock_count)
911
 
        # TODO: Upgrade locking to support using a Transport,
912
 
        # and potentially a remote locking protocol
913
 
        if self._lock_mode:
914
 
            if self._lock_mode != 'w':
915
 
                raise LockError("can't upgrade to a write lock from %r" %
916
 
                                self._lock_mode)
917
 
            self._lock_count += 1
918
 
        else:
919
 
            self._lock = self._transport.lock_write(
920
 
                    self._rel_controlfilename('branch-lock'))
921
 
            self._lock_mode = 'w'
922
 
            self._lock_count = 1
923
 
            self._set_transaction(transactions.PassThroughTransaction())
924
 
 
925
 
    def lock_read(self):
926
 
        #mutter("lock read: %s (%s)", self, self._lock_count)
927
 
        if self._lock_mode:
928
 
            assert self._lock_mode in ('r', 'w'), \
929
 
                   "invalid lock mode %r" % self._lock_mode
930
 
            self._lock_count += 1
931
 
        else:
932
 
            self._lock = self._transport.lock_read(
933
 
                    self._rel_controlfilename('branch-lock'))
934
 
            self._lock_mode = 'r'
935
 
            self._lock_count = 1
936
 
            self._set_transaction(transactions.ReadOnlyTransaction())
937
 
            # 5K may be excessive, but hey, its a knob.
938
 
            self.get_transaction().set_cache_size(5000)
939
 
                        
940
 
    def unlock(self):
941
 
        #mutter("unlock: %s (%s)", self, self._lock_count)
942
 
        if not self._lock_mode:
943
 
            raise LockError('branch %r is not locked' % (self))
944
 
 
945
 
        if self._lock_count > 1:
946
 
            self._lock_count -= 1
947
 
        else:
948
 
            self._finish_transaction()
949
 
            self._lock.unlock()
950
 
            self._lock = None
951
 
            self._lock_mode = self._lock_count = None
952
 
 
953
 
    def abspath(self, name):
954
 
        """See Branch.abspath."""
955
 
        return self._transport.abspath(name)
956
 
 
957
 
    def _rel_controlfilename(self, file_or_path):
958
 
        if not isinstance(file_or_path, basestring):
959
 
            file_or_path = u'/'.join(file_or_path)
960
 
        if file_or_path == '':
961
 
            return bzrlib.BZRDIR
962
 
        return bzrlib.transport.urlescape(bzrlib.BZRDIR + u'/' + file_or_path)
963
 
 
964
 
    def controlfilename(self, file_or_path):
965
 
        """See Branch.controlfilename."""
966
 
        return self._transport.abspath(self._rel_controlfilename(file_or_path))
967
 
 
968
 
    def controlfile(self, file_or_path, mode='r'):
969
 
        """See Branch.controlfile."""
970
 
        import codecs
971
 
 
972
 
        relpath = self._rel_controlfilename(file_or_path)
973
 
        #TODO: codecs.open() buffers linewise, so it was overloaded with
974
 
        # a much larger buffer, do we need to do the same for getreader/getwriter?
975
 
        if mode == 'rb': 
976
 
            return self._transport.get(relpath)
977
 
        elif mode == 'wb':
978
 
            raise BzrError("Branch.controlfile(mode='wb') is not supported, use put_controlfiles")
979
 
        elif mode == 'r':
980
 
            # XXX: Do we really want errors='replace'?   Perhaps it should be
981
 
            # an error, or at least reported, if there's incorrectly-encoded
982
 
            # data inside a file.
983
 
            # <https://launchpad.net/products/bzr/+bug/3823>
984
 
            return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
985
 
        elif mode == 'w':
986
 
            raise BzrError("Branch.controlfile(mode='w') is not supported, use put_controlfiles")
987
 
        else:
988
 
            raise BzrError("invalid controlfile mode %r" % mode)
989
 
 
990
 
    def put_controlfile(self, path, f, encode=True):
991
 
        """See Branch.put_controlfile."""
992
 
        self.put_controlfiles([(path, f)], encode=encode)
993
 
 
994
 
    def put_controlfiles(self, files, encode=True):
995
 
        """See Branch.put_controlfiles."""
996
 
        import codecs
997
 
        ctrl_files = []
998
 
        for path, f in files:
999
 
            if encode:
1000
 
                if isinstance(f, basestring):
1001
 
                    f = f.encode('utf-8', 'replace')
1002
 
                else:
1003
 
                    f = codecs.getwriter('utf-8')(f, errors='replace')
1004
 
            path = self._rel_controlfilename(path)
1005
 
            ctrl_files.append((path, f))
1006
 
        self._transport.put_multi(ctrl_files, mode=self._file_mode)
1007
 
 
1008
 
    def _find_modes(self, path=None):
1009
 
        """Determine the appropriate modes for files and directories."""
1010
 
        try:
1011
 
            if path is None:
1012
 
                path = self._rel_controlfilename('')
1013
 
            st = self._transport.stat(path)
1014
 
        except errors.TransportNotPossible:
1015
 
            self._dir_mode = 0755
1016
 
            self._file_mode = 0644
1017
 
        else:
1018
 
            self._dir_mode = st.st_mode & 07777
1019
 
            # Remove the sticky and execute bits for files
1020
 
            self._file_mode = self._dir_mode & ~07111
1021
 
        if not self._set_dir_mode:
1022
 
            self._dir_mode = None
1023
 
        if not self._set_file_mode:
1024
 
            self._file_mode = None
1025
 
 
1026
 
    def _check_format(self, format):
1027
 
        """Identify the branch format if needed.
1028
 
 
1029
 
        The format is stored as a reference to the format object in
1030
 
        self._branch_format for code that needs to check it later.
1031
 
 
1032
 
        The format parameter is either None or the branch format class
1033
 
        used to open this branch.
1034
 
        """
1035
 
        if format is None:
1036
 
            format = BzrBranchFormat.find_format(self._transport)
1037
 
        self._branch_format = format
1038
 
        mutter("got branch format %s", self._branch_format)
1039
 
 
1040
 
    @needs_read_lock
1041
 
    def get_root_id(self):
1042
 
        """See Branch.get_root_id."""
1043
 
        inv = self.get_inventory(self.last_revision())
1044
 
        return inv.root.file_id
1045
 
 
1046
 
    @needs_read_lock
1047
 
    def print_file(self, file, revision_id):
1048
 
        """See Branch.print_file."""
1049
 
        tree = self.revision_tree(revision_id)
1050
 
        # use inventory as it was in that revision
1051
 
        file_id = tree.inventory.path2id(file)
1052
 
        if not file_id:
1053
 
            try:
1054
 
                revno = self.revision_id_to_revno(revision_id)
1055
 
            except errors.NoSuchRevision:
1056
 
                # TODO: This should not be BzrError,
1057
 
                # but NoSuchFile doesn't fit either
1058
 
                raise BzrError('%r is not present in revision %s' 
1059
 
                                % (file, revision_id))
1060
 
            else:
1061
 
                raise BzrError('%r is not present in revision %s'
1062
 
                                % (file, revno))
1063
 
        tree.print_file(file_id)
1064
 
 
1065
 
    @needs_write_lock
1066
 
    def append_revision(self, *revision_ids):
1067
 
        """See Branch.append_revision."""
1068
 
        for revision_id in revision_ids:
1069
 
            mutter("add {%s} to revision-history" % revision_id)
1070
 
        rev_history = self.revision_history()
1071
 
        rev_history.extend(revision_ids)
1072
 
        self.set_revision_history(rev_history)
1073
 
 
1074
 
    @needs_write_lock
1075
 
    def set_revision_history(self, rev_history):
1076
 
        """See Branch.set_revision_history."""
1077
 
        old_revision = self.last_revision()
1078
 
        new_revision = rev_history[-1]
1079
 
        self.put_controlfile('revision-history', '\n'.join(rev_history))
1080
 
        try:
1081
 
            self.working_tree().set_last_revision(new_revision, old_revision)
1082
 
        except NoWorkingTree:
1083
 
            mutter('Unable to set_last_revision without a working tree.')
1084
 
 
1085
 
    def has_revision(self, revision_id):
1086
 
        """See Branch.has_revision."""
1087
 
        return (revision_id is None
1088
 
                or self.revision_store.has_id(revision_id))
1089
 
 
1090
 
    @needs_read_lock
1091
 
    def _get_revision_xml_file(self, revision_id):
1092
 
        if not revision_id or not isinstance(revision_id, basestring):
1093
 
            raise InvalidRevisionId(revision_id=revision_id, branch=self)
1094
 
        try:
1095
 
            return self.revision_store.get(revision_id)
1096
 
        except (IndexError, KeyError):
1097
 
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
1098
 
 
1099
 
    def get_revision_xml(self, revision_id):
1100
 
        """See Branch.get_revision_xml."""
1101
 
        return self._get_revision_xml_file(revision_id).read()
1102
 
 
1103
 
    def get_revision(self, revision_id):
1104
 
        """See Branch.get_revision."""
1105
 
        xml_file = self._get_revision_xml_file(revision_id)
1106
 
 
1107
 
        try:
1108
 
            r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
1109
 
        except SyntaxError, e:
1110
 
            raise bzrlib.errors.BzrError('failed to unpack revision_xml',
1111
 
                                         [revision_id,
1112
 
                                          str(e)])
1113
 
            
1114
 
        assert r.revision_id == revision_id
1115
 
        return r
1116
 
 
1117
 
    def get_revision_sha1(self, revision_id):
1118
 
        """See Branch.get_revision_sha1."""
1119
 
        # In the future, revision entries will be signed. At that
1120
 
        # point, it is probably best *not* to include the signature
1121
 
        # in the revision hash. Because that lets you re-sign
1122
 
        # the revision, (add signatures/remove signatures) and still
1123
 
        # have all hash pointers stay consistent.
1124
 
        # But for now, just hash the contents.
1125
 
        return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
1126
 
 
1127
 
    def get_ancestry(self, revision_id):
1128
 
        """See Branch.get_ancestry."""
1129
 
        if revision_id is None:
1130
 
            return [None]
1131
 
        w = self._get_inventory_weave()
1132
 
        return [None] + map(w.idx_to_name,
1133
 
                            w.inclusions([w.lookup(revision_id)]))
1134
 
 
1135
 
    def _get_inventory_weave(self):
1136
 
        return self.control_weaves.get_weave('inventory',
1137
 
                                             self.get_transaction())
1138
 
 
1139
 
    def get_inventory(self, revision_id):
1140
 
        """See Branch.get_inventory."""
1141
 
        xml = self.get_inventory_xml(revision_id)
1142
 
        return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
1143
 
 
1144
 
    def get_inventory_xml(self, revision_id):
1145
 
        """See Branch.get_inventory_xml."""
1146
 
        try:
1147
 
            assert isinstance(revision_id, basestring), type(revision_id)
1148
 
            iw = self._get_inventory_weave()
1149
 
            return iw.get_text(iw.lookup(revision_id))
1150
 
        except IndexError:
1151
 
            raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
1152
 
 
1153
 
    def get_inventory_sha1(self, revision_id):
1154
 
        """See Branch.get_inventory_sha1."""
1155
 
        return self.get_revision(revision_id).inventory_sha1
1156
 
 
1157
 
    def get_revision_inventory(self, revision_id):
1158
 
        """See Branch.get_revision_inventory."""
1159
 
        # TODO: Unify this with get_inventory()
1160
 
        # bzr 0.0.6 and later imposes the constraint that the inventory_id
1161
 
        # must be the same as its revision, so this is trivial.
1162
 
        if revision_id == None:
1163
 
            # This does not make sense: if there is no revision,
1164
 
            # then it is the current tree inventory surely ?!
1165
 
            # and thus get_root_id() is something that looks at the last
1166
 
            # commit on the branch, and the get_root_id is an inventory check.
1167
 
            raise NotImplementedError
1168
 
            # return Inventory(self.get_root_id())
1169
 
        else:
1170
 
            return self.get_inventory(revision_id)
1171
 
 
1172
 
    @needs_read_lock
1173
 
    def revision_history(self):
1174
 
        """See Branch.revision_history."""
1175
 
        transaction = self.get_transaction()
1176
 
        history = transaction.map.find_revision_history()
1177
 
        if history is not None:
1178
 
            mutter("cache hit for revision-history in %s", self)
1179
 
            return list(history)
1180
 
        history = [l.rstrip('\r\n') for l in
1181
 
                self.controlfile('revision-history', 'r').readlines()]
1182
 
        transaction.map.add_revision_history(history)
1183
 
        # this call is disabled because revision_history is 
1184
 
        # not really an object yet, and the transaction is for objects.
1185
 
        # transaction.register_clean(history, precious=True)
1186
 
        return list(history)
1187
 
 
1188
 
    def update_revisions(self, other, stop_revision=None):
1189
 
        """See Branch.update_revisions."""
1190
 
        from bzrlib.fetch import greedy_fetch
1191
 
        if stop_revision is None:
1192
 
            stop_revision = other.last_revision()
1193
 
        ### Should this be checking is_ancestor instead of revision_history?
1194
 
        if (stop_revision is not None and 
1195
 
            stop_revision in self.revision_history()):
1196
 
            return
1197
 
        greedy_fetch(to_branch=self, from_branch=other,
1198
 
                     revision=stop_revision)
1199
 
        pullable_revs = self.pullable_revisions(other, stop_revision)
1200
 
        if len(pullable_revs) > 0:
1201
 
            self.append_revision(*pullable_revs)
1202
 
 
1203
 
    def pullable_revisions(self, other, stop_revision):
1204
 
        """See Branch.pullable_revisions."""
1205
 
        other_revno = other.revision_id_to_revno(stop_revision)
1206
 
        try:
1207
 
            return self.missing_revisions(other, other_revno)
1208
 
        except DivergedBranches, e:
1209
 
            try:
1210
 
                pullable_revs = get_intervening_revisions(self.last_revision(),
1211
 
                                                          stop_revision, self)
1212
 
                assert self.last_revision() not in pullable_revs
1213
 
                return pullable_revs
1214
 
            except bzrlib.errors.NotAncestor:
1215
 
                if is_ancestor(self.last_revision(), stop_revision, self):
1216
 
                    return []
1217
 
                else:
1218
 
                    raise e
1219
 
        
1220
 
    def revision_tree(self, revision_id):
1221
 
        """See Branch.revision_tree."""
1222
 
        # TODO: refactor this to use an existing revision object
1223
 
        # so we don't need to read it in twice.
1224
 
        if revision_id == None or revision_id == NULL_REVISION:
1225
 
            return EmptyTree()
1226
 
        else:
1227
 
            inv = self.get_revision_inventory(revision_id)
1228
 
            return RevisionTree(self, inv, revision_id)
1229
 
 
1230
 
    def basis_tree(self):
1231
 
        """See Branch.basis_tree."""
1232
 
        try:
1233
 
            revision_id = self.revision_history()[-1]
1234
 
            xml = self.working_tree().read_basis_inventory(revision_id)
1235
 
            inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
1236
 
            return RevisionTree(self, inv, revision_id)
1237
 
        except (IndexError, NoSuchFile, NoWorkingTree), e:
1238
 
            return self.revision_tree(self.last_revision())
1239
 
 
1240
 
    def working_tree(self):
1241
 
        """See Branch.working_tree."""
1242
 
        from bzrlib.workingtree import WorkingTree
1243
 
        if self._transport.base.find('://') != -1:
1244
 
            raise NoWorkingTree(self.base)
1245
 
        return WorkingTree(self.base, branch=self)
1246
 
 
1247
 
    @needs_write_lock
1248
 
    def pull(self, source, overwrite=False):
1249
 
        """See Branch.pull."""
1250
 
        source.lock_read()
1251
 
        try:
1252
 
            old_count = len(self.revision_history())
1253
 
            try:
1254
 
                self.update_revisions(source)
1255
 
            except DivergedBranches:
1256
 
                if not overwrite:
1257
 
                    raise
1258
 
            if overwrite:
1259
 
                self.set_revision_history(source.revision_history())
1260
 
            new_count = len(self.revision_history())
1261
 
            return new_count - old_count
1262
 
        finally:
1263
 
            source.unlock()
1264
 
 
1265
 
    def get_parent(self):
1266
 
        """See Branch.get_parent."""
1267
 
        import errno
1268
 
        _locs = ['parent', 'pull', 'x-pull']
1269
 
        for l in _locs:
1270
 
            try:
1271
 
                return self.controlfile(l, 'r').read().strip('\n')
1272
 
            except NoSuchFile:
1273
 
                pass
1274
 
        return None
1275
 
 
1276
 
    def get_push_location(self):
1277
 
        """See Branch.get_push_location."""
1278
 
        config = bzrlib.config.BranchConfig(self)
1279
 
        push_loc = config.get_user_option('push_location')
1280
 
        return push_loc
1281
 
 
1282
 
    def set_push_location(self, location):
1283
 
        """See Branch.set_push_location."""
1284
 
        config = bzrlib.config.LocationConfig(self.base)
1285
 
        config.set_user_option('push_location', location)
1286
 
 
1287
 
    @needs_write_lock
1288
 
    def set_parent(self, url):
1289
 
        """See Branch.set_parent."""
1290
 
        # TODO: Maybe delete old location files?
1291
 
        from bzrlib.atomicfile import AtomicFile
1292
 
        f = AtomicFile(self.controlfilename('parent'))
1293
 
        try:
1294
 
            f.write(url + '\n')
1295
 
            f.commit()
1296
 
        finally:
1297
 
            f.close()
1298
 
 
1299
 
    def tree_config(self):
1300
 
        return TreeConfig(self)
1301
 
 
1302
 
    def sign_revision(self, revision_id, gpg_strategy):
1303
 
        """See Branch.sign_revision."""
1304
 
        plaintext = Testament.from_revision(self, revision_id).as_short_text()
1305
 
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1306
 
 
1307
 
    @needs_write_lock
1308
 
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1309
 
        """See Branch.store_revision_signature."""
1310
 
        self.revision_store.add(StringIO(gpg_strategy.sign(plaintext)), 
1311
 
                                revision_id, "sig")
1312
 
 
1313
 
 
1314
 
Branch.set_default_initializer(BzrBranch._initialize)
1315
 
 
1316
 
 
1317
 
class BranchTestProviderAdapter(object):
1318
 
    """A tool to generate a suite testing multiple branch formats at once.
1319
 
 
1320
 
    This is done by copying the test once for each transport and injecting
1321
 
    the transport_server, transport_readonly_server, and branch_format
1322
 
    classes into each copy. Each copy is also given a new id() to make it
1323
 
    easy to identify.
1324
 
    """
1325
 
 
1326
 
    def __init__(self, transport_server, transport_readonly_server, formats):
1327
 
        self._transport_server = transport_server
1328
 
        self._transport_readonly_server = transport_readonly_server
1329
 
        self._formats = formats
1330
 
    
1331
 
    def adapt(self, test):
1332
 
        result = TestSuite()
1333
 
        for format in self._formats:
1334
 
            new_test = deepcopy(test)
1335
 
            new_test.transport_server = self._transport_server
1336
 
            new_test.transport_readonly_server = self._transport_readonly_server
1337
 
            new_test.branch_format = format
1338
 
            def make_new_test_id():
1339
 
                new_id = "%s(%s)" % (new_test.id(), format.__class__.__name__)
1340
 
                return lambda: new_id
1341
 
            new_test.id = make_new_test_id()
1342
 
            result.addTest(new_test)
1343
 
        return result
1344
 
 
1345
 
 
1346
 
class ScratchBranch(BzrBranch):
 
1142
        """
 
1143
        self.lock_write()
 
1144
        try:
 
1145
            ## TODO: Option to move IDs only
 
1146
            assert not isinstance(from_paths, basestring)
 
1147
            tree = self.working_tree()
 
1148
            inv = tree.inventory
 
1149
            to_abs = self.abspath(to_name)
 
1150
            if not isdir(to_abs):
 
1151
                raise BzrError("destination %r is not a directory" % to_abs)
 
1152
            if not tree.has_filename(to_name):
 
1153
                raise BzrError("destination %r not in working directory" % to_abs)
 
1154
            to_dir_id = inv.path2id(to_name)
 
1155
            if to_dir_id == None and to_name != '':
 
1156
                raise BzrError("destination %r is not a versioned directory" % to_name)
 
1157
            to_dir_ie = inv[to_dir_id]
 
1158
            if to_dir_ie.kind not in ('directory', 'root_directory'):
 
1159
                raise BzrError("destination %r is not a directory" % to_abs)
 
1160
 
 
1161
            to_idpath = inv.get_idpath(to_dir_id)
 
1162
 
 
1163
            for f in from_paths:
 
1164
                if not tree.has_filename(f):
 
1165
                    raise BzrError("%r does not exist in working tree" % f)
 
1166
                f_id = inv.path2id(f)
 
1167
                if f_id == None:
 
1168
                    raise BzrError("%r is not versioned" % f)
 
1169
                name_tail = splitpath(f)[-1]
 
1170
                dest_path = appendpath(to_name, name_tail)
 
1171
                if tree.has_filename(dest_path):
 
1172
                    raise BzrError("destination %r already exists" % dest_path)
 
1173
                if f_id in to_idpath:
 
1174
                    raise BzrError("can't move %r to a subdirectory of itself" % f)
 
1175
 
 
1176
            # OK, so there's a race here, it's possible that someone will
 
1177
            # create a file in this interval and then the rename might be
 
1178
            # left half-done.  But we should have caught most problems.
 
1179
 
 
1180
            for f in from_paths:
 
1181
                name_tail = splitpath(f)[-1]
 
1182
                dest_path = appendpath(to_name, name_tail)
 
1183
                print "%s => %s" % (f, dest_path)
 
1184
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
 
1185
                try:
 
1186
                    os.rename(self.abspath(f), self.abspath(dest_path))
 
1187
                except OSError, e:
 
1188
                    raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
 
1189
                            ["rename rolled back"])
 
1190
 
 
1191
            self._write_inventory(inv)
 
1192
        finally:
 
1193
            self.unlock()
 
1194
 
 
1195
 
 
1196
    def revert(self, filenames, old_tree=None, backups=True):
 
1197
        """Restore selected files to the versions from a previous tree.
 
1198
 
 
1199
        backups
 
1200
            If true (default) backups are made of files before
 
1201
            they're renamed.
 
1202
        """
 
1203
        from bzrlib.errors import NotVersionedError, BzrError
 
1204
        from bzrlib.atomicfile import AtomicFile
 
1205
        from bzrlib.osutils import backup_file
 
1206
        
 
1207
        inv = self.read_working_inventory()
 
1208
        if old_tree is None:
 
1209
            old_tree = self.basis_tree()
 
1210
        old_inv = old_tree.inventory
 
1211
 
 
1212
        nids = []
 
1213
        for fn in filenames:
 
1214
            file_id = inv.path2id(fn)
 
1215
            if not file_id:
 
1216
                raise NotVersionedError("not a versioned file", fn)
 
1217
            if not old_inv.has_id(file_id):
 
1218
                raise BzrError("file not present in old tree", fn, file_id)
 
1219
            nids.append((fn, file_id))
 
1220
            
 
1221
        # TODO: Rename back if it was previously at a different location
 
1222
 
 
1223
        # TODO: If given a directory, restore the entire contents from
 
1224
        # the previous version.
 
1225
 
 
1226
        # TODO: Make a backup to a temporary file.
 
1227
 
 
1228
        # TODO: If the file previously didn't exist, delete it?
 
1229
        for fn, file_id in nids:
 
1230
            backup_file(fn)
 
1231
            
 
1232
            f = AtomicFile(fn, 'wb')
 
1233
            try:
 
1234
                f.write(old_tree.get_file(file_id).read())
 
1235
                f.commit()
 
1236
            finally:
 
1237
                f.close()
 
1238
 
 
1239
 
 
1240
    def pending_merges(self):
 
1241
        """Return a list of pending merges.
 
1242
 
 
1243
        These are revisions that have been merged into the working
 
1244
        directory but not yet committed.
 
1245
        """
 
1246
        cfn = self.controlfilename('pending-merges')
 
1247
        if not os.path.exists(cfn):
 
1248
            return []
 
1249
        p = []
 
1250
        for l in self.controlfile('pending-merges', 'r').readlines():
 
1251
            p.append(l.rstrip('\n'))
 
1252
        return p
 
1253
 
 
1254
 
 
1255
    def add_pending_merge(self, revision_id):
 
1256
        from bzrlib.revision import validate_revision_id
 
1257
 
 
1258
        validate_revision_id(revision_id)
 
1259
 
 
1260
        p = self.pending_merges()
 
1261
        if revision_id in p:
 
1262
            return
 
1263
        p.append(revision_id)
 
1264
        self.set_pending_merges(p)
 
1265
 
 
1266
 
 
1267
    def set_pending_merges(self, rev_list):
 
1268
        from bzrlib.atomicfile import AtomicFile
 
1269
        self.lock_write()
 
1270
        try:
 
1271
            f = AtomicFile(self.controlfilename('pending-merges'))
 
1272
            try:
 
1273
                for l in rev_list:
 
1274
                    print >>f, l
 
1275
                f.commit()
 
1276
            finally:
 
1277
                f.close()
 
1278
        finally:
 
1279
            self.unlock()
 
1280
 
 
1281
 
 
1282
 
 
1283
class ScratchBranch(Branch):
1347
1284
    """Special test class: a branch that cleans up after itself.
1348
1285
 
1349
1286
    >>> b = ScratchBranch()
1350
1287
    >>> isdir(b.base)
1351
1288
    True
1352
1289
    >>> bd = b.base
1353
 
    >>> b._transport.__del__()
 
1290
    >>> b.destroy()
1354
1291
    >>> isdir(bd)
1355
1292
    False
1356
1293
    """
1357
 
 
1358
 
    def __init__(self, files=[], dirs=[], transport=None):
 
1294
    def __init__(self, files=[], dirs=[], base=None):
1359
1295
        """Make a test branch.
1360
1296
 
1361
1297
        This creates a temporary directory and runs init-tree in it.
1362
1298
 
1363
1299
        If any files are listed, they are created in the working copy.
1364
1300
        """
1365
 
        if transport is None:
1366
 
            transport = bzrlib.transport.local.ScratchTransport()
1367
 
            Branch.initialize(transport.base)
1368
 
            super(ScratchBranch, self).__init__(transport)
1369
 
        else:
1370
 
            super(ScratchBranch, self).__init__(transport)
1371
 
 
 
1301
        from tempfile import mkdtemp
 
1302
        init = False
 
1303
        if base is None:
 
1304
            base = mkdtemp()
 
1305
            init = True
 
1306
        Branch.__init__(self, base, init=init)
1372
1307
        for d in dirs:
1373
 
            self._transport.mkdir(d)
 
1308
            os.mkdir(self.abspath(d))
1374
1309
            
1375
1310
        for f in files:
1376
 
            self._transport.put(f, 'content of %s' % f)
 
1311
            file(os.path.join(self.base, f), 'w').write('content of %s' % f)
1377
1312
 
1378
1313
 
1379
1314
    def clone(self):
1380
1315
        """
1381
1316
        >>> orig = ScratchBranch(files=["file1", "file2"])
1382
1317
        >>> clone = orig.clone()
1383
 
        >>> if os.name != 'nt':
1384
 
        ...   os.path.samefile(orig.base, clone.base)
1385
 
        ... else:
1386
 
        ...   orig.base == clone.base
1387
 
        ...
 
1318
        >>> os.path.samefile(orig.base, clone.base)
1388
1319
        False
1389
 
        >>> os.path.isfile(pathjoin(clone.base, "file1"))
 
1320
        >>> os.path.isfile(os.path.join(clone.base, "file1"))
1390
1321
        True
1391
1322
        """
1392
1323
        from shutil import copytree
1393
 
        from bzrlib.osutils import mkdtemp
 
1324
        from tempfile import mkdtemp
1394
1325
        base = mkdtemp()
1395
1326
        os.rmdir(base)
1396
1327
        copytree(self.base, base, symlinks=True)
1397
 
        return ScratchBranch(
1398
 
            transport=bzrlib.transport.local.ScratchTransport(base))
 
1328
        return ScratchBranch(base=base)
 
1329
        
 
1330
    def __del__(self):
 
1331
        self.destroy()
 
1332
 
 
1333
    def destroy(self):
 
1334
        """Destroy the test branch, removing the scratch directory."""
 
1335
        from shutil import rmtree
 
1336
        try:
 
1337
            if self.base:
 
1338
                mutter("delete ScratchBranch %s" % self.base)
 
1339
                rmtree(self.base)
 
1340
        except OSError, e:
 
1341
            # Work around for shutil.rmtree failing on Windows when
 
1342
            # readonly files are encountered
 
1343
            mutter("hit exception in destroying ScratchBranch: %s" % e)
 
1344
            for root, dirs, files in os.walk(self.base, topdown=False):
 
1345
                for name in files:
 
1346
                    os.chmod(os.path.join(root, name), 0700)
 
1347
            rmtree(self.base)
 
1348
        self.base = None
 
1349
 
1399
1350
    
1400
1351
 
1401
1352
######################################################################
1404
1355
 
1405
1356
def is_control_file(filename):
1406
1357
    ## FIXME: better check
1407
 
    filename = normpath(filename)
 
1358
    filename = os.path.normpath(filename)
1408
1359
    while filename != '':
1409
1360
        head, tail = os.path.split(filename)
1410
1361
        ## mutter('check %r for control file' % ((head, tail), ))
1414
1365
            break
1415
1366
        filename = head
1416
1367
    return False
 
1368
 
 
1369
 
 
1370
 
 
1371
def gen_file_id(name):
 
1372
    """Return new file id.
 
1373
 
 
1374
    This should probably generate proper UUIDs, but for the moment we
 
1375
    cope with just randomness because running uuidgen every time is
 
1376
    slow."""
 
1377
    import re
 
1378
    from binascii import hexlify
 
1379
    from time import time
 
1380
 
 
1381
    # get last component
 
1382
    idx = name.rfind('/')
 
1383
    if idx != -1:
 
1384
        name = name[idx+1 : ]
 
1385
    idx = name.rfind('\\')
 
1386
    if idx != -1:
 
1387
        name = name[idx+1 : ]
 
1388
 
 
1389
    # make it not a hidden file
 
1390
    name = name.lstrip('.')
 
1391
 
 
1392
    # remove any wierd characters; we don't escape them but rather
 
1393
    # just pull them out
 
1394
    name = re.sub(r'[^\w.]', '', name)
 
1395
 
 
1396
    s = hexlify(rand_bytes(8))
 
1397
    return '-'.join((name, compact_date(time()), s))
 
1398
 
 
1399
 
 
1400
def gen_root_id():
 
1401
    """Return a new tree-root file id."""
 
1402
    return gen_file_id('TREE_ROOT')
 
1403