← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

Clint Adams patch for shell completion hints

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/branch.py
1
 
#! /usr/bin/env python
2
 
# -*- coding: UTF-8 -*-
 
1
# Copyright (C) 2005 Canonical Ltd
3
2
 
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
16
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
16
 
18
17
 
19
 
from sets import Set
20
 
 
21
 
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
22
 
import traceback, socket, fnmatch, difflib, time
23
 
from binascii import hexlify
 
18
import sys
 
19
import os
24
20
 
25
21
import bzrlib
26
 
from inventory import Inventory
27
 
from trace import mutter, note
28
 
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
29
 
from inventory import InventoryEntry, Inventory
30
 
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, chomp, \
31
 
     format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
32
 
     joinpath, sha_string, file_kind, local_time_offset
33
 
from store import ImmutableStore
34
 
from revision import Revision
35
 
from errors import bailout
36
 
from textui import show_status
37
 
from diff import diff_trees
 
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
 
 
27
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId, \
 
28
     DivergedBranches, NotBranchError
 
29
from bzrlib.textui import show_status
 
30
from bzrlib.revision import Revision
 
31
from bzrlib.delta import compare_trees
 
32
from bzrlib.tree import EmptyTree, RevisionTree
 
33
import bzrlib.xml
 
34
import bzrlib.ui
 
35
 
 
36
 
38
37
 
39
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
40
39
## TODO: Maybe include checks for common corruption of newlines, etc?
41
40
 
42
41
 
 
42
# TODO: Some operations like log might retrieve the same revisions
 
43
# repeatedly to calculate deltas.  We could perhaps have a weakref
 
44
# cache in memory to make this faster.
 
45
 
 
46
# TODO: please move the revision-string syntax stuff out of the branch
 
47
# object; it's clutter
 
48
 
 
49
 
 
50
def find_branch(f, **args):
 
51
    if f and (f.startswith('http://') or f.startswith('https://')):
 
52
        from bzrlib.remotebranch import RemoteBranch
 
53
        return RemoteBranch(f, **args)
 
54
    else:
 
55
        return Branch(f, **args)
 
56
 
 
57
 
 
58
def find_cached_branch(f, cache_root, **args):
 
59
    from bzrlib.remotebranch import RemoteBranch
 
60
    br = find_branch(f, **args)
 
61
    def cacheify(br, store_name):
 
62
        from bzrlib.meta_store import CachedStore
 
63
        cache_path = os.path.join(cache_root, store_name)
 
64
        os.mkdir(cache_path)
 
65
        new_store = CachedStore(getattr(br, store_name), cache_path)
 
66
        setattr(br, store_name, new_store)
 
67
 
 
68
    if isinstance(br, RemoteBranch):
 
69
        cacheify(br, 'inventory_store')
 
70
        cacheify(br, 'text_store')
 
71
        cacheify(br, 'revision_store')
 
72
    return br
 
73
 
 
74
 
 
75
def _relpath(base, path):
 
76
    """Return path relative to base, or raise exception.
 
77
 
 
78
    The path may be either an absolute path or a path relative to the
 
79
    current working directory.
 
80
 
 
81
    Lifted out of Branch.relpath for ease of testing.
 
82
 
 
83
    os.path.commonprefix (python2.4) has a bad bug that it works just
 
84
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
 
85
    avoids that problem."""
 
86
    rp = os.path.abspath(path)
 
87
 
 
88
    s = []
 
89
    head = rp
 
90
    while len(head) >= len(base):
 
91
        if head == base:
 
92
            break
 
93
        head, tail = os.path.split(head)
 
94
        if tail:
 
95
            s.insert(0, tail)
 
96
    else:
 
97
        raise NotBranchError("path %r is not within branch %r" % (rp, base))
 
98
 
 
99
    return os.sep.join(s)
 
100
        
 
101
 
 
102
def find_branch_root(f=None):
 
103
    """Find the branch root enclosing f, or pwd.
 
104
 
 
105
    f may be a filename or a URL.
 
106
 
 
107
    It is not necessary that f exists.
 
108
 
 
109
    Basically we keep looking up until we find the control directory or
 
110
    run into the root.  If there isn't one, raises NotBranchError.
 
111
    """
 
112
    if f == None:
 
113
        f = os.getcwd()
 
114
    elif hasattr(os.path, 'realpath'):
 
115
        f = os.path.realpath(f)
 
116
    else:
 
117
        f = os.path.abspath(f)
 
118
    if not os.path.exists(f):
 
119
        raise BzrError('%r does not exist' % f)
 
120
        
 
121
 
 
122
    orig_f = f
 
123
 
 
124
    while True:
 
125
        if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
 
126
            return f
 
127
        head, tail = os.path.split(f)
 
128
        if head == f:
 
129
            # reached the root, whatever that may be
 
130
            raise NotBranchError('%s is not in a branch' % orig_f)
 
131
        f = head
 
132
 
43
133
 
44
134
 
45
135
 
46
136
######################################################################
47
137
# branch objects
48
138
 
49
 
class Branch:
 
139
class Branch(object):
50
140
    """Branch holding a history of revisions.
51
141
 
52
 
    :todo: Perhaps use different stores for different classes of object,
53
 
           so that we can keep track of how much space each one uses,
54
 
           or garbage-collect them.
55
 
 
56
 
    :todo: Add a RemoteBranch subclass.  For the basic case of read-only
57
 
           HTTP access this should be very easy by, 
58
 
           just redirecting controlfile access into HTTP requests.
59
 
           We would need a RemoteStore working similarly.
60
 
 
61
 
    :todo: Keep the on-disk branch locked while the object exists.
62
 
 
63
 
    :todo: mkdir() method.
 
142
    base
 
143
        Base directory of the branch.
 
144
 
 
145
    _lock_mode
 
146
        None, or 'r' or 'w'
 
147
 
 
148
    _lock_count
 
149
        If _lock_mode is true, a positive count of the number of times the
 
150
        lock has been taken.
 
151
 
 
152
    _lock
 
153
        Lock object from bzrlib.lock.
64
154
    """
65
 
    def __init__(self, base, init=False):
 
155
    base = None
 
156
    _lock_mode = None
 
157
    _lock_count = None
 
158
    _lock = None
 
159
    
 
160
    # Map some sort of prefix into a namespace
 
161
    # stuff like "revno:10", "revid:", etc.
 
162
    # This should match a prefix with a function which accepts
 
163
    REVISION_NAMESPACES = {}
 
164
 
 
165
    def __init__(self, base, init=False, find_root=True):
66
166
        """Create new branch object at a particular location.
67
167
 
68
 
        :param base: Base directory for the branch.
69
 
 
70
 
        :param init: If True, create new control files in a previously
 
168
        base -- Base directory for the branch.
 
169
        
 
170
        init -- If True, create new control files in a previously
71
171
             unversioned directory.  If False, the branch must already
72
172
             be versioned.
73
173
 
 
174
        find_root -- If true and init is false, find the root of the
 
175
             existing branch containing base.
 
176
 
74
177
        In the test suite, creation of new trees is tested using the
75
178
        `ScratchBranch` class.
76
179
        """
77
 
        self.base = os.path.realpath(base)
 
180
        from bzrlib.store import ImmutableStore
78
181
        if init:
 
182
            self.base = os.path.realpath(base)
79
183
            self._make_control()
 
184
        elif find_root:
 
185
            self.base = find_branch_root(base)
80
186
        else:
 
187
            self.base = os.path.realpath(base)
81
188
            if not isdir(self.controlfilename('.')):
82
 
                bailout("not a bzr branch: %s" % quotefn(base),
83
 
                        ['use "bzr init" to initialize a new working tree',
84
 
                         'current bzr can only operate from top-of-tree'])
85
 
            self._check_format()
 
189
                raise NotBranchError("not a bzr branch: %s" % quotefn(base),
 
190
                                     ['use "bzr init" to initialize a new working tree',
 
191
                                      'current bzr can only operate from top-of-tree'])
 
192
        self._check_format()
86
193
 
87
194
        self.text_store = ImmutableStore(self.controlfilename('text-store'))
88
195
        self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
96
203
    __repr__ = __str__
97
204
 
98
205
 
99
 
    def _rel(self, name):
100
 
        """Return filename relative to branch top"""
 
206
    def __del__(self):
 
207
        if self._lock_mode or self._lock:
 
208
            from bzrlib.warnings import warn
 
209
            warn("branch %r was not explicitly unlocked" % self)
 
210
            self._lock.unlock()
 
211
 
 
212
 
 
213
    def lock_write(self):
 
214
        if self._lock_mode:
 
215
            if self._lock_mode != 'w':
 
216
                from bzrlib.errors import LockError
 
217
                raise LockError("can't upgrade to a write lock from %r" %
 
218
                                self._lock_mode)
 
219
            self._lock_count += 1
 
220
        else:
 
221
            from bzrlib.lock import WriteLock
 
222
 
 
223
            self._lock = WriteLock(self.controlfilename('branch-lock'))
 
224
            self._lock_mode = 'w'
 
225
            self._lock_count = 1
 
226
 
 
227
 
 
228
    def lock_read(self):
 
229
        if self._lock_mode:
 
230
            assert self._lock_mode in ('r', 'w'), \
 
231
                   "invalid lock mode %r" % self._lock_mode
 
232
            self._lock_count += 1
 
233
        else:
 
234
            from bzrlib.lock import ReadLock
 
235
 
 
236
            self._lock = ReadLock(self.controlfilename('branch-lock'))
 
237
            self._lock_mode = 'r'
 
238
            self._lock_count = 1
 
239
                        
 
240
    def unlock(self):
 
241
        if not self._lock_mode:
 
