← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Martin Pool
  • Date: 2005-06-28 03:02:31 UTC
  • Revision ID: mbp@sourcefrog.net-20050628030231-d311e4ebcd467ef4
Merge John's import-speedup branch:

                                                                                         
  777 John Arbash Meinel <john@arbash-meinel.com>       Sun 2005-06-26 22:20:32 -0500
      revision-id: john@arbash-meinel.com-20050627032031-e82a50db3863b18e
      bzr selftest was not using the correct bzr

  776 John Arbash Meinel <john@arbash-meinel.com>       Sun 2005-06-26 22:20:22 -0500
      revision-id: john@arbash-meinel.com-20050627032021-c9f21fde989ddaee
      Add was using an old mutter

  775 John Arbash Meinel <john@arbash-meinel.com>       Sun 2005-06-26 22:02:33 -0500
      revision-id: john@arbash-meinel.com-20050627030233-9165cfe98fc63298
      Cleaned up to be less different

  774 John Arbash Meinel <john@arbash-meinel.com>       Sun 2005-06-26 21:54:53 -0500
      revision-id: john@arbash-meinel.com-20050627025452-4260d0e744edef43
      Allow BZR_PLUGIN_PATH='' to negate plugin loading.

  773 John Arbash Meinel <john@arbash-meinel.com>       Sun 2005-06-26 21:49:34 -0500
      revision-id: john@arbash-meinel.com-20050627024933-b7158f67b7b9eae5
      Finished the previous cleanup (allowing load_plugins to be called twice)

  772 John Arbash Meinel <john@arbash-meinel.com>       Sun 2005-06-26 21:45:08 -0500
      revision-id: john@arbash-meinel.com-20050627024508-723b1df510d196fc
      Work on making the tests pass. versioning.py is calling run_cmd directly, but plugins have been loaded.

  771 John Arbash Meinel <john@arbash-meinel.com>       Sun 2005-06-26 21:32:29 -0500
      revision-id: john@arbash-meinel.com-20050627023228-79972744d7c53e15
      Got it down a little bit more by removing import of tree and inventory.

  770 John Arbash Meinel <john@arbash-meinel.com>       Sun 2005-06-26 21:26:05 -0500
      revision-id: john@arbash-meinel.com-20050627022604-350b9773ef622f95
      Reducing the number of import from bzrlib/__init__.py and bzrlib/branch.py

  769 John Arbash Meinel <john@arbash-meinel.com>       Sun 2005-06-26 20:32:25 -0500
      revision-id: john@arbash-meinel.com-20050627013225-32dd044f10d23948
      Updated revision.py and xml.py to include SubElement.

  768 John Arbash Meinel <john@arbash-meinel.com>       Sun 2005-06-26 20:03:56 -0500
      revision-id: john@arbash-meinel.com-20050627010356-ee66919e1c377faf
      Minor typo

  767 John Arbash Meinel <john@arbash-meinel.com>       Sun 2005-06-26 20:03:13 -0500
      revision-id: john@arbash-meinel.com-20050627010312-40d024007eb85051
      Caching the import

  766 John Arbash Meinel <john@arbash-meinel.com>       Sun 2005-06-26 19:51:47 -0500
      revision-id: john@arbash-meinel.com-20050627005147-5281c99e48ed1834
      Created wrapper functions for lazy import of ElementTree

  765 John Arbash Meinel <john@arbash-meinel.com>       Sun 2005-06-26 19:46:37 -0500
      revision-id: john@arbash-meinel.com-20050627004636-bf432902004a94c5
      Removed all of the test imports of cElementTree

  764 John Arbash Meinel <john@arbash-meinel.com>       Sun 2005-06-26 19:43:59 -0500
      revision-id: john@arbash-meinel.com-20050627004358-d137fbe9570dd71b
      Trying to make bzr startup faster.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/branch.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
 
from sets import Set
19
 
 
20
 
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
21
 
import traceback, socket, fnmatch, difflib, time
22
 
from binascii import hexlify
 
18
import sys, os
23
19
 
24
20
import bzrlib
25
 
from inventory import Inventory
26
 
from trace import mutter, note
27
 
from tree import Tree, EmptyTree, RevisionTree
28
 
from inventory import InventoryEntry, Inventory
29
 
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
30
 
     format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
31
 
     joinpath, sha_string, file_kind, local_time_offset, appendpath
32
 
from store import ImmutableStore
33
 
from revision import Revision
34
 
from errors import bailout, BzrError
35
 
from textui import show_status
36
 
from diff import diff_trees
 
21
from bzrlib.trace import mutter, note
 
22
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, splitpath, \
 
23
     sha_file, appendpath, file_kind
 
24
from bzrlib.errors import BzrError
37
25
 
38
26
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
39
27
## TODO: Maybe include checks for common corruption of newlines, etc?
46
34
        return remotebranch.RemoteBranch(f, **args)
47
35
    else:
48
36
        return Branch(f, **args)
 
37
 
 
38
 
 
39
def find_cached_branch(f, cache_root, **args):
 
40
    from remotebranch import RemoteBranch
 
41
    br = find_branch(f, **args)
 
42
    def cacheify(br, store_name):
 
43
        from meta_store import CachedStore
 
44
        cache_path = os.path.join(cache_root, store_name)
 
45
        os.mkdir(cache_path)
 
46
        new_store = CachedStore(getattr(br, store_name), cache_path)
 
47
        setattr(br, store_name, new_store)
 
48
 
 
49
    if isinstance(br, RemoteBranch):
 
50
        cacheify(br, 'inventory_store')
 
51
        cacheify(br, 'text_store')
 
52
        cacheify(br, 'revision_store')
 
53
    return br
 
54
 
 
55
 
 
56
def _relpath(base, path):
 
57
    """Return path relative to base, or raise exception.
 
58
 
 
59
    The path may be either an absolute path or a path relative to the
 
60
    current working directory.
 
61
 
 
62
    Lifted out of Branch.relpath for ease of testing.
 
63
 
 
64
    os.path.commonprefix (python2.4) has a bad bug that it works just
 
65
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
 
66
    avoids that problem."""
 
67
    rp = os.path.abspath(path)
 
68
 
 
69
    s = []
 
70
    head = rp
 
71
    while len(head) >= len(base):
 
72
        if head == base:
 
73
            break
 
74
        head, tail = os.path.split(head)
 
75
        if tail:
 
76
            s.insert(0, tail)
 
77
    else:
 
78
        from errors import NotBranchError
 
79
        raise NotBranchError("path %r is not within branch %r" % (rp, base))
 
80
 
 
81
    return os.sep.join(s)
49
82
        
50
83
 
51
84
def find_branch_root(f=None):
78
111
            raise BzrError('%r is not in a branch' % orig_f)
79
112
        f = head
80
113
    
 
114
class DivergedBranches(Exception):
 
115
    def __init__(self, branch1, branch2):
 
116
        self.branch1 = branch1
 
117
        self.branch2 = branch2
 
118
        Exception.__init__(self, "These branches have diverged.")
 
119
 
 
120
 
 
121
class NoSuchRevision(BzrError):
 
122
    def __init__(self, branch, revision):
 
123
        self.branch = branch
 
124
        self.revision = revision
 
125
        msg = "Branch %s has no revision %d" % (branch, revision)
 
126
        BzrError.__init__(self, msg)
81
127
 
82
128
 
83
129
######################################################################
84
130
# branch objects
85
131
 
86
 
class Branch:
 
132
class Branch(object):
87
133
    """Branch holding a history of revisions.
88
134
 
89
135
    base
90
136
        Base directory of the branch.
 
137
 
 
138
    _lock_mode
 
139
        None, or 'r' or 'w'
 
140
 
 
141
    _lock_count
 
142
        If _lock_mode is true, a positive count of the number of times the
 
143
        lock has been taken.
 
144
 
 
145
    _lock
 
146
        Lock object from bzrlib.lock.
91
147
    """