242
            from bzrlib.errors import LockError
 
243
            raise LockError('branch %r is not locked' % (self))
 
244
 
 
245
        if self._lock_count > 1:
 
246
            self._lock_count -= 1
 
247
        else:
 
248
            self._lock.unlock()
 
249
            self._lock = None
 
250
            self._lock_mode = self._lock_count = None
 
251
 
 
252
    def abspath(self, name):
 
253
        """Return absolute filename for something in the branch"""
101
254
        return os.path.join(self.base, name)
102
 
        
 
255
 
 
256
    def relpath(self, path):
 
257
        """Return path relative to this branch of something inside it.
 
258
 
 
259
        Raises an error if path is not in this branch."""
 
260
        return _relpath(self.base, path)
103
261
 
104
262
    def controlfilename(self, file_or_path):
105
263
        """Return location relative to branch."""
106
 
        if isinstance(file_or_path, types.StringTypes):
 
264
        if isinstance(file_or_path, basestring):
107
265
            file_or_path = [file_or_path]
108
266
        return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
109
267
 
110
268
 
111
269
    def controlfile(self, file_or_path, mode='r'):
112
 
        """Open a control file for this branch"""
113
 
        return file(self.controlfilename(file_or_path), mode)
114
 
 
 
270
        """Open a control file for this branch.
 
271
 
 
272
        There are two classes of file in the control directory: text
 
273
        and binary.  binary files are untranslated byte streams.  Text
 
274
        control files are stored with Unix newlines and in UTF-8, even
 
275
        if the platform or locale defaults are different.
 
276
 
 
277
        Controlfiles should almost never be opened in write mode but
 
278
        rather should be atomically copied and replaced using atomicfile.
 
279
        """
 
280
 
 
281
        fn = self.controlfilename(file_or_path)
 
282
 
 
283
        if mode == 'rb' or mode == 'wb':
 
284
            return file(fn, mode)
 
285
        elif mode == 'r' or mode == 'w':
 
286
            # open in binary mode anyhow so there's no newline translation;
 
287
            # codecs uses line buffering by default; don't want that.
 
288
            import codecs
 
289
            return codecs.open(fn, mode + 'b', 'utf-8',
 
290
                               buffering=60000)
 
291
        else:
 
292
            raise BzrError("invalid controlfile mode %r" % mode)
115
293
 
116
294
    def _make_control(self):
 
295
        from bzrlib.inventory import Inventory
 
296
        
117
297
        os.mkdir(self.controlfilename([]))
118
298
        self.controlfile('README', 'w').write(
119
299
            "This is a Bazaar-NG control directory.\n"
120
 
            "Do not change any files in this directory.")
 
300
            "Do not change any files in this directory.\n")
121
301
        self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
122
302
        for d in ('text-store', 'inventory-store', 'revision-store'):
123
303
            os.mkdir(self.controlfilename(d))
124
304
        for f in ('revision-history', 'merged-patches',
125
 
                  'pending-merged-patches', 'branch-name'):
 
305
                  'pending-merged-patches', 'branch-name',
 
306
                  'branch-lock',
 
307
                  'pending-merges'):
126
308
            self.controlfile(f, 'w').write('')
127
309
        mutter('created control directory in ' + self.base)
128
 
        Inventory().write_xml(self.controlfile('inventory','w'))
 
310
 
 
311
        # if we want per-tree root ids then this is the place to set
 
312
        # them; they're not needed for now and so ommitted for
 
313
        # simplicity.
 
314
        f = self.controlfile('inventory','w')
 
315
        bzrlib.xml.serializer_v4.write_inventory(Inventory(), f)
129
316
 
130
317
 
131
318
    def _check_format(self):
135
322
 
136
323
        In the future, we might need different in-memory Branch
137
324
        classes to support downlevel branches.  But not yet.
138
 
        """        
139
 
        # read in binary mode to detect newline wierdness.
140
 
        fmt = self.controlfile('branch-format', 'rb').read()
 
325
        """
 
326
        # This ignores newlines so that we can open branches created
 
327
        # on Windows from Linux and so on.  I think it might be better
 
328
        # to always make all internal files in unix format.
 
329
        fmt = self.controlfile('branch-format', 'r').read()
 
330
        fmt = fmt.replace('\r\n', '\n')
141
331
        if fmt != BZR_BRANCH_FORMAT:
142
 
            bailout('sorry, branch format %r not supported' % fmt,
143
 
                    ['use a different bzr version',
144
 
                     'or remove the .bzr directory and "bzr init" again'])
145
 
 
 
332
            raise BzrError('sorry, branch format %r not supported' % fmt,
 
333
                           ['use a different bzr version',
 
334
                            'or remove the .bzr directory and "bzr init" again'])
 
335
 
 
336
    def get_root_id(self):
 
337
        """Return the id of this branches root"""
 
338
        inv = self.read_working_inventory()
 
339
        return inv.root.file_id
 
340
 
 
341
    def set_root_id(self, file_id):
 
342
        inv = self.read_working_inventory()
 
343
        orig_root_id = inv.root.file_id
 
344
        del inv._byid[inv.root.file_id]
 
345
        inv.root.file_id = file_id
 
346
        inv._byid[inv.root.file_id] = inv.root
 
347
        for fid in inv:
 
348
            entry = inv[fid]
 
349
            if entry.parent_id in (None, orig_root_id):
 
350
                entry.parent_id = inv.root.file_id
 
351
        self._write_inventory(inv)
146
352
 
147
353
    def read_working_inventory(self):
148
354
        """Read the working inventory."""
149
 
        before = time.time()
150
 
        inv = Inventory.read_xml(self.controlfile('inventory', 'r'))
151
 
        mutter("loaded inventory of %d items in %f"
152
 
               % (len(inv), time.time() - before))
153
 
        return inv
154
 
 
 
355
        from bzrlib.inventory import Inventory
 
356
        self.lock_read()
 
357
        try:
 
358
            # ElementTree does its own conversion from UTF-8, so open in
 
359
            # binary.
 
360
            f = self.controlfile('inventory', 'rb')
 
361
            return bzrlib.xml.serializer_v4.read_inventory(f)
 
362
        finally:
 
363
            self.unlock()
 
364
            
155
365
 
156
366
    def _write_inventory(self, inv):
157
367
        """Update the working inventory.
159
369
        That is to say, the inventory describing changes underway, that
160
370
        will be committed to the next revision.
161
371
        """
162
 
        ## TODO: factor out to atomicfile?  is rename safe on windows?
163
 
        tmpfname = self.controlfilename('inventory.tmp')
164
 
        tmpf = file(tmpfname, 'w')
165
 
        inv.write_xml(tmpf)
166
 
        tmpf.close()
167
 
        os.rename(tmpfname, self.controlfilename('inventory'))
 
372
        from bzrlib.atomicfile import AtomicFile
 
373
        
 
374
        self.lock_write()
 
375
        try:
 
376
            f = AtomicFile(self.controlfilename('inventory'), 'wb')
 
377
            try:
 
378
                bzrlib.xml.serializer_v4.write_inventory(inv, f)
 
379
                f.commit()
 
380
            finally:
 
381
                f.close()
 
382
        finally:
 
383
            self.unlock()
 
384
        
168
385
        mutter('wrote working inventory')
169
 
 
 
386
            
170
387
 
171
388
    inventory = property(read_working_inventory, _write_inventory, None,
172
389
                         """Inventory for the working copy.""")
173
390
 
174
391
 
175
 
    def add(self, files, verbose=False):
 
392
    def add(self, files, ids=None):
176
393
        """Make files versioned.
177
394
 
 
395
        Note that the command line normally calls smart_add instead,
 
396
        which can automatically recurse.
 
397
 
178
398
        This puts the files in the Added state, so that they will be
179
399
        recorded by the next commit.
180
400
 
181
 
        :todo: Perhaps have an option to add the ids even if the files do
182
 
               not (yet) exist.
183
 
 
184
 
        :todo: Perhaps return the ids of the files?  But then again it
185
 
               is easy to retrieve them if they're needed.
186
 
 
187
 
        :todo: Option to specify file id.
188
 
 
189
 
        :todo: Adding a directory should optionally recurse down and
190
 
               add all non-ignored children.  Perhaps do that in a
191
 
               higher-level method.
192
 
 
193
 
        >>> b = ScratchBranch(files=['foo'])
194
 
        >>> 'foo' in b.unknowns()
195
 
        True
196
 
        >>> b.show_status()
197
 
        ?       foo
198
 
        >>> b.add('foo')
199
 
        >>> 'foo' in b.unknowns()
200
 
        False
201
 
        >>> bool(b.inventory.path2id('foo'))
202
 
        True
203
 
        >>> b.show_status()
204
 
        A       foo
205
 
 
206
 
        >>> b.add('foo')
207
 
        Traceback (most recent call last):
208
 
        ...
209
 
        BzrError: ('foo is already versioned', [])
210
 
 
211
 
        >>> b.add(['nothere'])
212
 
        Traceback (most recent call last):
213
 
        BzrError: ('cannot add: not a regular file or directory: nothere', [])
 
401
        files
 
402
            List of paths to add, relative to the base of the tree.
 
403
 
 
404
        ids
 
405
            If set, use these instead of automatically generated ids.
 
406
            Must be the same length as the list of files, but may
 
407
            contain None for ids that are to be autogenerated.
 
408
 
 
409
        TODO: Perhaps have an option to add the ids even if the files do
 
410
              not (yet) exist.
 
411
 
 
412
        TODO: Perhaps yield the ids and paths as they're added.
214
413
        """
215
 
 
216
414
        # TODO: Re-adding a file that is removed in the working copy
217
415
        # should probably put it back with the previous ID.