92
 
    _lockmode = None
 
148
    base = None
 
149
    _lock_mode = None
 
150
    _lock_count = None
 
151
    _lock = None
93
152
    
94
 
    def __init__(self, base, init=False, find_root=True, lock_mode='w'):
 
153
    def __init__(self, base, init=False, find_root=True):
95
154
        """Create new branch object at a particular location.
96
155
 
97
156
        base -- Base directory for the branch.
106
165
        In the test suite, creation of new trees is tested using the
107
166
        `ScratchBranch` class.
108
167
        """
 
168
        from bzrlib.store import ImmutableStore
109
169
        if init:
110
170
            self.base = os.path.realpath(base)
111
171
            self._make_control()
114
174
        else:
115
175
            self.base = os.path.realpath(base)
116
176
            if not isdir(self.controlfilename('.')):
117
 
                bailout("not a bzr branch: %s" % quotefn(base),
118
 
                        ['use "bzr init" to initialize a new working tree',
119
 
                         'current bzr can only operate from top-of-tree'])
 
177
                from errors import NotBranchError
 
178
                raise NotBranchError("not a bzr branch: %s" % quotefn(base),
 
179
                                     ['use "bzr init" to initialize a new working tree',
 
180
                                      'current bzr can only operate from top-of-tree'])
120
181
        self._check_format()
121
 
        self.lock(lock_mode)
122
182
 
123
183
        self.text_store = ImmutableStore(self.controlfilename('text-store'))
124
184
        self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
132
192
    __repr__ = __str__
133
193
 
134
194
 
135
 
 
136
 
    def lock(self, mode='w'):
137
 
        """Lock the on-disk branch, excluding other processes."""
138
 
        try:
139
 
            import fcntl, errno
140
 
 
141
 
            if mode == 'w':
142
 
                lm = fcntl.LOCK_EX
143
 
                om = os.O_WRONLY | os.O_CREAT
144
 
            elif mode == 'r':
145
 
                lm = fcntl.LOCK_SH
146
 
                om = os.O_RDONLY
147
 
            else:
148
 
                raise BzrError("invalid locking mode %r" % mode)
149
 
 
150
 
            try:
151
 
                lockfile = os.open(self.controlfilename('branch-lock'), om)
152
 
            except OSError, e:
153
 
                if e.errno == errno.ENOENT:
154
 
                    # might not exist on branches from <0.0.4
155
 
                    self.controlfile('branch-lock', 'w').close()
156
 
                    lockfile = os.open(self.controlfilename('branch-lock'), om)
157
 
                else:
158
 
                    raise e
 
195
    def __del__(self):
 
196
        if self._lock_mode or self._lock:
 
197
            from warnings import warn
 
198
            warn("branch %r was not explicitly unlocked" % self)
 
199
            self._lock.unlock()
 
200
 
 
201
 
 
202
 
 
203
    def lock_write(self):
 
204
        if self._lock_mode:
 
205
            if self._lock_mode != 'w':
 
206
                from errors import LockError
 
207
                raise LockError("can't upgrade to a write lock from %r" %
 
208
                                self._lock_mode)
 
209
            self._lock_count += 1
 
210
        else:
 
211
            from bzrlib.lock import WriteLock
 
212
 
 
213
            self._lock = WriteLock(self.controlfilename('branch-lock'))
 
214
            self._lock_mode = 'w'
 
215
            self._lock_count = 1
 
216
 
 
217
 
 
218
 
 
219
    def lock_read(self):
 
220
        if self._lock_mode:
 
221
            assert self._lock_mode in ('r', 'w'), \
 
222
                   "invalid lock mode %r" % self._lock_mode
 
223
            self._lock_count += 1
 
224
        else:
 
225
            from bzrlib.lock import ReadLock
 
226
 
 
227
            self._lock = ReadLock(self.controlfilename('branch-lock'))
 
228
            self._lock_mode = 'r'
 
229
            self._lock_count = 1
 
230
                        
 
231
 
159
232
            
160
 
            fcntl.lockf(lockfile, lm)
161
 
            def unlock():
162
 
                fcntl.lockf(lockfile, fcntl.LOCK_UN)
163
 
                os.close(lockfile)
164
 
                self._lockmode = None
165
 
            self.unlock = unlock
166
 
            self._lockmode = mode
167
 
        except ImportError:
168
 
            warning("please write a locking method for platform %r" % sys.platform)
169
 
            def unlock():
170
 
                self._lockmode = None
171
 
            self.unlock = unlock
172
 
            self._lockmode = mode
173
 
 
174
 
 
175
 
    def _need_readlock(self):
176
 
        if self._lockmode not in ['r', 'w']:
177
 
            raise BzrError('need read lock on branch, only have %r' % self._lockmode)
178
 
 
179
 
    def _need_writelock(self):
180
 
        if self._lockmode not in ['w']:
181
 
            raise BzrError('need write lock on branch, only have %r' % self._lockmode)
 
233
    def unlock(self):
 
234
        if not self._lock_mode:
 
235
            from errors import LockError
 
236
            raise LockError('branch %r is not locked' % (self))
 
237
 
 
238
        if self._lock_count > 1:
 
239
            self._lock_count -= 1
 
240
        else:
 
241
            self._lock.unlock()
 
242
            self._lock = None
 
243
            self._lock_mode = self._lock_count = None
182
244
 
183
245
 
184
246
    def abspath(self, name):
190
252
        """Return path relative to this branch of something inside it.
191
253
 
192
254
        Raises an error if path is not in this branch."""
193
 
        rp = os.path.realpath(path)
194
 
        # FIXME: windows
195
 
        if not rp.startswith(self.base):
196
 
            bailout("path %r is not within branch %r" % (rp, self.base))
197
 
        rp = rp[len(self.base):]
198
 
        rp = rp.lstrip(os.sep)
199
 
        return rp
 
255
        return _relpath(self.base, path)
200
256
 
201
257
 
202
258
    def controlfilename(self, file_or_path):
203
259
        """Return location relative to branch."""
204
 
        if isinstance(file_or_path, types.StringTypes):
 
260
        if isinstance(file_or_path, basestring):
205
261
            file_or_path = [file_or_path]
206
262
        return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
207
263
 
234
290
 
235
291
 
236
292
    def _make_control(self):
 
293
        from bzrlib.inventory import Inventory
237
294
        os.mkdir(self.controlfilename([]))
238
295
        self.controlfile('README', 'w').write(
239
296
            "This is a Bazaar-NG control directory.\n"
240
 
            "Do not change any files in this directory.")
 
297
            "Do not change any files in this directory.\n")
241
298
        self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
242
299
        for d in ('text-store', 'inventory-store', 'revision-store'):
243
300
            os.mkdir(self.controlfilename(d))
263
320
        fmt = self.controlfile('branch-format', 'r').read()
264
321
        fmt.replace('\r\n', '')
265
322
        if fmt != BZR_BRANCH_FORMAT:
266
 
            bailout('sorry, branch format %r not supported' % fmt,
267
 
                    ['use a different bzr version',
268
 
                     'or remove the .bzr directory and "bzr init" again'])
 
323
            raise BzrError('sorry, branch format %r not supported' % fmt,
 
324
                           ['use a different bzr version',
 
325
                            'or remove the .bzr directory and "bzr init" again'])
 
326
 
269
327
 
270
328
 
271
329
    def read_working_inventory(self):
272
330
        """Read the working inventory."""
273
 
        self._need_readlock()
274
 
        before = time.time()
 
331
        from bzrlib.inventory import Inventory
 
332
        from time import time
 
333
        before = time()
275
334
        # ElementTree does its own conversion from UTF-8, so open in