218
 
        if isinstance(files, types.StringTypes):
 
416
        if isinstance(files, basestring):
 
417
            assert(ids is None or isinstance(ids, basestring))
219
418
            files = [files]
220
 
        
221
 
        inv = self.read_working_inventory()
222
 
        for f in files:
223
 
            if is_control_file(f):
224
 
                bailout("cannot add control file %s" % quotefn(f))
225
 
 
226
 
            fp = splitpath(f)
227
 
 
228
 
            if len(fp) == 0:
229
 
                bailout("cannot add top-level %r" % f)
230
 
                
231
 
            fullpath = os.path.normpath(self._rel(f))
232
 
 
233
 
            if isfile(fullpath):
234
 
                kind = 'file'
235
 
            elif isdir(fullpath):
236
 
                kind = 'directory'
237
 
            else:
238
 
                bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
239
 
 
240
 
            if len(fp) > 1:
241
 
                parent_name = joinpath(fp[:-1])
242
 
                mutter("lookup parent %r" % parent_name)
243
 
                parent_id = inv.path2id(parent_name)
244
 
                if parent_id == None:
245
 
                    bailout("cannot add: parent %r is not versioned"
246
 
                            % joinpath(fp[:-1]))
247
 
            else:
248
 
                parent_id = None
249
 
 
250
 
            file_id = _gen_file_id(fp[-1])
251
 
            inv.add(InventoryEntry(file_id, fp[-1], kind=kind, parent_id=parent_id))
252
 
            if verbose:
253
 
                show_status('A', kind, quotefn(f))
254
 
                
255
 
            mutter("add file %s file_id:{%s} kind=%r parent_id={%s}"
256
 
                   % (f, file_id, kind, parent_id))
257
 
        self._write_inventory(inv)
258
 
 
 
419
            if ids is not None:
 
420
                ids = [ids]
 
421
 
 
422
        if ids is None:
 
423
            ids = [None] * len(files)
 
424
        else:
 
425
            assert(len(ids) == len(files))
 
426
 
 
427
        self.lock_write()
 
428
        try:
 
429
            inv = self.read_working_inventory()
 
430
            for f,file_id in zip(files, ids):
 
431
                if is_control_file(f):
 
432
                    raise BzrError("cannot add control file %s" % quotefn(f))
 
433
 
 
434
                fp = splitpath(f)
 
435
 
 
436
                if len(fp) == 0:
 
437
                    raise BzrError("cannot add top-level %r" % f)
 
438
 
 
439
                fullpath = os.path.normpath(self.abspath(f))
 
440
 
 
441
                try:
 
442
                    kind = file_kind(fullpath)
 
443
                except OSError:
 
444
                    # maybe something better?
 
445
                    raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
 
446
 
 
447
                if kind != 'file' and kind != 'directory':
 
448
                    raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
 
449
 
 
450
                if file_id is None:
 
451
                    file_id = gen_file_id(f)
 
452
                inv.add_path(f, kind=kind, file_id=file_id)
 
453
 
 
454
                mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
 
455
 
 
456
            self._write_inventory(inv)
 
457
        finally:
 
458
            self.unlock()
 
459
            
 
460
 
 
461
    def print_file(self, file, revno):
 
462
        """Print `file` to stdout."""
 
463
        self.lock_read()
 
464
        try:
 
465
            tree = self.revision_tree(self.lookup_revision(revno))
 
466
            # use inventory as it was in that revision
 
467
            file_id = tree.inventory.path2id(file)
 
468
            if not file_id:
 
469
                raise BzrError("%r is not present in revision %s" % (file, revno))
 
470
            tree.print_file(file_id)
 
471
        finally:
 
472
            self.unlock()
259
473
 
260
474
 
261
475
    def remove(self, files, verbose=False):
263
477
 
264
478
        This does not remove their text.  This does not run on 
265
479
 
266
 
        :todo: Refuse to remove modified files unless --force is given?
267
 
 
268
 
        >>> b = ScratchBranch(files=['foo'])
269
 
        >>> b.add('foo')
270
 
        >>> b.inventory.has_filename('foo')
271
 
        True
272
 
        >>> b.remove('foo')
273
 
        >>> b.working_tree().has_filename('foo')
274
 
        True
275
 
        >>> b.inventory.has_filename('foo')
276
 
        False
277
 
        
278
 
        >>> b = ScratchBranch(files=['foo'])
279
 
        >>> b.add('foo')
280
 
        >>> b.commit('one')
281
 
        >>> b.remove('foo')
282
 
        >>> b.commit('two')
283
 
        >>> b.inventory.has_filename('foo') 
284
 
        False
285
 
        >>> b.basis_tree().has_filename('foo') 
286
 
        False
287
 
        >>> b.working_tree().has_filename('foo') 
288
 
        True
289
 
 
290
 
        :todo: Do something useful with directories.
291
 
 
292
 
        :todo: Should this remove the text or not?  Tough call; not
 
480
        TODO: Refuse to remove modified files unless --force is given?
 
481
 
 
482
        TODO: Do something useful with directories.
 
483
 
 
484
        TODO: Should this remove the text or not?  Tough call; not
293
485
        removing may be useful and the user can just use use rm, and
294
486
        is the opposite of add.  Removing it is consistent with most
295
487
        other tools.  Maybe an option.
296
488
        """
297
489
        ## TODO: Normalize names
298
490
        ## TODO: Remove nested loops; better scalability
299
 
 
300
 
        if isinstance(files, types.StringTypes):
 
491
        if isinstance(files, basestring):
301
492
            files = [files]
302
 
        
303
 
        tree = self.working_tree()
304
 
        inv = tree.inventory
305
 
 
306
 
        # do this before any modifications
307
 
        for f in files:
308
 
            fid = inv.path2id(f)
309
 
            if not fid:
310
 
                bailout("cannot remove unversioned file %s" % quotefn(f))
311
 
            mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
312
 
            if verbose:
313
 
                # having remove it, it must be either ignored or unknown
314
 
                if tree.is_ignored(f):
315
 
                    new_status = 'I'
316
 
                else:
317
 
                    new_status = '?'
318
 
                show_status(new_status, inv[fid].kind, quotefn(f))
319
 
            del inv[fid]
320
 
 
 
493
 
 
494
        self.lock_write()
 
495
 
 
496
        try:
 
497
            tree = self.working_tree()
 
498
            inv = tree.inventory
 
499
 
 
500
            # do this before any modifications
 
501
            for f in files:
 
502
                fid = inv.path2id(f)
 
503
                if not fid:
 
504
                    raise BzrError("cannot remove unversioned file %s" % quotefn(f))
 
505
                mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
 
506
                if verbose:
 
507
                    # having remove it, it must be either ignored or unknown
 
508
                    if tree.is_ignored(f):
 
509
                        new_status = 'I'
 
510
                    else:
 
511
                        new_status = '?'
 
512
                    show_status(new_status, inv[fid].kind, quotefn(f))
 
513
                del inv[fid]
 
514
 
 
515
            self._write_inventory(inv)
 
516
        finally:
 
517
            self.unlock()
 
518
 
 
519
 
 
520
    # FIXME: this doesn't need to be a branch method
 
521
    def set_inventory(self, new_inventory_list):
 
522
        from bzrlib.inventory import Inventory, InventoryEntry
 
523
        inv = Inventory(self.get_root_id())
 
524
        for path, file_id, parent, kind in new_inventory_list:
 
525
            name = os.path.basename(path)
 
526
            if name == "":
 
527
                continue
 
528
            inv.add(InventoryEntry(file_id, name, kind, parent))
321
529
        self._write_inventory(inv)
322
530
 
323
531
 
340
548
        return self.working_tree().unknowns()
341
549
 
342
550
 
343
 
    def commit(self, message, timestamp=None, timezone=None,
344
 
               committer=None,
345
 
               verbose=False):
346
 
        """Commit working copy as a new revision.
347
 
        
348
 
        The basic approach is to add all the file texts into the
349
 
        store, then the inventory, then make a new revision pointing
350
 
        to that inventory and store that.
351
 
        
352
 
        This is not quite safe if the working copy changes during the
353
 
        commit; for the moment that is simply not allowed.  A better
354
 
        approach is to make a temporary copy of the files before
355
 
        computing their hashes, and then add those hashes in turn to
356
 
        the inventory.  This should mean at least that there are no
357
 
        broken hash pointers.  There is no way we can get a snapshot
358
 
        of the whole directory at an instant.  This would also have to
359
 
        be robust against files disappearing, moving, etc.  So the
360
 
        whole thing is a bit hard.
361
 
 
362
 
        :param timestamp: if not None, seconds-since-epoch for a
363
 
             postdated/predated commit.