276
335
        # binary.
277
 
        inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
278
 
        mutter("loaded inventory of %d items in %f"
279
 
               % (len(inv), time.time() - before))
280
 
        return inv
281
 
 
 
336
        self.lock_read()
 
337
        try:
 
338
            inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
 
339
            mutter("loaded inventory of %d items in %f"
 
340
                   % (len(inv), time() - before))
 
341
            return inv
 
342
        finally:
 
343
            self.unlock()
 
344
            
282
345
 
283
346
    def _write_inventory(self, inv):
284
347
        """Update the working inventory.
286
349
        That is to say, the inventory describing changes underway, that
287
350
        will be committed to the next revision.
288
351
        """
289
 
        self._need_writelock()
290
 
        ## TODO: factor out to atomicfile?  is rename safe on windows?
291
 
        ## TODO: Maybe some kind of clean/dirty marker on inventory?
292
 
        tmpfname = self.controlfilename('inventory.tmp')
293
 
        tmpf = file(tmpfname, 'wb')
294
 
        inv.write_xml(tmpf)
295
 
        tmpf.close()
296
 
        inv_fname = self.controlfilename('inventory')
297
 
        if sys.platform == 'win32':
298
 
            os.remove(inv_fname)
299
 
        os.rename(tmpfname, inv_fname)
 
352
        self.lock_write()
 
353
        try:
 
354
            from bzrlib.atomicfile import AtomicFile
 
355
 
 
356
            f = AtomicFile(self.controlfilename('inventory'), 'wb')
 
357
            try:
 
358
                inv.write_xml(f)
 
359
                f.commit()
 
360
            finally:
 
361
                f.close()
 
362
        finally:
 
363
            self.unlock()
 
364
        
300
365
        mutter('wrote working inventory')
301
 
 
 
366
            
302
367
 
303
368
    inventory = property(read_working_inventory, _write_inventory, None,
304
369
                         """Inventory for the working copy.""")
305
370
 
306
371
 
307
 
    def add(self, files, verbose=False):
 
372
    def add(self, files, verbose=False, ids=None):
308
373
        """Make files versioned.
309
374
 
310
375
        Note that the command line normally calls smart_add instead.
312
377
        This puts the files in the Added state, so that they will be
313
378
        recorded by the next commit.
314
379
 
 
380
        files
 
381
            List of paths to add, relative to the base of the tree.
 
382
 
 
383
        ids
 
384
            If set, use these instead of automatically generated ids.
 
385
            Must be the same length as the list of files, but may
 
386
            contain None for ids that are to be autogenerated.
 
387
 
315
388
        TODO: Perhaps have an option to add the ids even if the files do
316
 
               not (yet) exist.
 
389
              not (yet) exist.
317
390
 
318
391
        TODO: Perhaps return the ids of the files?  But then again it
319
 
               is easy to retrieve them if they're needed.
320
 
 
321
 
        TODO: Option to specify file id.
 
392
              is easy to retrieve them if they're needed.
322
393
 
323
394
        TODO: Adding a directory should optionally recurse down and
324
 
               add all non-ignored children.  Perhaps do that in a
325
 
               higher-level method.
326
 
 
327
 
        >>> b = ScratchBranch(files=['foo'])
328
 
        >>> 'foo' in b.unknowns()
329
 
        True
330
 
        >>> b.show_status()
331
 
        ?       foo
332
 
        >>> b.add('foo')
333
 
        >>> 'foo' in b.unknowns()
334
 
        False
335
 
        >>> bool(b.inventory.path2id('foo'))
336
 
        True
337
 
        >>> b.show_status()
338
 
        A       foo
339
 
 
340
 
        >>> b.add('foo')
341
 
        Traceback (most recent call last):
342
 
        ...
343
 
        BzrError: ('foo is already versioned', [])
344
 
 
345
 
        >>> b.add(['nothere'])
346
 
        Traceback (most recent call last):
347
 
        BzrError: ('cannot add: not a regular file or directory: nothere', [])
 
395
              add all non-ignored children.  Perhaps do that in a
 
396
              higher-level method.
348
397
        """
349
 
        self._need_writelock()
350
 
 
 
398
        from bzrlib.textui import show_status
351
399
        # TODO: Re-adding a file that is removed in the working copy
352
400
        # should probably put it back with the previous ID.
353
 
        if isinstance(files, types.StringTypes):
 
401
        if isinstance(files, basestring):
 
402
            assert(ids is None or isinstance(ids, basestring))
354
403
            files = [files]
355
 
        
356
 
        inv = self.read_working_inventory()
357
 
        for f in files:
358
 
            if is_control_file(f):
359
 
                bailout("cannot add control file %s" % quotefn(f))
360
 
 
361
 
            fp = splitpath(f)
362
 
 
363
 
            if len(fp) == 0:
364
 
                bailout("cannot add top-level %r" % f)
365
 
                
366
 
            fullpath = os.path.normpath(self.abspath(f))
367
 
 
368
 
            try:
369
 
                kind = file_kind(fullpath)
370
 
            except OSError:
371
 
                # maybe something better?
372
 
                bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
373
 
            
374
 
            if kind != 'file' and kind != 'directory':
375
 
                bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
376
 
 
377
 
            file_id = gen_file_id(f)
378
 
            inv.add_path(f, kind=kind, file_id=file_id)
379
 
 
380
 
            if verbose:
381
 
                show_status('A', kind, quotefn(f))
382
 
                
383
 
            mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
384
 
            
385
 
        self._write_inventory(inv)
386
 
 
 
404
            if ids is not None:
 
405
                ids = [ids]
 
406
 
 
407
        if ids is None:
 
408
            ids = [None] * len(files)
 
409
        else:
 
410
            assert(len(ids) == len(files))
 
411
 
 
412
        self.lock_write()
 
413
        try:
 
414
            inv = self.read_working_inventory()
 
415
            for f,file_id in zip(files, ids):
 
416
                if is_control_file(f):
 
417
                    raise BzrError("cannot add control file %s" % quotefn(f))
 
418
 
 
419
                fp = splitpath(f)
 
420
 
 
421
                if len(fp) == 0:
 
422
                    raise BzrError("cannot add top-level %r" % f)
 
423
 
 
424
                fullpath = os.path.normpath(self.abspath(f))
 
425
 
 
426
                try:
 
427
                    kind = file_kind(fullpath)
 
428
                except OSError:
 
429
                    # maybe something better?
 
430
                    raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
 
431
 
 
432
                if kind != 'file' and kind != 'directory':
 
433
                    raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
 
434
 
 
435
                if file_id is None:
 
436
                    file_id = gen_file_id(f)
 
437
                inv.add_path(f, kind=kind, file_id=file_id)
 
438
 
 
439
                if verbose:
 
440
                    print 'added', quotefn(f)
 
441
 
 
442
                mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
 
443
 
 
444
            self._write_inventory(inv)
 
445
        finally:
 
446
            self.unlock()
 
447
            
387
448
 
388
449
    def print_file(self, file, revno):
389
450
        """Print `file` to stdout."""
390
 
        self._need_readlock()
391
 
        tree = self.revision_tree(self.lookup_revision(revno))
392
 
        # use inventory as it was in that revision
393
 
        file_id = tree.inventory.path2id(file)
394
 
        if not file_id:
395
 
            bailout("%r is not present in revision %d" % (file, revno))
396
 
        tree.print_file(file_id)
397
 
        
 
451
        self.lock_read()
 
452
        try:
 
453
            tree = self.revision_tree(self.lookup_revision(revno))
 
454
            # use inventory as it was in that revision
 
455
            file_id = tree.inventory.path2id(file)
 
456
            if not file_id:
 
457
                raise BzrError("%r is not present in revision %d" % (file, revno))
 