364
 
        """
365
 
 
366
 
        ## TODO: Show branch names
367
 
 
368
 
        # TODO: Don't commit if there are no changes, unless forced?
369
 
 
370
 
        # First walk over the working inventory; and both update that
371
 
        # and also build a new revision inventory.  The revision
372
 
        # inventory needs to hold the text-id, sha1 and size of the
373
 
        # actual file versions committed in the revision.  (These are
374
 
        # not present in the working inventory.)  We also need to
375
 
        # detect missing/deleted files, and remove them from the
376
 
        # working inventory.
377
 
 
378
 
        work_inv = self.read_working_inventory()
379
 
        inv = Inventory()
380
 
        basis = self.basis_tree()
381
 
        basis_inv = basis.inventory
382
 
        missing_ids = []
383
 
        for path, entry in work_inv.iter_entries():
384
 
            ## TODO: Cope with files that have gone missing.
385
 
 
386
 
            ## TODO: Check that the file kind has not changed from the previous
387
 
            ## revision of this file (if any).
388
 
 
389
 
            entry = entry.copy()
390
 
 
391
 
            p = self._rel(path)
392
 
            file_id = entry.file_id
393
 
            mutter('commit prep file %s, id %r ' % (p, file_id))
394
 
 
395
 
            if not os.path.exists(p):
396
 
                mutter("    file is missing, removing from inventory")
397
 
                if verbose:
398
 
                    show_status('D', entry.kind, quotefn(path))
399
 
                missing_ids.append(file_id)
400
 
                continue
401
 
 
402
 
            # TODO: Handle files that have been deleted
403
 
 
404
 
            # TODO: Maybe a special case for empty files?  Seems a
405
 
            # waste to store them many times.
406
 
 
407
 
            inv.add(entry)
408
 
 
409
 
            if basis_inv.has_id(file_id):
410
 
                old_kind = basis_inv[file_id].kind
411
 
                if old_kind != entry.kind:
412
 
                    bailout("entry %r changed kind from %r to %r"
413
 
                            % (file_id, old_kind, entry.kind))
414
 
 
415
 
            if entry.kind == 'directory':
416
 
                if not isdir(p):
417
 
                    bailout("%s is entered as directory but not a directory" % quotefn(p))
418
 
            elif entry.kind == 'file':
419
 
                if not isfile(p):
420
 
                    bailout("%s is entered as file but is not a file" % quotefn(p))
421
 
 
422
 
                content = file(p, 'rb').read()
423
 
 
424
 
                entry.text_sha1 = sha_string(content)
425
 
                entry.text_size = len(content)
426
 
 
427
 
                old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
428
 
                if (old_ie
429
 
                    and (old_ie.text_size == entry.text_size)
430
 
                    and (old_ie.text_sha1 == entry.text_sha1)):
431
 
                    ## assert content == basis.get_file(file_id).read()
432
 
                    entry.text_id = basis_inv[file_id].text_id
433
 
                    mutter('    unchanged from previous text_id {%s}' %
434
 
                           entry.text_id)
435
 
                    
436
 
                else:
437
 
                    entry.text_id = _gen_file_id(entry.name)
438
 
                    self.text_store.add(content, entry.text_id)
439
 
                    mutter('    stored with text_id {%s}' % entry.text_id)
440
 
                    if verbose:
441
 
                        if not old_ie:
442
 
                            state = 'A'
443
 
                        elif (old_ie.name == entry.name
444
 
                              and old_ie.parent_id == entry.parent_id):
445
 
                            state = 'R'
446
 
                        else:
447
 
                            state = 'M'
448
 
 
449
 
                        show_status(state, entry.kind, quotefn(path))
450
 
 
451
 
        for file_id in missing_ids:
452
 
            # have to do this later so we don't mess up the iterator.
453
 
            # since parents may be removed before their children we
454
 
            # have to test.
455
 
 
456
 
            # FIXME: There's probably a better way to do this; perhaps
457
 
            # the workingtree should know how to filter itself.
458
 
            if work_inv.has_id(file_id):
459
 
                del work_inv[file_id]
460
 
 
461
 
 
462
 
        inv_id = rev_id = _gen_revision_id(time.time())
463
 
        
464
 
        inv_tmp = tempfile.TemporaryFile()
465
 
        inv.write_xml(inv_tmp)
466
 
        inv_tmp.seek(0)
467
 
        self.inventory_store.add(inv_tmp, inv_id)
468
 
        mutter('new inventory_id is {%s}' % inv_id)
469
 
 
470
 
        self._write_inventory(work_inv)
471
 
 
472
 
        if timestamp == None:
473
 
            timestamp = time.time()
474
 
 
475
 
        if committer == None:
476
 
            committer = username()
477
 
 
478
 
        if timezone == None:
479
 
            timezone = local_time_offset()
480
 
 
481
 
        mutter("building commit log message")
482
 
        rev = Revision(timestamp=timestamp,
483
 
                       timezone=timezone,
484
 
                       committer=committer,
485
 
                       precursor = self.last_patch(),
486
 
                       message = message,
487
 
                       inventory_id=inv_id,
488
 
                       revision_id=rev_id)
489
 
 
490
 
        rev_tmp = tempfile.TemporaryFile()
491
 
        rev.write_xml(rev_tmp)
492
 
        rev_tmp.seek(0)
493
 
        self.revision_store.add(rev_tmp, rev_id)
494
 
        mutter("new revision_id is {%s}" % rev_id)
495
 
        
496
 
        ## XXX: Everything up to here can simply be orphaned if we abort
497
 
        ## the commit; it will leave junk files behind but that doesn't
498
 
        ## matter.
499
 
 
500
 
        ## TODO: Read back the just-generated changeset, and make sure it
501
 
        ## applies and recreates the right state.
502
 
 
503
 
        ## TODO: Also calculate and store the inventory SHA1
504
 
        mutter("committing patch r%d" % (self.revno() + 1))
505
 
 
506
 
        mutter("append to revision-history")
507
 
        self.controlfile('revision-history', 'at').write(rev_id + '\n')
508
 
 
509
 
        mutter("done!")
 
551
    def append_revision(self, *revision_ids):
 
552
        from bzrlib.atomicfile import AtomicFile
 
553
 
 
554
        for revision_id in revision_ids:
 
555
            mutter("add {%s} to revision-history" % revision_id)
 
556
 
 
557
        rev_history = self.revision_history()
 
558
        rev_history.extend(revision_ids)
 
559
 
 
560
        f = AtomicFile(self.controlfilename('revision-history'))
 
561
        try:
 
562
            for rev_id in rev_history:
 
563
                print >>f, rev_id
 
564
            f.commit()
 
565
        finally:
 
566
            f.close()
 
567
 
 
568
 
 
569
    def get_revision_xml_file(self, revision_id):
 
570
        """Return XML file object for revision object."""
 
571
        if not revision_id or not isinstance(revision_id, basestring):
 
572
            raise InvalidRevisionId(revision_id)
 
573
 
 
574
        self.lock_read()
 
575
        try:
 
576
            try:
 
577
                return self.revision_store[revision_id]
 
578
            except IndexError:
 
579
                raise bzrlib.errors.NoSuchRevision(self, revision_id)
 
580
        finally:
 
581
            self.unlock()
 
582
 
 
583
 
 
584
    #deprecated
 
585
    get_revision_xml = get_revision_xml_file
510
586
 
511
587
 
512
588
    def get_revision(self, revision_id):
513
589
        """Return the Revision object for a named revision"""
514
 
        r = Revision.read_xml(self.revision_store[revision_id])
 
590
        xml_file = self.get_revision_xml_file(revision_id)
 
591
 
 
592
        try:
 
593
            r = bzrlib.xml.serializer_v4.read_revision(xml_file)
 
594
        except SyntaxError, e:
 
595
            raise bzrlib.errors.BzrError('failed to unpack revision_xml',
 
596
                                         [revision_id,
 
597
                                          str(e)])
 
598
            
515
599
        assert r.revision_id == revision_id
516
600
        return r
517
601
 
518
602
 
 
603
    def get_revision_delta(self, revno):
 
604
        """Return the delta for one revision.
 
605
 
 
606
        The delta is relative to its mainline predecessor, or the
 
607
        empty tree for revision 1.
 
608
        """
 
609
        assert isinstance(revno, int)
 
610
        rh = self.revision_history()
 
611
        if not (1 <= revno <= len(rh)):
 
612
            raise InvalidRevisionNumber(revno)
 
613
 
 
614
        # revno is 1-based; list is 0-based
 
615
 
 
616
        new_tree = self.revision_tree(rh[revno-1])
 
617
        if revno == 1:
 
618
            old_tree = EmptyTree()
 
619
        else:
 
620
            old_tree = self.revision_tree(rh[revno-2])
 
621
 
 
622
        return compare_trees(old_tree, new_tree)
 
623
 
 
624
        
 
625
 
 
626
    def get_revision_sha1(self, revision_id):
 
627
        """Hash the stored value of a revision, and return it."""
 
628
        # In the future, revision entries will be signed. At that
 
629
        # point, it is probably best *not* to include the signature
 
630
        # in the revision hash. Because that lets you re-sign
 
631
        # the revision, (add signatures/remove signatures) and still
 
632
        # have all hash pointers stay consistent.
 
633
        # But for now, just hash the contents.
 
634
        return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
 
635
 
 
636
 
519
637
    def get_inventory(self, inventory_id):
520
638
        """Get Inventory object by hash.
521
639
 
522
 
        :todo: Perhaps for this and similar methods, take a revision
 
640
        TODO: Perhaps for this and similar methods, take a revision
523
641
               parameter which can be either an integer revno or a
524
642
               string hash."""
525
 
        i = Inventory.read_xml(self.inventory_store[inventory_id])
526
 
        return i
 
643
        from bzrlib.inventory import Inventory
 
644
 
 
645
        f = self.get_inventory_xml_file(inventory_id)
 
646
        return bzrlib.xml.serializer_v4.read_inventory(f)
 
647
 
 
648
 
 
649
    def get_inventory_xml(self, inventory_id):
 
650
        """Get inventory XML as a file object."""
 
651
        return self.inventory_store[inventory_id]
 
652
 
 
653
    get_inventory_xml_file = get_inventory_xml
 
654
            
 
655
 
 
656
    def get_inventory_sha1(self, inventory_id):
 
657
        """Return the sha1 hash of the inventory entry
 
658
        """
 
659
        return sha_file(self.get_inventory_xml(inventory_id))
527
660
 
528
661
 
529
662
    def get_revision_inventory(self, revision_id):
530
663
        """Return inventory of a past revision."""
 
664
        # bzr 0.0.6 imposes the constraint that the inventory_id
 
665
        # must be the same as its revision, so this is trivial.
531
666
        if revision_id == None:
532
 
            return Inventory()
 
667
            from bzrlib.inventory import Inventory
 
668
            return Inventory(self.get_root_id())
533
669
        else:
534
 
            return self.get_inventory(self.get_revision(revision_id).inventory_id)
 
670
            return self.get_inventory(revision_id)
535
671
 
536
672
 
537
673
    def revision_history(self):
540
676
        >>> ScratchBranch().revision_history()
541
677
        []
542
678
        """
543
 
        return [chomp(l) for l in self.controlfile('revision-history').readlines()]
 
679
        self.lock_read()
 
680
        try:
 
681
            return [l.rstrip('\r\n') for l in
 
682
                    self.controlfile('revision-history', 'r').readlines()]
 
683
        finally:
 
684
            self.unlock()
 
685
 
 
686
 
 
687
    def common_ancestor(self, other, self_revno=None, other_revno=None):
 
688
        """
 
689
        >>> from bzrlib.commit import commit
 
690
        >>> sb = ScratchBranch(files=['foo', 'foo~'])
 
691
        >>> sb.common_ancestor(sb) == (None, None)
 
692
        True
 
693
        >>> commit(sb, "Committing first revision", verbose=False)
 
694
        >>> sb.common_ancestor(sb)[0]
 
695
        1
 
696
        >>> clone = sb.clone()
 
697
        >>> commit(sb, "Committing second revision", verbose=False)
 
698
        >>> sb.common_ancestor(sb)[0]
 
699
        2
 
700
        >>> sb.common_ancestor(clone)[0]
 
701
        1
 
702
        >>> commit(clone, "Committing divergent second revision", 
 
703
        ...               verbose=False)
 
704
        >>> sb.common_ancestor(clone)[0]
 
705
        1
 
706
        >>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
 
707
        True
 
708
        >>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
 
709
        True
 
710
        >>> clone2 = sb.clone()
 
711
        >>> sb.common_ancestor(clone2)[0]
 
712
        2
 
713
        >>> sb.common_ancestor(clone2, self_revno=1)[0]
 
714
        1
 
715
        >>> sb.common_ancestor(clone2, other_revno=1)[0]
 
716
        1
 
717
        """
 
718
        my_history = self.revision_history()
 
719
        other_history = other.revision_history()
 
720
        if self_revno is None:
 
721
            self_revno = len(my_history)
 
722
        if other_revno is None:
 
723
            other_revno = len(other_history)
 
724
        indices = range(min((self_revno, other_revno)))
 
725
        indices.reverse()
 
726
        for r in indices:
 
727
            if my_history[r] == other_history[r]:
 
728
                return r+1, my_history[r]
 
729
        return None, None
544
730
 
545
731
 
546
732
    def revno(self):
548
734
 
549
735
        That is equivalent to the number of revisions committed to
550
736
        this branch.
551
 
 
552
 
        >>> b = ScratchBranch()
553
 
        >>> b.revno()
554
 
        0
555
 
        >>> b.commit('no foo')
556
 
        >>> b.revno()
557
 
        1
558
737
        """
559
738
        return len(self.revision_history())
560
739
 
561
740
 
562
741
    def last_patch(self):
563
742
        """Return last patch hash, or None if no history.
564
 
 
565
 
        >>> ScratchBranch().last_patch() == None
566
 
        True
567
743
        """
568
744
        ph = self.revision_history()
569
745
        if ph:
570
746
            return ph[-1]
571
 
 
572
 
 
573
 
    def lookup_revision(self, revno):
574
 
        """Return revision hash for revision number."""
 
747
        else:
 
748
            return None
 
749
 
 
750
 
 
751
    def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
 
752
        """
 
753
        If self and other have not diverged, return a list of the revisions
 
754
        present in other, but missing from self.
 
755
 
 
756
        >>> from bzrlib.commit import commit
 
757
        >>> bzrlib.trace.silent = True
 
758
        >>> br1 = ScratchBranch()
 
759
        >>> br2 = ScratchBranch()
 
760
        >>> br1.missing_revisions(br2)
 
761
        []
 
762
        >>> commit(br2, "lala!", rev_id="REVISION-ID-1")
 
763
        >>> br1.missing_revisions(br2)
 
764
        [u'REVISION-ID-1']
 
765
        >>> br2.missing_revisions(br1)
 
766
        []
 
767
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1")
 
768
        >>> br1.missing_revisions(br2)
 
769
        []
 
770
        >>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
 
771
        >>> br1.missing_revisions(br2)
 
772
        [u'REVISION-ID-2A']
 
773
        >>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
 
774
        >>> br1.missing_revisions(br2)
 
775
        Traceback (most recent call last):
 
776
        DivergedBranches: These branches have diverged.
 
777
        """
 
778
        self_history = self.revision_history()
 
779
        self_len = len(self_history)
 
780
        other_history = other.revision_history()
 
781
        other_len = len(other_history)
 
782
        common_index = min(self_len, other_len) -1
 
783
        if common_index >= 0 and \
 
784
            self_history[common_index] != other_history[common_index]:
 
785
            raise DivergedBranches(self, other)
 
786
 
 
787
        if stop_revision is None:
 
788
            stop_revision = other_len
 
789
        elif stop_revision > other_len:
 
790
            raise bzrlib.errors.NoSuchRevision(self, stop_revision)
 
791
        
 
792
        return other_history[self_len:stop_revision]
 
793
 
 
794
 
 
795
    def update_revisions(self, other, stop_revision=None):
 
796
        """Pull in all new revisions from other branch.
 
797
        """
 
798
        from bzrlib.fetch import greedy_fetch
 
799
 
 
800
        pb = bzrlib.ui.ui_factory.progress_bar()
 
801
        pb.update('comparing histories')
 
802
 
 
803
        revision_ids = self.missing_revisions(other, stop_revision)
 
804
 
 
805
        if len(revision_ids) > 0:
 
806
            count = greedy_fetch(self, other, revision_ids[-1], pb)[0]
 
807
        else:
 
808
            count = 0
 
809
        self.append_revision(*revision_ids)
 
810
        ## note("Added %d revisions." % count)
 
811
        pb.clear()
 
812
 
 
813
    def install_revisions(self, other, revision_ids, pb):
 
814
        if hasattr(other.revision_store, "prefetch"):
 
815
            other.revision_store.prefetch(revision_ids)
 
816
        if hasattr(other.inventory_store, "prefetch"):
 
817
            inventory_ids = [other.get_revision(r).inventory_id
 
818
                             for r in revision_ids]
 
819
            other.inventory_store.prefetch(inventory_ids)
 
820
 
 
821
        if pb is None:
 
822
            pb = bzrlib.ui.ui_factory.progress_bar()
 
823
                
 
824
        revisions = []
 
825
        needed_texts = set()
 
826
        i = 0
 
827
 
 
828
        failures = set()
 
829
        for i, rev_id in enumerate(revision_ids):
 
830
            pb.update('fetching revision', i+1, len(revision_ids))
 
831
            try:
 
832
                rev = other.get_revision(rev_id)
 
833
            except bzrlib.errors.NoSuchRevision:
 
834
                failures.add(rev_id)
 
835
                continue
 
836
 
 
837
            revisions.append(rev)
 
838
            inv = other.get_inventory(str(rev.inventory_id))
 
839
            for key, entry in inv.iter_entries():
 
840
                if entry.text_id is None:
 
841
                    continue
 
842
                if entry.text_id not in self.text_store:
 
843
                    needed_texts.add(entry.text_id)
 
844
 
 
845
        pb.clear()
 
846
                    
 
847
        count, cp_fail = self.text_store.copy_multi(other.text_store, 
 
848
                                                    needed_texts)
 
849
        #print "Added %d texts." % count 
 
850
        inventory_ids = [ f.inventory_id for f in revisions ]
 
851
        count, cp_fail = self.inventory_store.copy_multi(other.inventory_store, 
 
852
                                                         inventory_ids)
 
853
        #print "Added %d inventories." % count 
 
854
        revision_ids = [ f.revision_id for f in revisions]
 
855
 
 
856
        count, cp_fail = self.revision_store.copy_multi(other.revision_store, 
 
857
                                                          revision_ids,
 
858
                                                          permit_failure=True)
 
859
        assert len(cp_fail) == 0 
 
860
        return count, failures
 
861
       
 
862
 
 
863
    def commit(self, *args, **kw):
 
864
        from bzrlib.commit import commit
 
865
        commit(self, *args, **kw)
 
866
        
 
867
 
 
868
    def lookup_revision(self, revision):
 
869
        """Return the revision identifier for a given revision information."""
 
870
        revno, info = self._get_revision_info(revision)
 
871
        return info
 
872
 
 
873
 
 
874
    def revision_id_to_revno(self, revision_id):
 
875
        """Given a revision id, return its revno"""
 
876
        history = self.revision_history()
 
877
        try:
 
878
            return history.index(revision_id) + 1
 
879
        except ValueError:
 
880
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
 
881
 
 
882
 
 
883
    def get_revision_info(self, revision):
 
884
        """Return (revno, revision id) for revision identifier.
 
885
 
 
886
        revision can be an integer, in which case it is assumed to be revno (though
 
887
            this will translate negative values into positive ones)
 
888
        revision can also be a string, in which case it is parsed for something like
 
889
            'date:' or 'revid:' etc.
 