458
            tree.print_file(file_id)
 
459
        finally:
 
460
            self.unlock()
 
461
 
398
462
 
399
463
    def remove(self, files, verbose=False):
400
464
        """Mark nominated files for removal from the inventory.
403
467
 
404
468
        TODO: Refuse to remove modified files unless --force is given?
405
469
 
406
 
        >>> b = ScratchBranch(files=['foo'])
407
 
        >>> b.add('foo')
408
 
        >>> b.inventory.has_filename('foo')
409
 
        True
410
 
        >>> b.remove('foo')
411
 
        >>> b.working_tree().has_filename('foo')
412
 
        True
413
 
        >>> b.inventory.has_filename('foo')
414
 
        False
415
 
        
416
 
        >>> b = ScratchBranch(files=['foo'])
417
 
        >>> b.add('foo')
418
 
        >>> b.commit('one')
419
 
        >>> b.remove('foo')
420
 
        >>> b.commit('two')
421
 
        >>> b.inventory.has_filename('foo') 
422
 
        False
423
 
        >>> b.basis_tree().has_filename('foo') 
424
 
        False
425
 
        >>> b.working_tree().has_filename('foo') 
426
 
        True
427
 
 
428
470
        TODO: Do something useful with directories.
429
471
 
430
472
        TODO: Should this remove the text or not?  Tough call; not
432
474
        is the opposite of add.  Removing it is consistent with most
433
475
        other tools.  Maybe an option.
434
476
        """
 
477
        from bzrlib.textui import show_status
435
478
        ## TODO: Normalize names
436
479
        ## TODO: Remove nested loops; better scalability
437
 
        self._need_writelock()
438
 
 
439
 
        if isinstance(files, types.StringTypes):
 
480
        if isinstance(files, basestring):
440
481
            files = [files]
441
 
        
442
 
        tree = self.working_tree()
443
 
        inv = tree.inventory
444
 
 
445
 
        # do this before any modifications
446
 
        for f in files:
447
 
            fid = inv.path2id(f)
448
 
            if not fid:
449
 
                bailout("cannot remove unversioned file %s" % quotefn(f))
450
 
            mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
451
 
            if verbose:
452
 
                # having remove it, it must be either ignored or unknown
453
 
                if tree.is_ignored(f):
454
 
                    new_status = 'I'
455
 
                else:
456
 
                    new_status = '?'
457
 
                show_status(new_status, inv[fid].kind, quotefn(f))
458
 
            del inv[fid]
459
 
 
 
482
 
 
483
        self.lock_write()
 
484
 
 
485
        try:
 
486
            tree = self.working_tree()
 
487
            inv = tree.inventory
 
488
 
 
489
            # do this before any modifications
 
490
            for f in files:
 
491
                fid = inv.path2id(f)
 
492
                if not fid:
 
493
                    raise BzrError("cannot remove unversioned file %s" % quotefn(f))
 
494
                mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
 
495
                if verbose:
 
496
                    # having remove it, it must be either ignored or unknown
 
497
                    if tree.is_ignored(f):
 
498
                        new_status = 'I'
 
499
                    else:
 
500
                        new_status = '?'
 
501
                    show_status(new_status, inv[fid].kind, quotefn(f))
 
502
                del inv[fid]
 
503
 
 
504
            self._write_inventory(inv)
 
505
        finally:
 
506
            self.unlock()
 
507
 
 
508
 
 
509
    # FIXME: this doesn't need to be a branch method
 
510
    def set_inventory(self, new_inventory_list):
 
511
        from bzrlib.inventory import Inventory, InventoryEntry
 
512
        inv = Inventory()
 
513
        for path, file_id, parent, kind in new_inventory_list:
 
514
            name = os.path.basename(path)
 
515
            if name == "":
 
516
                continue
 
517
            inv.add(InventoryEntry(file_id, name, kind, parent))
460
518
        self._write_inventory(inv)
461
519
 
462
520
 
479
537
        return self.working_tree().unknowns()
480
538
 
481
539
 
482
 
    def commit(self, message, timestamp=None, timezone=None,
483
 
               committer=None,
484
 
               verbose=False):
485
 
        """Commit working copy as a new revision.
486
 
        
487
 
        The basic approach is to add all the file texts into the
488
 
        store, then the inventory, then make a new revision pointing
489
 
        to that inventory and store that.
490
 
        
491
 
        This is not quite safe if the working copy changes during the
492
 
        commit; for the moment that is simply not allowed.  A better
493
 
        approach is to make a temporary copy of the files before
494
 
        computing their hashes, and then add those hashes in turn to
495
 
        the inventory.  This should mean at least that there are no
496
 
        broken hash pointers.  There is no way we can get a snapshot
497
 
        of the whole directory at an instant.  This would also have to
498
 
        be robust against files disappearing, moving, etc.  So the
499
 
        whole thing is a bit hard.
500
 
 
501
 
        timestamp -- if not None, seconds-since-epoch for a
502
 
             postdated/predated commit.
503
 
        """
504
 
        self._need_writelock()
505
 
 
506
 
        ## TODO: Show branch names
507
 
 
508
 
        # TODO: Don't commit if there are no changes, unless forced?
509
 
 
510
 
        # First walk over the working inventory; and both update that
511
 
        # and also build a new revision inventory.  The revision
512
 
        # inventory needs to hold the text-id, sha1 and size of the
513
 
        # actual file versions committed in the revision.  (These are
514
 
        # not present in the working inventory.)  We also need to
515
 
        # detect missing/deleted files, and remove them from the
516
 
        # working inventory.
517
 
 
518
 
        work_inv = self.read_working_inventory()
519
 
        inv = Inventory()
520
 
        basis = self.basis_tree()
521
 
        basis_inv = basis.inventory
522
 
        missing_ids = []
523
 
        for path, entry in work_inv.iter_entries():
524
 
            ## TODO: Cope with files that have gone missing.
525
 
 
526
 
            ## TODO: Check that the file kind has not changed from the previous
527
 
            ## revision of this file (if any).
528
 
 
529
 
            entry = entry.copy()
530
 
 
531
 
            p = self.abspath(path)
532
 
            file_id = entry.file_id
533
 
            mutter('commit prep file %s, id %r ' % (p, file_id))
534
 
 
535
 
            if not os.path.exists(p):
536
 
                mutter("    file is missing, removing from inventory")
537
 
                if verbose:
538
 
                    show_status('D', entry.kind, quotefn(path))
539
 
                missing_ids.append(file_id)
540
 
                continue
541
 
 
542
 
            # TODO: Handle files that have been deleted
543
 
 
544
 
            # TODO: Maybe a special case for empty files?  Seems a
545
 
            # waste to store them many times.
546
 
 
547
 
            inv.add(entry)
548
 
 
549
 
            if basis_inv.has_id(file_id):
550
 
                old_kind = basis_inv[file_id].kind
551
 
                if old_kind != entry.kind:
552
 
                    bailout("entry %r changed kind from %r to %r"
553
 
                            % (file_id, old_kind, entry.kind))
554
 
 
555
 
            if entry.kind == 'directory':
556
 
                if not isdir(p):
557
 
                    bailout("%s is entered as directory but not a directory" % quotefn(p))
558
 
            elif entry.kind == 'file':
559
 
                if not isfile(p):
560
 
                    bailout("%s is entered as file but is not a file" % quotefn(p))
561
 
 
562
 
                content = file(p, 'rb').read()
563
 
 
564
 
                entry.text_sha1 = sha_string(content)
565
 
                entry.text_size = len(content)
566
 
 
567
 
                old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
568
 
                if (old_ie
569
 
                    and (old_ie.text_size == entry.text_size)
570
 
                    and (old_ie.text_sha1 == entry.text_sha1)):
571
 
                    ## assert content == basis.get_file(file_id).read()
572
 
                    entry.text_id = basis_inv[file_id].text_id
573
 
                    mutter('    unchanged from previous text_id {%s}' %
574
 
                           entry.text_id)
575
 
                    
576
 
                else:
577
 
                    entry.text_id = gen_file_id(entry.name)
578
 
                    self.text_store.add(content, entry.text_id)
579
 
                    mutter('    stored with text_id {%s}' % entry.text_id)
580
 
                    if verbose:
581
 
                        if not old_ie:
582
 
                            state = 'A'
583
 
                        elif (old_ie.name == entry.name
584
 
                              and old_ie.parent_id == entry.parent_id):
585
 
                            state = 'M'
586
 
                        else:
587
 
                            state = 'R'
588
 
 
589
 
                        show_status(state, entry.kind, quotefn(path))
590
 
 
591
 
        for file_id in missing_ids:
592
 
            # have to do this later so we don't mess up the iterator.
593
 
            # since parents may be removed before their children we
594
 
            # have to test.
595
 
 
596
 
            # FIXME: There's probably a better way to do this; perhaps
597
 
            # the workingtree should know how to filter itself.
598
 
            if work_inv.has_id(file_id):
599
 
                del work_inv[file_id]
600
 
 
601
 
 
602
 
        inv_id = rev_id = _gen_revision_id(time.time())
603
 
        
604
 
        inv_tmp = tempfile.TemporaryFile()
605
 
        inv.write_xml(inv_tmp)
606
 
        inv_tmp.seek(0)
607
 
        self.inventory_store.add(inv_tmp, inv_id)
608
 
        mutter('new inventory_id is {%s}' % inv_id)
609
 
 
610
 
        self._write_inventory(work_inv)
611
 
 
612
 
        if timestamp == None:
613
 
            timestamp = time.time()
614
 
 
615
 
        if committer == None:
616
 
            committer = username()
617
 
 
618
 
        if timezone == None:
619
 
            timezone = local_time_offset()
620
 
 
621
 
        mutter("building commit log message")
622
 
        rev = Revision(timestamp=timestamp,
623
 
                       timezone=timezone,
624
 
                       committer=committer,
625
 
                       precursor = self.last_patch(),
626
 
                       message = message,
627
 
                       inventory_id=inv_id,
628
 
                       revision_id=rev_id)
629
 
 
630
 
        rev_tmp = tempfile.TemporaryFile()
631
 
        rev.write_xml(rev_tmp)
632
 
        rev_tmp.seek(0)
633
 
        self.revision_store.add(rev_tmp, rev_id)
634
 
        mutter("new revision_id is {%s}" % rev_id)
635
 
        
636
 
        ## XXX: Everything up to here can simply be orphaned if we abort
637
 
        ## the commit; it will leave junk files behind but that doesn't
638
 
        ## matter.
639
 
 
640
 
        ## TODO: Read back the just-generated changeset, and make sure it
641
 
        ## applies and recreates the right state.
642
 
 
643
 
        ## TODO: Also calculate and store the inventory SHA1
644
 
        mutter("committing patch r%d" % (self.revno() + 1))
645
 
 
646
 
 
647
 
        self.append_revision(rev_id)
648
 
        
649
 
        if verbose:
650
 
            note("commited r%d" % self.revno())
651
 
 
652
 
 
653
540
    def append_revision(self, revision_id):
 
541
        from bzrlib.atomicfile import AtomicFile
 
542
 
654
543
        mutter("add {%s} to revision-history" % revision_id)
655
 
        rev_history = self.revision_history()
656
 
 
657
 
        tmprhname = self.controlfilename('revision-history.tmp')
658
 
        rhname = self.controlfilename('revision-history')
659
 
        
660
 
        f = file(tmprhname, 'wt')
661
 
        rev_history.append(revision_id)
662
 
        f.write('\n'.join(rev_history))
663
 
        f.write('\n')
664
 
        f.close()
665
 
 
666
 
        if sys.platform == 'win32':
667
 
            os.remove(rhname)
668
 
        os.rename(tmprhname, rhname)
669
 
        
 
544
        rev_history = self.revision_history() + [revision_id]
 
545
 
 
546
        f = AtomicFile(self.controlfilename('revision-history'))
 
547
        try:
 
548
            for rev_id in rev_history:
 
549
                print >>f, rev_id
 
550
            f.commit()
 
551
        finally:
 
552
            f.close()
670
553
 
671
554
 
672
555
    def get_revision(self, revision_id):
673
556
        """Return the Revision object for a named revision"""
674
 
        self._need_readlock()
 
557
        from bzrlib.revision import Revision
 
558
        if not revision_id or not isinstance(revision_id, basestring):
 
559
            raise ValueError('invalid revision-id: %r' % revision_id)
675
560
        r = Revision.read_xml(self.revision_store[revision_id])
676
561
        assert r.revision_id == revision_id
677
562
        return r
678
563
 
 
564
    def get_revision_sha1(self, revision_id):
 
565
        """Hash the stored value of a revision, and return it."""
 
566
        # In the future, revision entries will be signed. At that
 
567
        # point, it is probably best *not* to include the signature
 
568
        # in the revision hash. Because that lets you re-sign
 
569
        # the revision, (add signatures/remove signatures) and still
 
570
        # have all hash pointers stay consistent.
 
571
        # But for now, just hash the contents.
 
572
        return sha_file(self.revision_store[revision_id])
 
573
 
679
574
 
680
575
    def get_inventory(self, inventory_id):
681
576
        """Get Inventory object by hash.
683
578
        TODO: Perhaps for this and similar methods, take a revision
684
579
               parameter which can be either an integer revno or a
685
580
               string hash."""
686
 
        self._need_readlock()
 
581
        from bzrlib.inventory import Inventory
687
582
        i = Inventory.read_xml(self.inventory_store[inventory_id])
688
583
        return i
689
584
 
 
585
    def get_inventory_sha1(self, inventory_id):
 
586
        """Return the sha1 hash of the inventory entry
 
587
        """
 
588
        return sha_file(self.inventory_store[inventory_id])
 
589
 
690
590
 
691
591
    def get_revision_inventory(self, revision_id):
692
592
        """Return inventory of a past revision."""
693
 
        self._need_readlock()
694
593
        if revision_id == None:
 
594
            from bzrlib.inventory import Inventory
695
595
            return Inventory()
696
596
        else:
697
597
            return self.get_inventory(self.get_revision(revision_id).inventory_id)
703
603
        >>> ScratchBranch().revision_history()
704
604
        []
705
605
        """
706
 
        self._need_readlock()
707
 
        return [l.rstrip('\r\n') for l in self.controlfile('revision-history', 'r').readlines()]
708
 
 
 
606
        self.lock_read()
 
607
        try:
 
608
            return [l.rstrip('\r\n') for l in
 
609
                    self.controlfile('revision-history', 'r').readlines()]
 
610
        finally:
 
611
            self.unlock()
 
612
 
 
613
 
 
614
    def common_ancestor(self, other, self_revno=None, other_revno=None):
 
615
        """
 
616
        >>> import commit
 
617
        >>> sb = ScratchBranch(files=['foo', 'foo~'])
 
618
        >>> sb.common_ancestor(sb) == (None, None)
 
619
        True
 
620
        >>> commit.commit(sb, "Committing first revision", verbose=False)
 
621
        >>> sb.common_ancestor(sb)[0]
 
622
        1
 
623
        >>> clone = sb.clone()
 
624
        >>> commit.commit(sb, "Committing second revision", verbose=False)
 
625
        >>> sb.common_ancestor(sb)[0]
 
626
        2
 
627
        >>> sb.common_ancestor(clone)[0]
 
628
        1
 
629
        >>> commit.commit(clone, "Committing divergent second revision", 
 
630
        ...               verbose=False)
 