890
        """
 
891
        revno, rev_id = self._get_revision_info(revision)
 
892
        if revno is None:
 
893
            raise bzrlib.errors.NoSuchRevision(self, revision)
 
894
        return revno, rev_id
 
895
 
 
896
    def get_rev_id(self, revno, history=None):
 
897
        """Find the revision id of the specified revno."""
575
898
        if revno == 0:
576
899
            return None
577
 
 
578
 
        try:
579
 
            # list is 0-based; revisions are 1-based
580
 
            return self.revision_history()[revno-1]
581
 
        except IndexError:
582
 
            bailout("no such revision %s" % revno)
583
 
 
 
900
        if history is None:
 
901
            history = self.revision_history()
 
902
        elif revno <= 0 or revno > len(history):
 
903
            raise bzrlib.errors.NoSuchRevision(self, revno)
 
904
        return history[revno - 1]
 
905
 
 
906
    def _get_revision_info(self, revision):
 
907
        """Return (revno, revision id) for revision specifier.
 
908
 
 
909
        revision can be an integer, in which case it is assumed to be revno
 
910
        (though this will translate negative values into positive ones)
 
911
        revision can also be a string, in which case it is parsed for something
 
912
        like 'date:' or 'revid:' etc.
 
913
 
 
914
        A revid is always returned.  If it is None, the specifier referred to
 
915
        the null revision.  If the revid does not occur in the revision
 
916
        history, revno will be None.
 
917
        """
 
918
        
 
919
        if revision is None:
 
920
            return 0, None
 
921
        revno = None
 
922
        try:# Convert to int if possible
 
923
            revision = int(revision)
 
924
        except ValueError:
 
925
            pass
 
926
        revs = self.revision_history()
 
927
        if isinstance(revision, int):
 
928
            if revision < 0:
 
929
                revno = len(revs) + revision + 1
 
930
            else:
 
931
                revno = revision
 
932
            rev_id = self.get_rev_id(revno, revs)
 
933
        elif isinstance(revision, basestring):
 
934
            for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
 
935
                if revision.startswith(prefix):
 
936
                    result = func(self, revs, revision)
 
937
                    if len(result) > 1:
 
938
                        revno, rev_id = result
 
939
                    else:
 
940
                        revno = result[0]
 
941
                        rev_id = self.get_rev_id(revno, revs)
 
942
                    break
 
943
            else:
 
944
                raise BzrError('No namespace registered for string: %r' %
 
945
                               revision)
 
946
        else:
 
947
            raise TypeError('Unhandled revision type %s' % revision)
 
948
 
 
949
        if revno is None:
 
950
            if rev_id is None:
 
951
                raise bzrlib.errors.NoSuchRevision(self, revision)
 
952
        return revno, rev_id
 
953
 
 
954
    def _namespace_revno(self, revs, revision):
 
955
        """Lookup a revision by revision number"""
 
956
        assert revision.startswith('revno:')
 
957
        try:
 
958
            return (int(revision[6:]),)
 
959
        except ValueError:
 
960
            return None
 
961
    REVISION_NAMESPACES['revno:'] = _namespace_revno
 
962
 
 
963
    def _namespace_revid(self, revs, revision):
 
964
        assert revision.startswith('revid:')
 
965
        rev_id = revision[len('revid:'):]
 
966
        try:
 
967
            return revs.index(rev_id) + 1, rev_id
 
968
        except ValueError:
 
969
            return None, rev_id
 
970
    REVISION_NAMESPACES['revid:'] = _namespace_revid
 
971
 
 
972
    def _namespace_last(self, revs, revision):
 
973
        assert revision.startswith('last:')
 
974
        try:
 
975
            offset = int(revision[5:])
 
976
        except ValueError:
 
977
            return (None,)
 
978
        else:
 
979
            if offset <= 0:
 
980
                raise BzrError('You must supply a positive value for --revision last:XXX')
 
981
            return (len(revs) - offset + 1,)
 
982
    REVISION_NAMESPACES['last:'] = _namespace_last
 
983
 
 
984
    def _namespace_tag(self, revs, revision):
 
985
        assert revision.startswith('tag:')
 
986
        raise BzrError('tag: namespace registered, but not implemented.')
 
987
    REVISION_NAMESPACES['tag:'] = _namespace_tag
 
988
 
 
989
    def _namespace_date(self, revs, revision):
 
990
        assert revision.startswith('date:')
 
991
        import datetime
 
992
        # Spec for date revisions:
 
993
        #   date:value
 
994
        #   value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
 
995
        #   it can also start with a '+/-/='. '+' says match the first
 
996
        #   entry after the given date. '-' is match the first entry before the date
 
997
        #   '=' is match the first entry after, but still on the given date.
 
998
        #
 
999
        #   +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
 
1000
        #   -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
 
1001
        #   =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
 
1002
        #       May 13th, 2005 at 0:00
 
1003
        #
 
1004
        #   So the proper way of saying 'give me all entries for today' is:
 
1005
        #       -r {date:+today}:{date:-tomorrow}
 
1006
        #   The default is '=' when not supplied
 
1007
        val = revision[5:]
 
1008
        match_style = '='
 
1009
        if val[:1] in ('+', '-', '='):
 
1010
            match_style = val[:1]
 
1011
            val = val[1:]
 
1012
 
 
1013
        today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
 
1014
        if val.lower() == 'yesterday':
 
1015
            dt = today - datetime.timedelta(days=1)
 
1016
        elif val.lower() == 'today':
 
1017
            dt = today
 
1018
        elif val.lower() == 'tomorrow':
 
1019
            dt = today + datetime.timedelta(days=1)
 
1020
        else:
 
1021
            import re
 
1022
            # This should be done outside the function to avoid recompiling it.
 
1023
            _date_re = re.compile(
 
1024
                    r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
 
1025
                    r'(,|T)?\s*'
 
1026
                    r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
 
1027
                )
 
1028
            m = _date_re.match(val)
 
1029
            if not m or (not m.group('date') and not m.group('time')):
 
1030
                raise BzrError('Invalid revision date %r' % revision)
 
1031
 
 
1032
            if m.group('date'):
 
1033
                year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
 
1034
            else:
 
1035
                year, month, day = today.year, today.month, today.day
 
1036
            if m.group('time'):
 
1037
                hour = int(m.group('hour'))
 
1038
                minute = int(m.group('minute'))
 
1039
                if m.group('second'):
 
1040
                    second = int(m.group('second'))
 
1041
                else:
 
1042
                    second = 0
 
1043
            else:
 
1044
                hour, minute, second = 0,0,0
 
1045
 
 
1046
            dt = datetime.datetime(year=year, month=month, day=day,
 
1047
                    hour=hour, minute=minute, second=second)
 
1048
        first = dt
 
1049
        last = None
 
1050
        reversed = False
 
1051
        if match_style == '-':
 
1052
            reversed = True
 
1053
        elif match_style == '=':
 
1054
            last = dt + datetime.timedelta(days=1)
 
1055
 
 
1056
        if reversed:
 
1057
            for i in range(len(revs)-1, -1, -1):
 
1058
                r = self.get_revision(revs[i])
 
1059
                # TODO: Handle timezone.
 
1060
                dt = datetime.datetime.fromtimestamp(r.timestamp)
 
1061
                if first >= dt and (last is None or dt >= last):
 
1062
                    return (i+1,)
 
1063
        else:
 
1064
            for i in range(len(revs)):
 
1065
                r = self.get_revision(revs[i])
 
1066
                # TODO: Handle timezone.
 
1067
                dt = datetime.datetime.fromtimestamp(r.timestamp)
 
1068
                if first <= dt and (last is None or dt <= last):
 
1069
                    return (i+1,)
 
1070
    REVISION_NAMESPACES['date:'] = _namespace_date
584
1071
 
585
1072
    def revision_tree(self, revision_id):
586
1073
        """Return Tree for a revision on this branch.
587
1074
 
588
1075
        `revision_id` may be None for the null revision, in which case
589
1076
        an `EmptyTree` is returned."""
590
 
 
 
1077
        # TODO: refactor this to use an existing revision object
 
1078
        # so we don't need to read it in twice.
591
1079
        if revision_id == None:
592
1080
            return EmptyTree()
593
1081
        else:
597
1085
 
598
1086
    def working_tree(self):
599
1087
        """Return a `Tree` for the working copy."""
 
1088
        from bzrlib.workingtree import WorkingTree
600
1089
        return WorkingTree(self.base, self.read_working_inventory())
601
1090
 
602
1091
 
604
1093
        """Return `Tree` object for last revision.
605
1094
 
606
1095
        If there are no revisions yet, return an `EmptyTree`.
607
 
 
608
 
        >>> b = ScratchBranch(files=['foo'])
609
 
        >>> b.basis_tree().has_filename('foo')
610
 
        False
611
 
        >>> b.working_tree().has_filename('foo')
612
 
        True
613
 
        >>> b.add('foo')
614
 
        >>> b.commit('add foo')
615
 
        >>> b.basis_tree().has_filename('foo')
616
 
        True
617
1096
        """
618
1097
        r = self.last_patch()
619
1098
        if r == None:
623
1102
 
624
1103
 
625
1104
 
626
 
    def write_log(self, show_timezone='original'):
627
 
        """Write out human-readable log of commits to this branch
628
 
 
629
 
        :param utc: If true, show dates in universal time, not local time."""
630
 
        ## TODO: Option to choose either original, utc or local timezone
631
 
        revno = 1
632
 
        precursor = None
633
 
        for p in self.revision_history():
634
 
            print '-' * 40
635
 
            print 'revno:', revno
636
 
            ## TODO: Show hash if --id is given.
637
 
            ##print 'revision-hash:', p
638
 
            rev = self.get_revision(p)
639
 
            print 'committer:', rev.committer
640
 
            print 'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
641
 
                                                 show_timezone))
642
 
 
643
 
            ## opportunistic consistency check, same as check_patch_chaining
644
 
            if rev.precursor != precursor:
645
 
                bailout("mismatched precursor!")
646
 
 
647
 
            print 'message:'
648
 
            if not rev.message:
649
 
                print '  (no message)'
650
 
            else:
651
 
                for l in rev.message.split('\n'):
652
 
                    print '  ' + l
653
 
 
654
 
            revno += 1
655
 
            precursor = p
656
 
 
657
 
 
658
 
 
659
 
    def show_status(branch, show_all=False):
660
 
        """Display single-line status for non-ignored working files.