631
        >>> sb.common_ancestor(clone)[0]
 
632
        1
 
633
        >>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
 
634
        True
 
635
        >>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
 
636
        True
 
637
        >>> clone2 = sb.clone()
 
638
        >>> sb.common_ancestor(clone2)[0]
 
639
        2
 
640
        >>> sb.common_ancestor(clone2, self_revno=1)[0]
 
641
        1
 
642
        >>> sb.common_ancestor(clone2, other_revno=1)[0]
 
643
        1
 
644
        """
 
645
        my_history = self.revision_history()
 
646
        other_history = other.revision_history()
 
647
        if self_revno is None:
 
648
            self_revno = len(my_history)
 
649
        if other_revno is None:
 
650
            other_revno = len(other_history)
 
651
        indices = range(min((self_revno, other_revno)))
 
652
        indices.reverse()
 
653
        for r in indices:
 
654
            if my_history[r] == other_history[r]:
 
655
                return r+1, my_history[r]
 
656
        return None, None
709
657
 
710
658
    def enum_history(self, direction):
711
659
        """Return (revno, revision_id) for history of branch.
726
674
                yield i, rh[i-1]
727
675
                i -= 1
728
676
        else:
729
 
            raise BzrError('invalid history direction %r' % direction)
 
677
            raise ValueError('invalid history direction', direction)
730
678
 
731
679
 
732
680
    def revno(self):
734
682
 
735
683
        That is equivalent to the number of revisions committed to
736
684
        this branch.
737
 
 
738
 
        >>> b = ScratchBranch()
739
 
        >>> b.revno()
740
 
        0
741
 
        >>> b.commit('no foo')
742
 
        >>> b.revno()
743
 
        1
744
685
        """
745
686
        return len(self.revision_history())
746
687
 
747
688
 
748
689
    def last_patch(self):
749
690
        """Return last patch hash, or None if no history.
750
 
 
751
 
        >>> ScratchBranch().last_patch() == None
752
 
        True
753
691
        """
754
692
        ph = self.revision_history()
755
693
        if ph:
756
694
            return ph[-1]
757
695
        else:
758
696
            return None
 
697
 
 
698
 
 
699
    def missing_revisions(self, other, stop_revision=None):
 
700
        """
 
701
        If self and other have not diverged, return a list of the revisions
 
702
        present in other, but missing from self.
 
703
 
 
704
        >>> from bzrlib.commit import commit
 
705
        >>> bzrlib.trace.silent = True
 
706
        >>> br1 = ScratchBranch()
 
707
        >>> br2 = ScratchBranch()
 
708
        >>> br1.missing_revisions(br2)
 
709
        []
 
710
        >>> commit(br2, "lala!", rev_id="REVISION-ID-1")
 
711
        >>> br1.missing_revisions(br2)
 
712
        [u'REVISION-ID-1']
 
713
        >>> br2.missing_revisions(br1)
 
714
        []
 
715
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1")
 
716
        >>> br1.missing_revisions(br2)
 
717
        []
 
718
        >>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
 
719
        >>> br1.missing_revisions(br2)
 
720
        [u'REVISION-ID-2A']
 
721
        >>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
 
722
        >>> br1.missing_revisions(br2)
 
723
        Traceback (most recent call last):
 
724
        DivergedBranches: These branches have diverged.
 
725
        """
 
726
        self_history = self.revision_history()
 
727
        self_len = len(self_history)
 
728
        other_history = other.revision_history()
 
729
        other_len = len(other_history)
 
730
        common_index = min(self_len, other_len) -1
 
731
        if common_index >= 0 and \
 
732
            self_history[common_index] != other_history[common_index]:
 
733
            raise DivergedBranches(self, other)
 
734
 
 
735
        if stop_revision is None:
 
736
            stop_revision = other_len
 
737
        elif stop_revision > other_len:
 
738
            raise NoSuchRevision(self, stop_revision)
 
739
        
 
740
        return other_history[self_len:stop_revision]
 
741
 
 
742
 
 
743
    def update_revisions(self, other, stop_revision=None):
 
744
        """Pull in all new revisions from other branch.
 
745
        
 
746
        >>> from bzrlib.commit import commit
 
747
        >>> bzrlib.trace.silent = True
 
748
        >>> br1 = ScratchBranch(files=['foo', 'bar'])
 
749
        >>> br1.add('foo')
 
750
        >>> br1.add('bar')
 
751
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
 
752
        >>> br2 = ScratchBranch()
 
753
        >>> br2.update_revisions(br1)
 
754
        Added 2 texts.
 
755
        Added 1 inventories.
 
756
        Added 1 revisions.
 
757
        >>> br2.revision_history()
 
758
        [u'REVISION-ID-1']
 
759
        >>> br2.update_revisions(br1)
 
760
        Added 0 texts.
 
761
        Added 0 inventories.
 
762
        Added 0 revisions.
 
763
        >>> br1.text_store.total_size() == br2.text_store.total_size()
 
764
        True
 
765
        """
 
766
        from bzrlib.progress import ProgressBar
 
767
        try:
 
768
            set
 
769
        except NameError:
 
770
            from sets import Set as set
 
771
 
 
772
        pb = ProgressBar()
 
773
 
 
774
        pb.update('comparing histories')
 
775
        revision_ids = self.missing_revisions(other, stop_revision)
 
776
 
 
777
        if hasattr(other.revision_store, "prefetch"):
 
778
            other.revision_store.prefetch(revision_ids)
 
779
        if hasattr(other.inventory_store, "prefetch"):
 
780
            inventory_ids = [other.get_revision(r).inventory_id
 
781
                             for r in revision_ids]
 
782
            other.inventory_store.prefetch(inventory_ids)
 
783
                
 
784
        revisions = []
 
785
        needed_texts = set()
 
786
        i = 0
 
787
        for rev_id in revision_ids:
 
788
            i += 1
 
789
            pb.update('fetching revision', i, len(revision_ids))
 
790
            rev = other.get_revision(rev_id)
 
791
            revisions.append(rev)
 
792
            inv = other.get_inventory(str(rev.inventory_id))
 
793
            for key, entry in inv.iter_entries():
 
794
                if entry.text_id is None:
 
795
                    continue
 
796
                if entry.text_id not in self.text_store:
 
797
                    needed_texts.add(entry.text_id)
 
798
 
 
799
        pb.clear()
 
800
                    
 
801
        count = self.text_store.copy_multi(other.text_store, needed_texts)
 
802
        print "Added %d texts." % count 
 
803
        inventory_ids = [ f.inventory_id for f in revisions ]
 
804
        count = self.inventory_store.copy_multi(other.inventory_store, 
 
805
                                                inventory_ids)
 
806
        print "Added %d inventories." % count 
 
807
        revision_ids = [ f.revision_id for f in revisions]
 
808
        count = self.revision_store.copy_multi(other.revision_store, 
 
809
                                               revision_ids)
 
810
        for revision_id in revision_ids:
 
811
            self.append_revision(revision_id)
 
812
        print "Added %d revisions." % count
 
813
                    
 
814
        
 
815
    def commit(self, *args, **kw):
 
816
        from bzrlib.commit import commit
 
817
        commit(self, *args, **kw)
759
818
        
760
819
 
761
820
    def lookup_revision(self, revno):
775
834
 
776
835
        `revision_id` may be None for the null revision, in which case
777
836
        an `EmptyTree` is returned."""
778
 
        self._need_readlock()
 
837
        from bzrlib.tree import EmptyTree, RevisionTree
 
838
        # TODO: refactor this to use an existing revision object
 
839
        # so we don't need to read it in twice.
779
840
        if revision_id == None:
780
841
            return EmptyTree()
781
842
        else:
793
854
        """Return `Tree` object for last revision.
794
855
 
795
856
        If there are no revisions yet, return an `EmptyTree`.
796
 
 
797
 
        >>> b = ScratchBranch(files=['foo'])
798
 
        >>> b.basis_tree().has_filename('foo')
799
 
        False
800
 
        >>> b.working_tree().has_filename('foo')
801
 
        True
802
 
        >>> b.add('foo')
803
 
        >>> b.commit('add foo')
804
 
        >>> b.basis_tree().has_filename('foo')
805
 
        True
806
857
        """
 
858
        from bzrlib.tree import EmptyTree, RevisionTree
807
859
        r = self.last_patch()
808
860
        if r == None:
809
861
            return EmptyTree()
817
869
 
818
870
        This can change the directory or the filename or both.
819
871
        """
820
 
        self._need_writelock()
821
 
        tree = self.working_tree()
822
 
        inv = tree.inventory
823
 
        if not tree.has_filename(from_rel):
824
 
            bailout("can't rename: old working file %r does not exist" % from_rel)
825
 
        if tree.has_filename(to_rel):
826
 
            bailout("can't rename: new working file %r already exists" % to_rel)
827
 
            
828
 
        file_id = inv.path2id(from_rel)
829
 
        if file_id == None:
830
 
            bailout("can't rename: old name %r is not versioned" % from_rel)
831
 
 
832
 
        if inv.path2id(to_rel):
833
 
            bailout("can't rename: new name %r is already versioned" % to_rel)
834
 
 
835
 
        to_dir, to_tail = os.path.split(to_rel)
836
 
        to_dir_id = inv.path2id(to_dir)
837
 
        if to_dir_id == None and to_dir != '':
838
 
            bailout("can't determine destination directory id for %r" % to_dir)
839
 
 
840
 
        mutter("rename_one:")
841
 
        mutter("  file_id    {%s}" % file_id)
842
 
        mutter("  from_rel   %r" % from_rel)
843
 
        mutter("  to_rel     %r" % to_rel)
844
 
        mutter("  to_dir     %r" % to_dir)
845
 
        mutter("  to_dir_id  {%s}" % to_dir_id)
846
 
            
847
 
        inv.rename(file_id, to_dir_id, to_tail)
848
 
 
849
 
        print "%s => %s" % (from_rel, to_rel)
850
 
        
851
 
        from_abs = self.abspath(from_rel)
852
 
        to_abs = self.abspath(to_rel)
 
872
        self.lock_write()
853
873
        try:
854
 
            os.rename(from_abs, to_abs)
855
 
        except OSError, e:
856
 
            bailout("failed to rename %r to %r: %s"
857
 
                    % (from_abs, to_abs, e[1]),
858
 
                    ["rename rolled back"])
859
 
 
860
 
        self._write_inventory(inv)
861
 
            
 
874
            tree = self.working_tree()
 
875
            inv = tree.inventory
 
876
            if not tree.has_filename(from_rel):
 
877
                raise BzrError("can't rename: old working file %r does not exist" % from_rel)
 
878
            if tree.has_filename(to_rel):
 
879
                raise BzrError("can't rename: new working file %r already exists" % to_rel)
 
880
 
 
881
            file_id = inv.path2id(from_rel)
 
882
            if file_id == None:
 
883
                raise BzrError("can't rename: old name %r is not versioned" % from_rel)
 
884
 
 
885
            if inv.path2id(to_rel):
 
886
                raise BzrError("can't rename: new name %r is already versioned" % to_rel)
 
887
 
 
888
            to_dir, to_tail = os.path.split(to_rel)
 
889
            to_dir_id = inv.path2id(to_dir)
 
890
            if to_dir_id == None and to_dir != '':
 
891
                raise BzrError("can't determine destination directory id for %r" % to_dir)
 
892
 
 
893
            mutter("rename_one:")
 
894
            mutter("  file_id    {%s}" % file_id)
 
895
            mutter("  from_rel   %r" % from_rel)
 
896
            mutter("  to_rel     %r" % to_rel)
 
897
            mutter("  to_dir     %r" % to_dir)
 
898
            mutter("  to_dir_id  {%s}" % to_dir_id)
 
899
 
 
900
            inv.rename(file_id, to_dir_id, to_tail)
 
901
 
 
902
            print "%s => %s" % (from_rel, to_rel)
 
903
 
 
904
            from_abs = self.abspath(from_rel)
 
905
            to_abs = self.abspath(to_rel)
 
906
            try:
 
907
                os.rename(from_abs, to_abs)
 
908
            except OSError, e:
 
909
                raise BzrError("failed to rename %r to %r: %s"
 
910
                        % (from_abs, to_abs, e[1]),
 
911
                        ["rename rolled back"])
 
912
 
 
913
            self._write_inventory(inv)
 
914
        finally:
 
915
            self.unlock()
862
916
 
863
917
 
864
918
    def move(self, from_paths, to_name):
872
926
        Note that to_name is only the last component of the new name;
873
927
        this doesn't change the directory.
874
928
        """
875
 
        self._need_writelock()
876
 
        ## TODO: Option to move IDs only
877
 
        assert not isinstance(from_paths, basestring)
878
 
        tree = self.working_tree()
879
 
        inv = tree.inventory
880
 
        to_abs = self.abspath(to_name)
881
 
        if not isdir(to_abs):
882
 
            bailout("destination %r is not a directory" % to_abs)
883
 
        if not tree.has_filename(to_name):
884
 
            bailout("destination %r not in working directory" % to_abs)
885
 
        to_dir_id = inv.path2id(to_name)
886
 
        if to_dir_id == None and to_name != '':
887
 
            bailout("destination %r is not a versioned directory" % to_name)
888
 
        to_dir_ie = inv[to_dir_id]
889
 
        if to_dir_ie.kind not in ('directory', 'root_directory'):
890
 
            bailout("destination %r is not a directory" % to_abs)
891
 
 
892
 
        to_idpath = Set(inv.get_idpath(to_dir_id))
893
 
 
894
 
        for f in from_paths:
895
 
            if not tree.has_filename(f):
896
 
                bailout("%r does not exist in working tree" % f)
897
 
            f_id = inv.path2id(f)
898
 
            if f_id == None:
899
 
                bailout("%r is not versioned" % f)
900
 
            name_tail = splitpath(f)[-1]
901
 
            dest_path = appendpath(to_name, name_tail)
902
 
            if tree.has_filename(dest_path):
903
 
                bailout("destination %r already exists" % dest_path)
904
 
            if f_id in to_idpath:
905
 
                bailout("can't move %r to a subdirectory of itself" % f)
906
 
 
907
 
        # OK, so there's a race here, it's possible that someone will
908
 
        # create a file in this interval and then the rename might be
909
 
        # left half-done.  But we should have caught most problems.
910
 
 
911
 
        for f in from_paths:
912
 
            name_tail = splitpath(f)[-1]
913
 
            dest_path = appendpath(to_name, name_tail)
914
 
            print "%s => %s" % (f, dest_path)
915
 
            inv.rename(inv.path2id(f), to_dir_id, name_tail)
 
929
        self.lock_write()
 
930
        try:
 
931
            ## TODO: Option to move IDs only
 
932
            assert not isinstance(from_paths, basestring)
 
933
            tree = self.working_tree()
 
934
            inv = tree.inventory
 
935
            to_abs = self.abspath(to_name)
 
936
            if not isdir(to_abs):
 
937
                raise BzrError("destination %r is not a directory" % to_abs)
 
938
            if not tree.has_filename(to_name):
 
939
                raise BzrError("destination %r not in working directory" % to_abs)
 
940
            to_dir_id = inv.path2id(to_name)
 
941
            if to_dir_id == None and to_name != '':
 
942
                raise BzrError("destination %r is not a versioned directory" % to_name)
 