661
 
 
662
 
        The list is show sorted in order by file name.
663
 
 
664
 
        >>> b = ScratchBranch(files=['foo', 'foo~'])
665
 
        >>> b.show_status()
666
 
        ?       foo
667
 
        >>> b.add('foo')
668
 
        >>> b.show_status()
669
 
        A       foo
670
 
        >>> b.commit("add foo")
671
 
        >>> b.show_status()
672
 
        >>> os.unlink(b._rel('foo'))
673
 
        >>> b.show_status()
674
 
        D       foo
675
 
        
676
 
 
677
 
        :todo: Get state for single files.
678
 
 
679
 
        :todo: Perhaps show a slash at the end of directory names.        
680
 
 
681
 
        """
682
 
 
683
 
        # We have to build everything into a list first so that it can
684
 
        # sorted by name, incorporating all the different sources.
685
 
 
686
 
        # FIXME: Rather than getting things in random order and then sorting,
687
 
        # just step through in order.
688
 
 
689
 
        # Interesting case: the old ID for a file has been removed,
690
 
        # but a new file has been created under that name.
691
 
 
692
 
        old = branch.basis_tree()
693
 
        old_inv = old.inventory
694
 
        new = branch.working_tree()
695
 
        new_inv = new.inventory
696
 
 
697
 
        for fs, fid, oldname, newname, kind in diff_trees(old, new):
698
 
            if fs == 'R':
699
 
                show_status(fs, kind,
700
 
                            oldname + ' => ' + newname)
701
 
            elif fs == 'A' or fs == 'M':
702
 
                show_status(fs, kind, newname)
703
 
            elif fs == 'D':
704
 
                show_status(fs, kind, oldname)
705
 
            elif fs == '.':
706
 
                if show_all:
707
 
                    show_status(fs, kind, newname)
708
 
            elif fs == 'I':
709
 
                if show_all:
710
 
                    show_status(fs, kind, newname)
711
 
            elif fs == '?':
712
 
                show_status(fs, kind, newname)
713
 
            else:
714
 
                bailout("wierd file state %r" % ((fs, fid),))
715
 
                
 
1105
    def rename_one(self, from_rel, to_rel):
 
1106
        """Rename one file.
 
1107
 
 
1108
        This can change the directory or the filename or both.
 
1109
        """
 
1110
        self.lock_write()
 
1111
        try:
 
1112
            tree = self.working_tree()
 
1113
            inv = tree.inventory
 
1114
            if not tree.has_filename(from_rel):
 
1115
                raise BzrError("can't rename: old working file %r does not exist" % from_rel)
 
1116
            if tree.has_filename(to_rel):
 
1117
                raise BzrError("can't rename: new working file %r already exists" % to_rel)
 
1118
 
 
1119
            file_id = inv.path2id(from_rel)
 
1120
            if file_id == None:
 
1121
                raise BzrError("can't rename: old name %r is not versioned" % from_rel)
 
1122
 
 
1123
            if inv.path2id(to_rel):
 
1124
                raise BzrError("can't rename: new name %r is already versioned" % to_rel)
 
1125
 
 
1126
            to_dir, to_tail = os.path.split(to_rel)
 
1127
            to_dir_id = inv.path2id(to_dir)
 
1128
            if to_dir_id == None and to_dir != '':
 
1129
                raise BzrError("can't determine destination directory id for %r" % to_dir)
 
1130
 
 
1131
            mutter("rename_one:")
 
1132
            mutter("  file_id    {%s}" % file_id)
 
1133
            mutter("  from_rel   %r" % from_rel)
 
1134
            mutter("  to_rel     %r" % to_rel)
 
1135
            mutter("  to_dir     %r" % to_dir)
 
1136
            mutter("  to_dir_id  {%s}" % to_dir_id)
 
1137
 
 
1138
            inv.rename(file_id, to_dir_id, to_tail)
 
1139
 
 
1140
            from_abs = self.abspath(from_rel)
 
1141
            to_abs = self.abspath(to_rel)
 
1142
            try:
 
1143
                os.rename(from_abs, to_abs)
 
1144
            except OSError, e:
 
1145
                raise BzrError("failed to rename %r to %r: %s"
 
1146
                        % (from_abs, to_abs, e[1]),
 
1147
                        ["rename rolled back"])
 
1148
 
 
1149
            self._write_inventory(inv)
 
1150
        finally:
 
1151
            self.unlock()
 
1152
 
 
1153
 
 
1154
    def move(self, from_paths, to_name):
 
1155
        """Rename files.
 
1156
 
 
1157
        to_name must exist as a versioned directory.
 
1158
 
 
1159
        If to_name exists and is a directory, the files are moved into
 
1160
        it, keeping their old names.  If it is a directory, 
 
1161
 
 
1162
        Note that to_name is only the last component of the new name;
 
1163
        this doesn't change the directory.
 
1164
 
 
1165
        This returns a list of (from_path, to_path) pairs for each
 
1166
        entry that is moved.
 
1167
        """
 
1168
        result = []
 
1169
        self.lock_write()
 
1170
        try:
 
1171
            ## TODO: Option to move IDs only
 
1172
            assert not isinstance(from_paths, basestring)
 
1173
            tree = self.working_tree()
 
1174
            inv = tree.inventory
 
1175
            to_abs = self.abspath(to_name)
 
1176
            if not isdir(to_abs):
 
1177
                raise BzrError("destination %r is not a directory" % to_abs)
 
1178
            if not tree.has_filename(to_name):
 
1179
                raise BzrError("destination %r not in working directory" % to_abs)
 
1180
            to_dir_id = inv.path2id(to_name)
 
1181
            if to_dir_id == None and to_name != '':
 
1182
                raise BzrError("destination %r is not a versioned directory" % to_name)
 
1183
            to_dir_ie = inv[to_dir_id]
 
1184
            if to_dir_ie.kind not in ('directory', 'root_directory'):
 
1185
                raise BzrError("destination %r is not a directory" % to_abs)
 
1186
 
 
1187
            to_idpath = inv.get_idpath(to_dir_id)
 
1188
 
 
1189
            for f in from_paths:
 
1190
                if not tree.has_filename(f):
 
1191
                    raise BzrError("%r does not exist in working tree" % f)
 
1192
                f_id = inv.path2id(f)
 
1193
                if f_id == None:
 
1194
                    raise BzrError("%r is not versioned" % f)
 
1195
                name_tail = splitpath(f)[-1]
 
1196
                dest_path = appendpath(to_name, name_tail)
 
1197
                if tree.has_filename(dest_path):
 
1198
                    raise BzrError("destination %r already exists" % dest_path)
 
1199
                if f_id in to_idpath:
 
1200
                    raise BzrError("can't move %r to a subdirectory of itself" % f)
 
1201
 
 
1202
            # OK, so there's a race here, it's possible that someone will
 
1203
            # create a file in this interval and then the rename might be
 
1204
            # left half-done.  But we should have caught most problems.
 
1205
 
 
1206
            for f in from_paths:
 
1207
                name_tail = splitpath(f)[-1]
 
1208
                dest_path = appendpath(to_name, name_tail)
 
1209
                result.append((f, dest_path))
 
1210
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
 
1211
                try:
 
1212
                    os.rename(self.abspath(f), self.abspath(dest_path))
 
1213
                except OSError, e:
 
1214
                    raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
 
1215
                            ["rename rolled back"])
 
1216
 
 
1217
            self._write_inventory(inv)
 
1218
        finally:
 
1219
            self.unlock()
 
1220
 
 
1221
        return result
 
1222
 
 
1223
 
 
1224
    def revert(self, filenames, old_tree=None, backups=True):
 
1225
        """Restore selected files to the versions from a previous tree.
 
1226
 
 
1227
        backups
 
1228
            If true (default) backups are made of files before
 
1229
            they're renamed.
 
1230
        """
 
1231
        from bzrlib.errors import NotVersionedError, BzrError
 
1232
        from bzrlib.atomicfile import AtomicFile
 
1233
        from bzrlib.osutils import backup_file
 
1234
        
 
1235
        inv = self.read_working_inventory()
 
1236
        if old_tree is None:
 
1237
            old_tree = self.basis_tree()
 
1238
        old_inv = old_tree.inventory
 
1239
 
 
1240
        nids = []
 
1241
        for fn in filenames:
 
1242
            file_id = inv.path2id(fn)
 
1243
            if not file_id:
 
1244
                raise NotVersionedError("not a versioned file", fn)
 
1245
            if not old_inv.has_id(file_id):
 
1246
                raise BzrError("file not present in old tree", fn, file_id)
 
1247
            nids.append((fn, file_id))
 
1248
            
 
1249
        # TODO: Rename back if it was previously at a different location
 
1250
 
 
1251
        # TODO: If given a directory, restore the entire contents from
 
1252
        # the previous version.
 
1253
 
 
1254
        # TODO: Make a backup to a temporary file.
 
1255
 
 
1256
        # TODO: If the file previously didn't exist, delete it?
 
1257
        for fn, file_id in nids:
 
1258
            backup_file(fn)
 
1259
            
 
1260
            f = AtomicFile(fn, 'wb')
 
1261
            try:
 
1262
                f.write(old_tree.get_file(file_id).read())
 
1263
                f.commit()
 
1264
            finally:
 
1265
                f.close()
 
1266
 
 
1267
 
 
1268
    def pending_merges(self):
 
1269
        """Return a list of pending merges.
 