943
            to_dir_ie = inv[to_dir_id]
 
944
            if to_dir_ie.kind not in ('directory', 'root_directory'):
 
945
                raise BzrError("destination %r is not a directory" % to_abs)
 
946
 
 
947
            to_idpath = inv.get_idpath(to_dir_id)
 
948
 
 
949
            for f in from_paths:
 
950
                if not tree.has_filename(f):
 
951
                    raise BzrError("%r does not exist in working tree" % f)
 
952
                f_id = inv.path2id(f)
 
953
                if f_id == None:
 
954
                    raise BzrError("%r is not versioned" % f)
 
955
                name_tail = splitpath(f)[-1]
 
956
                dest_path = appendpath(to_name, name_tail)
 
957
                if tree.has_filename(dest_path):
 
958
                    raise BzrError("destination %r already exists" % dest_path)
 
959
                if f_id in to_idpath:
 
960
                    raise BzrError("can't move %r to a subdirectory of itself" % f)
 
961
 
 
962
            # OK, so there's a race here, it's possible that someone will
 
963
            # create a file in this interval and then the rename might be
 
964
            # left half-done.  But we should have caught most problems.
 
965
 
 
966
            for f in from_paths:
 
967
                name_tail = splitpath(f)[-1]
 
968
                dest_path = appendpath(to_name, name_tail)
 
969
                print "%s => %s" % (f, dest_path)
 
970
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
 
971
                try:
 
972
                    os.rename(self.abspath(f), self.abspath(dest_path))
 
973
                except OSError, e:
 
974
                    raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
 
975
                            ["rename rolled back"])
 
976
 
 
977
            self._write_inventory(inv)
 
978
        finally:
 
979
            self.unlock()
 
980
 
 
981
 
 
982
    def revert(self, filenames, old_tree=None, backups=True):
 
983
        """Restore selected files to the versions from a previous tree.
 
984
 
 
985
        backups
 
986
            If true (default) backups are made of files before
 
987
            they're renamed.
 
988
        """
 
989
        from bzrlib.errors import NotVersionedError, BzrError
 
990
        from bzrlib.atomicfile import AtomicFile
 
991
        from bzrlib.osutils import backup_file
 
992
        
 
993
        inv = self.read_working_inventory()
 
994
        if old_tree is None:
 
995
            old_tree = self.basis_tree()
 
996
        old_inv = old_tree.inventory
 
997
 
 
998
        nids = []
 
999
        for fn in filenames:
 
1000
            file_id = inv.path2id(fn)
 
1001
            if not file_id:
 
1002
                raise NotVersionedError("not a versioned file", fn)
 
1003
            if not old_inv.has_id(file_id):
 
1004
                raise BzrError("file not present in old tree", fn, file_id)
 
1005
            nids.append((fn, file_id))
 
1006
            
 
1007
        # TODO: Rename back if it was previously at a different location
 
1008
 
 
1009
        # TODO: If given a directory, restore the entire contents from
 
1010
        # the previous version.
 
1011
 
 
1012
        # TODO: Make a backup to a temporary file.
 
1013
 
 
1014
        # TODO: If the file previously didn't exist, delete it?
 
1015
        for fn, file_id in nids:
 
1016
            backup_file(fn)
 
1017
            
 
1018
            f = AtomicFile(fn, 'wb')
916
1019
            try:
917
 
                os.rename(self.abspath(f), self.abspath(dest_path))
918
 
            except OSError, e:
919
 
                bailout("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
920
 
                        ["rename rolled back"])
921
 
 
922
 
        self._write_inventory(inv)
923
 
 
 
1020
                f.write(old_tree.get_file(file_id).read())
 
1021
                f.commit()
 
1022
            finally:
 
1023
                f.close()
924
1024
 
925
1025
 
926
1026
 
935
1035
    >>> isdir(bd)
936
1036
    False
937
1037
    """
938
 
    def __init__(self, files=[], dirs=[]):
 
1038
    def __init__(self, files=[], dirs=[], base=None):
939
1039
        """Make a test branch.
940
1040
 
941
1041
        This creates a temporary directory and runs init-tree in it.
942
1042
 
943
1043
        If any files are listed, they are created in the working copy.
944
1044
        """
945
 
        Branch.__init__(self, tempfile.mkdtemp(), init=True)
 
1045
        from tempfile import mkdtemp
 
1046
        init = False
 
1047
        if base is None:
 
1048
            base = mkdtemp()
 
1049
            init = True
 
1050
        Branch.__init__(self, base, init=init)
946
1051
        for d in dirs:
947
1052
            os.mkdir(self.abspath(d))
948
1053
            
950
1055
            file(os.path.join(self.base, f), 'w').write('content of %s' % f)
951
1056
 
952
1057
 
 
1058
    def clone(self):
 
1059
        """
 
1060
        >>> orig = ScratchBranch(files=["file1", "file2"])
 
1061
        >>> clone = orig.clone()
 
1062
        >>> os.path.samefile(orig.base, clone.base)
 
1063
        False
 
1064
        >>> os.path.isfile(os.path.join(clone.base, "file1"))
 
1065
        True
 
1066
        """
 
1067
        from shutil import copytree
 
1068
        from tempfile import mkdtemp
 
1069
        base = mkdtemp()
 
1070
        os.rmdir(base)
 
1071
        copytree(self.base, base, symlinks=True)
 
1072
        return ScratchBranch(base=base)
 
1073
        
953
1074
    def __del__(self):
954
1075
        self.destroy()
955
1076
 
956
1077
    def destroy(self):
957
1078
        """Destroy the test branch, removing the scratch directory."""
 
1079
        from shutil import rmtree
958
1080
        try:
959
 
            mutter("delete ScratchBranch %s" % self.base)
960
 
            shutil.rmtree(self.base)
 
1081
            if self.base:
 
1082
                mutter("delete ScratchBranch %s" % self.base)
 
1083
                rmtree(self.base)
961
1084
        except OSError, e:
962
1085
            # Work around for shutil.rmtree failing on Windows when
963
1086
            # readonly files are encountered
965
1088
            for root, dirs, files in os.walk(self.base, topdown=False):
966
1089
                for name in files:
967
1090
                    os.chmod(os.path.join(root, name), 0700)
968
 
            shutil.rmtree(self.base)
 
1091
            rmtree(self.base)
969
1092
        self.base = None
970
1093
 
971
1094
    
989
1112
 
990
1113
 
991
1114
 
992
 
def _gen_revision_id(when):
993
 
    """Return new revision-id."""
994
 
    s = '%s-%s-' % (user_email(), compact_date(when))
995
 
    s += hexlify(rand_bytes(8))
996
 
    return s
997
 
 
998
 
 
999
1115
def gen_file_id(name):
1000
1116
    """Return new file id.
1001
1117
 
1002
1118
    This should probably generate proper UUIDs, but for the moment we
1003
1119
    cope with just randomness because running uuidgen every time is
1004
1120
    slow."""
 
1121
    import re
 
1122
    from binascii import hexlify
 
1123
    from time import time
 
1124
 
 
1125
    # get last component
1005
1126
    idx = name.rfind('/')
1006
1127
    if idx != -1:
1007
1128
        name = name[idx+1 : ]
1009
1130
    if idx != -1:
1010
1131
        name = name[idx+1 : ]
1011
1132
 
 
1133
    # make it not a hidden file
1012
1134
    name = name.lstrip('.')
1013
1135
 
 
1136
    # remove any wierd characters; we don't escape them but rather
 
1137
    # just pull them out
 
1138
    name = re.sub(r'[^\w.]', '', name)
 
1139
 
1014
1140
    s = hexlify(rand_bytes(8))
1015
 
    return '-'.join((name, compact_date(time.time()), s))
 
1141
    return '-'.join((name, compact_date(time()), s))