1270
 
 
1271
        These are revisions that have been merged into the working
 
1272
        directory but not yet committed.
 
1273
        """
 
1274
        cfn = self.controlfilename('pending-merges')
 
1275
        if not os.path.exists(cfn):
 
1276
            return []
 
1277
        p = []
 
1278
        for l in self.controlfile('pending-merges', 'r').readlines():
 
1279
            p.append(l.rstrip('\n'))
 
1280
        return p
 
1281
 
 
1282
 
 
1283
    def add_pending_merge(self, revision_id):
 
1284
        from bzrlib.revision import validate_revision_id
 
1285
 
 
1286
        validate_revision_id(revision_id)
 
1287
 
 
1288
        p = self.pending_merges()
 
1289
        if revision_id in p:
 
1290
            return
 
1291
        p.append(revision_id)
 
1292
        self.set_pending_merges(p)
 
1293
 
 
1294
 
 
1295
    def set_pending_merges(self, rev_list):
 
1296
        from bzrlib.atomicfile import AtomicFile
 
1297
        self.lock_write()
 
1298
        try:
 
1299
            f = AtomicFile(self.controlfilename('pending-merges'))
 
1300
            try:
 
1301
                for l in rev_list:
 
1302
                    print >>f, l
 
1303
                f.commit()
 
1304
            finally:
 
1305
                f.close()
 
1306
        finally:
 
1307
            self.unlock()
 
1308
 
 
1309
 
 
1310
    def get_parent(self):
 
1311
        """Return the parent location of the branch.
 
1312
 
 
1313
        This is the default location for push/pull/missing.  The usual
 
1314
        pattern is that the user can override it by specifying a
 
1315
        location.
 
1316
        """
 
1317
        import errno
 
1318
        _locs = ['parent', 'pull', 'x-pull']
 
1319
        for l in _locs:
 
1320
            try:
 
1321
                return self.controlfile(l, 'r').read().strip('\n')
 
1322
            except IOError, e:
 
1323
                if e.errno != errno.ENOENT:
 
1324
                    raise
 
1325
        return None
 
1326
 
 
1327
 
 
1328
    def set_parent(self, url):
 
1329
        # TODO: Maybe delete old location files?
 
1330
        from bzrlib.atomicfile import AtomicFile
 
1331
        self.lock_write()
 
1332
        try:
 
1333
            f = AtomicFile(self.controlfilename('parent'))
 
1334
            try:
 
1335
                f.write(url + '\n')
 
1336
                f.commit()
 
1337
            finally:
 
1338
                f.close()
 
1339
        finally:
 
1340
            self.unlock()
 
1341
 
 
1342
    def check_revno(self, revno):
 
1343
        """\
 
1344
        Check whether a revno corresponds to any revision.
 
1345
        Zero (the NULL revision) is considered valid.
 
1346
        """
 
1347
        if revno != 0:
 
1348
            self.check_real_revno(revno)
 
1349
            
 
1350
    def check_real_revno(self, revno):
 
1351
        """\
 
1352
        Check whether a revno corresponds to a real revision.
 
1353
        Zero (the NULL revision) is considered invalid
 
1354
        """
 
1355
        if revno < 1 or revno > self.revno():
 
1356
            raise InvalidRevisionNumber(revno)
 
1357
        
 
1358
        
716
1359
 
717
1360
 
718
1361
class ScratchBranch(Branch):
722
1365
    >>> isdir(b.base)
723
1366
    True
724
1367
    >>> bd = b.base
725
 
    >>> del b
 
1368
    >>> b.destroy()
726
1369
    >>> isdir(bd)
727
1370
    False
728
1371
    """
729
 
    def __init__(self, files = []):
 
1372
    def __init__(self, files=[], dirs=[], base=None):
730
1373
        """Make a test branch.
731
1374
 
732
1375
        This creates a temporary directory and runs init-tree in it.
733
1376
 
734
1377
        If any files are listed, they are created in the working copy.
735
1378
        """
736
 
        Branch.__init__(self, tempfile.mkdtemp(), init=True)
 
1379
        from tempfile import mkdtemp
 
1380
        init = False
 
1381
        if base is None:
 
1382
            base = mkdtemp()
 
1383
            init = True
 
1384
        Branch.__init__(self, base, init=init)
 
1385
        for d in dirs:
 
1386
            os.mkdir(self.abspath(d))
 
1387
            
737
1388
        for f in files:
738
1389
            file(os.path.join(self.base, f), 'w').write('content of %s' % f)
739
1390
 
740
1391
 
 
1392
    def clone(self):
 
1393
        """
 
1394
        >>> orig = ScratchBranch(files=["file1", "file2"])
 
1395
        >>> clone = orig.clone()
 
1396
        >>> os.path.samefile(orig.base, clone.base)
 
1397
        False
 
1398
        >>> os.path.isfile(os.path.join(clone.base, "file1"))
 
1399
        True
 
1400
        """
 
1401
        from shutil import copytree
 
1402
        from tempfile import mkdtemp
 
1403
        base = mkdtemp()
 
1404
        os.rmdir(base)
 
1405
        copytree(self.base, base, symlinks=True)
 
1406
        return ScratchBranch(base=base)
 
1407
 
 
1408
 
 
1409
        
741
1410
    def __del__(self):
 
1411
        self.destroy()
 
1412
 
 
1413
    def destroy(self):
742
1414
        """Destroy the test branch, removing the scratch directory."""
743
 
        shutil.rmtree(self.base)
 
1415
        from shutil import rmtree
 
1416
        try:
 
1417
            if self.base:
 
1418
                mutter("delete ScratchBranch %s" % self.base)
 
1419
                rmtree(self.base)
 
1420
        except OSError, e:
 
1421
            # Work around for shutil.rmtree failing on Windows when
 
1422
            # readonly files are encountered
 
1423
            mutter("hit exception in destroying ScratchBranch: %s" % e)
 
1424
            for root, dirs, files in os.walk(self.base, topdown=False):
 
1425
                for name in files:
 
1426
                    os.chmod(os.path.join(root, name), 0700)
 
1427
            rmtree(self.base)
 
1428
        self.base = None
744
1429
 
745
1430
    
746
1431
 
756
1441
        ## mutter('check %r for control file' % ((head, tail), ))
757
1442
        if tail == bzrlib.BZRDIR:
758
1443
            return True
 
1444
        if filename == head:
 
1445
            break
759
1446
        filename = head
760
1447
    return False
761
1448
 
762
1449
 
763
1450
 
764
 
def _gen_revision_id(when):
765
 
    """Return new revision-id."""
766
 
    s = '%s-%s-' % (user_email(), compact_date(when))
767
 
    s += hexlify(rand_bytes(8))
768
 
    return s
769
 
 
770
 
 
771
 
def _gen_file_id(name):
 
1451
def gen_file_id(name):
772
1452
    """Return new file id.
773
1453
 
774
1454
    This should probably generate proper UUIDs, but for the moment we
775
1455
    cope with just randomness because running uuidgen every time is
776
1456
    slow."""
777
 
    assert '/' not in name
778
 
    while name[0] == '.':
779
 
        name = name[1:]
 
1457
    import re
 
1458
    from binascii import hexlify
 
1459
    from time import time
 
1460
 
 
1461
    # get last component
 
1462
    idx = name.rfind('/')
 
1463
    if idx != -1:
 
1464
        name = name[idx+1 : ]
 
1465
    idx = name.rfind('\\')
 
1466
    if idx != -1:
 
1467
        name = name[idx+1 : ]
 
1468
 
 
1469
    # make it not a hidden file
 
1470
    name = name.lstrip('.')
 
1471
 
 
1472
    # remove any wierd characters; we don't escape them but rather
 
1473
    # just pull them out
 
1474
    name = re.sub(r'[^\w.]', '', name)
 
1475
 
780
1476
    s = hexlify(rand_bytes(8))
781
 
    return '-'.join((name, compact_date(time.time()), s))
782
 
 
 
1477
    return '-'.join((name, compact_date(time()), s))
 
1478
 
 
1479
 
 
1480
def gen_root_id():
 
1481
    """Return a new tree-root file id."""
 
1482
    return gen_file_id('TREE_ROOT')
 
1483
 
 
1484
 
 
1485
def copy_branch(branch_from, to_location, revision=None):
 
1486
    """Copy branch_from into the existing directory to_location.
 
1487
 
 
1488
    revision
 
1489
        If not None, only revisions up to this point will be copied.
 
1490
        The head of the new branch will be that revision.
 
1491
 
 
1492
    to_location
 
1493
        The name of a local directory that exists but is empty.
 
1494
    """
 
1495
    from bzrlib.merge import merge
 
1496
 
 
1497
    assert isinstance(branch_from, Branch)
 
1498
    assert isinstance(to_location, basestring)
 
1499
    
 
1500
    br_to = Branch(to_location, init=True)
 
1501
    br_to.set_root_id(branch_from.get_root_id())
 
1502
    if revision is None:
 
1503
        revno = branch_from.revno()
 
1504
    else:
 
1505
        revno, rev_id = branch_from.get_revision_info(revision)
 
1506
    br_to.update_revisions(branch_from, stop_revision=revno)
 
1507
    merge((to_location, -1), (to_location, 0), this_dir=to_location,
 
1508
          check_clean=False, ignore_zero=True)
 
1509
    
 
1510
    from_location = branch_from.base
 
1511
    br_to.set_parent(branch_from.base)
783
1512