/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Martin Pool
  • Date: 2005-08-04 22:04:40 UTC
  • Revision ID: mbp@sourcefrog.net-20050804220440-99562df8151d1ac5
- add pending merge from aaron

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
 
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
19
 
import traceback, socket, fnmatch, difflib, time
20
 
from binascii import hexlify
 
18
import sys
 
19
import os
21
20
 
22
21
import bzrlib
23
 
from inventory import Inventory
24
 
from trace import mutter, note
25
 
from tree import Tree, EmptyTree, RevisionTree
26
 
from inventory import InventoryEntry, Inventory
27
 
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
28
 
     format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
29
 
     joinpath, sha_string, file_kind, local_time_offset, appendpath
30
 
from store import ImmutableStore
31
 
from revision import Revision
32
 
from errors import bailout, BzrError
33
 
from textui import show_status
34
 
 
 
22
from bzrlib.trace import mutter, note
 
23
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, \
 
24
     splitpath, \
 
25
     sha_file, appendpath, file_kind
 
26
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId
 
27
import bzrlib.errors
 
28
from bzrlib.textui import show_status
 
29
from bzrlib.revision import Revision
 
30
from bzrlib.xml import unpack_xml
 
31
from bzrlib.delta import compare_trees
 
32
from bzrlib.tree import EmptyTree, RevisionTree
 
33
        
35
34
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
36
35
## TODO: Maybe include checks for common corruption of newlines, etc?
37
36
 
38
37
 
 
38
# TODO: Some operations like log might retrieve the same revisions
 
39
# repeatedly to calculate deltas.  We could perhaps have a weakref
 
40
# cache in memory to make this faster.
 
41
 
39
42
 
40
43
def find_branch(f, **args):
41
44
    if f and (f.startswith('http://') or f.startswith('https://')):
43
46
        return remotebranch.RemoteBranch(f, **args)
44
47
    else:
45
48
        return Branch(f, **args)
 
49
 
 
50
 
 
51
def find_cached_branch(f, cache_root, **args):
 
52
    from remotebranch import RemoteBranch
 
53
    br = find_branch(f, **args)
 
54
    def cacheify(br, store_name):
 
55
        from meta_store import CachedStore
 
56
        cache_path = os.path.join(cache_root, store_name)
 
57
        os.mkdir(cache_path)
 
58
        new_store = CachedStore(getattr(br, store_name), cache_path)
 
59
        setattr(br, store_name, new_store)
 
60
 
 
61
    if isinstance(br, RemoteBranch):
 
62
        cacheify(br, 'inventory_store')
 
63
        cacheify(br, 'text_store')
 
64
        cacheify(br, 'revision_store')
 
65
    return br
 
66
 
 
67
 
 
68
def _relpath(base, path):
 
69
    """Return path relative to base, or raise exception.
 
70
 
 
71
    The path may be either an absolute path or a path relative to the
 
72
    current working directory.
 
73
 
 
74
    Lifted out of Branch.relpath for ease of testing.
 
75
 
 
76
    os.path.commonprefix (python2.4) has a bad bug that it works just
 
77
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
 
78
    avoids that problem."""
 
79
    rp = os.path.abspath(path)
 
80
 
 
81
    s = []
 
82
    head = rp
 
83
    while len(head) >= len(base):
 
84
        if head == base:
 
85
            break
 
86
        head, tail = os.path.split(head)
 
87
        if tail:
 
88
            s.insert(0, tail)
 
89
    else:
 
90
        from errors import NotBranchError
 
91
        raise NotBranchError("path %r is not within branch %r" % (rp, base))
 
92
 
 
93
    return os.sep.join(s)
46
94
        
47
95
 
48
96
def find_branch_root(f=None):
75
123
            raise BzrError('%r is not in a branch' % orig_f)
76
124
        f = head
77
125
    
 
126
class DivergedBranches(Exception):
 
127
    def __init__(self, branch1, branch2):
 
128
        self.branch1 = branch1
 
129
        self.branch2 = branch2
 
130
        Exception.__init__(self, "These branches have diverged.")
78
131
 
79
132
 
80
133
######################################################################
85
138
 
86
139
    base
87
140
        Base directory of the branch.
 
141
 
 
142
    _lock_mode
 
143
        None, or 'r' or 'w'
 
144
 
 
145
    _lock_count
 
146
        If _lock_mode is true, a positive count of the number of times the
 
147
        lock has been taken.
 
148
 
 
149
    _lock
 
150
        Lock object from bzrlib.lock.
88
151
    """
89
 
    _lockmode = None
90
152
    base = None
 
153
    _lock_mode = None
 
154
    _lock_count = None
 
155
    _lock = None
91
156
    
92
 
    def __init__(self, base, init=False, find_root=True, lock_mode='w'):
 
157
    # Map some sort of prefix into a namespace
 
158
    # stuff like "revno:10", "revid:", etc.
 
159
    # This should match a prefix with a function which accepts
 
160
    REVISION_NAMESPACES = {}
 
161
 
 
162
    def __init__(self, base, init=False, find_root=True):
93
163
        """Create new branch object at a particular location.
94
164
 
95
165
        base -- Base directory for the branch.
104
174
        In the test suite, creation of new trees is tested using the
105
175
        `ScratchBranch` class.
106
176
        """
 
177
        from bzrlib.store import ImmutableStore
107
178
        if init:
108
179
            self.base = os.path.realpath(base)
109
180
            self._make_control()
112
183
        else:
113
184
            self.base = os.path.realpath(base)
114
185
            if not isdir(self.controlfilename('.')):
115
 
                bailout("not a bzr branch: %s" % quotefn(base),
116
 
                        ['use "bzr init" to initialize a new working tree',
117
 
                         'current bzr can only operate from top-of-tree'])
 
186
                from errors import NotBranchError
 
187
                raise NotBranchError("not a bzr branch: %s" % quotefn(base),
 
188
                                     ['use "bzr init" to initialize a new working tree',
 
189
                                      'current bzr can only operate from top-of-tree'])
118
190
        self._check_format()
119
 
        self.lock(lock_mode)
120
191
 
121
192
        self.text_store = ImmutableStore(self.controlfilename('text-store'))
122
193
        self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
130
201
    __repr__ = __str__
131
202
 
132
203
 
133
 
 
134
 
    def lock(self, mode='w'):
135
 
        """Lock the on-disk branch, excluding other processes."""
136
 
        try:
137
 
            import fcntl, errno
138
 
 
139
 
            if mode == 'w':
140
 
                lm = fcntl.LOCK_EX
141
 
                om = os.O_WRONLY | os.O_CREAT
142
 
            elif mode == 'r':
143
 
                lm = fcntl.LOCK_SH
144
 
                om = os.O_RDONLY
145
 
            else:
146
 
                raise BzrError("invalid locking mode %r" % mode)
147
 
 
148
 
            try:
149
 
                lockfile = os.open(self.controlfilename('branch-lock'), om)
150
 
            except OSError, e:
151
 
                if e.errno == errno.ENOENT:
152
 
                    # might not exist on branches from <0.0.4
153
 
                    self.controlfile('branch-lock', 'w').close()
154
 
                    lockfile = os.open(self.controlfilename('branch-lock'), om)
155
 
                else:
156
 
                    raise e
 
204
    def __del__(self):
 
205
        if self._lock_mode or self._lock:
 
206
            from warnings import warn
 
207
            warn("branch %r was not explicitly unlocked" % self)
 
208
            self._lock.unlock()
 
209
 
 
210
 
 
211
 
 
212
    def lock_write(self):
 
213
        if self._lock_mode:
 
214
            if self._lock_mode != 'w':
 
215
                from errors import LockError
 
216
                raise LockError("can't upgrade to a write lock from %r" %
 
217
                                self._lock_mode)
 
218
            self._lock_count += 1
 
219
        else:
 
220
            from bzrlib.lock import WriteLock
 
221
 
 
222
            self._lock = WriteLock(self.controlfilename('branch-lock'))
 
223
            self._lock_mode = 'w'
 
224
            self._lock_count = 1
 
225
 
 
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
 
157
241
            
158
 
            fcntl.lockf(lockfile, lm)
159
 
            def unlock():
160
 
                fcntl.lockf(lockfile, fcntl.LOCK_UN)
161
 
                os.close(lockfile)
162
 
                self._lockmode = None
163
 
            self.unlock = unlock
164
 
            self._lockmode = mode
165
 
        except ImportError:
166
 
            warning("please write a locking method for platform %r" % sys.platform)
167
 
            def unlock():
168
 
                self._lockmode = None
169
 
            self.unlock = unlock
170
 
            self._lockmode = mode
171
 
 
172
 
 
173
 
    def _need_readlock(self):
174
 
        if self._lockmode not in ['r', 'w']:
175
 
            raise BzrError('need read lock on branch, only have %r' % self._lockmode)
176
 
 
177
 
    def _need_writelock(self):
178
 
        if self._lockmode not in ['w']:
179
 
            raise BzrError('need write lock on branch, only have %r' % self._lockmode)
 
242
    def unlock(self):
 
243
        if not self._lock_mode:
 
244
            from errors import LockError
 
245
            raise LockError('branch %r is not locked' % (self))
 
246
 
 
247
        if self._lock_count > 1:
 
248
            self._lock_count -= 1
 
249
        else:
 
250
            self._lock.unlock()
 
251
            self._lock = None
 
252
            self._lock_mode = self._lock_count = None
180
253
 
181
254
 
182
255
    def abspath(self, name):
188
261
        """Return path relative to this branch of something inside it.
189
262
 
190
263
        Raises an error if path is not in this branch."""
191
 
        rp = os.path.realpath(path)
192
 
        # FIXME: windows
193
 
        if not rp.startswith(self.base):
194
 
            bailout("path %r is not within branch %r" % (rp, self.base))
195
 
        rp = rp[len(self.base):]
196
 
        rp = rp.lstrip(os.sep)
197
 
        return rp
 
264
        return _relpath(self.base, path)
198
265
 
199
266
 
200
267
    def controlfilename(self, file_or_path):
201
268
        """Return location relative to branch."""
202
 
        if isinstance(file_or_path, types.StringTypes):
 
269
        if isinstance(file_or_path, basestring):
203
270
            file_or_path = [file_or_path]
204
271
        return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
205
272
 
232
299
 
233
300
 
234
301
    def _make_control(self):
 
302
        from bzrlib.inventory import Inventory
 
303
        from bzrlib.xml import pack_xml
 
304
        
235
305
        os.mkdir(self.controlfilename([]))
236
306
        self.controlfile('README', 'w').write(
237
307
            "This is a Bazaar-NG control directory.\n"
238
 
            "Do not change any files in this directory.")
 
308
            "Do not change any files in this directory.\n")
239
309
        self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
240
310
        for d in ('text-store', 'inventory-store', 'revision-store'):
241
311
            os.mkdir(self.controlfilename(d))
242
312
        for f in ('revision-history', 'merged-patches',
243
313
                  'pending-merged-patches', 'branch-name',
244
 
                  'branch-lock'):
 
314
                  'branch-lock',
 
315
                  'pending-merges'):
245
316
            self.controlfile(f, 'w').write('')
246
317
        mutter('created control directory in ' + self.base)
247
 
        Inventory().write_xml(self.controlfile('inventory','w'))
 
318
 
 
319
        pack_xml(Inventory(gen_root_id()), self.controlfile('inventory','w'))
248
320
 
249
321
 
250
322
    def _check_format(self):
261
333
        fmt = self.controlfile('branch-format', 'r').read()
262
334
        fmt.replace('\r\n', '')
263
335
        if fmt != BZR_BRANCH_FORMAT:
264
 
            bailout('sorry, branch format %r not supported' % fmt,
265
 
                    ['use a different bzr version',
266
 
                     'or remove the .bzr directory and "bzr init" again'])
267
 
 
 
336
            raise BzrError('sorry, branch format %r not supported' % fmt,
 
337
                           ['use a different bzr version',
 
338
                            'or remove the .bzr directory and "bzr init" again'])
 
339
 
 
340
    def get_root_id(self):
 
341
        """Return the id of this branches root"""
 
342
        inv = self.read_working_inventory()
 
343
        return inv.root.file_id
 
344
 
 
345
    def set_root_id(self, file_id):
 
346
        inv = self.read_working_inventory()
 
347
        orig_root_id = inv.root.file_id
 
348
        del inv._byid[inv.root.file_id]
 
349
        inv.root.file_id = file_id
 
350
        inv._byid[inv.root.file_id] = inv.root
 
351
        for fid in inv:
 
352
            entry = inv[fid]
 
353
            if entry.parent_id in (None, orig_root_id):
 
354
                entry.parent_id = inv.root.file_id
 
355
        self._write_inventory(inv)
268
356
 
269
357
    def read_working_inventory(self):
270
358
        """Read the working inventory."""
271
 
        self._need_readlock()
272
 
        before = time.time()
273
 
        # ElementTree does its own conversion from UTF-8, so open in
274
 
        # binary.
275
 
        inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
276
 
        mutter("loaded inventory of %d items in %f"
277
 
               % (len(inv), time.time() - before))
278
 
        return inv
279
 
 
 
359
        from bzrlib.inventory import Inventory
 
360
        from bzrlib.xml import unpack_xml
 
361
        from time import time
 
362
        before = time()
 
363
        self.lock_read()
 
364
        try:
 
365
            # ElementTree does its own conversion from UTF-8, so open in
 
366
            # binary.
 
367
            inv = unpack_xml(Inventory,
 
368
                             self.controlfile('inventory', 'rb'))
 
369
            mutter("loaded inventory of %d items in %f"
 
370
                   % (len(inv), time() - before))
 
371
            return inv
 
372
        finally:
 
373
            self.unlock()
 
374
            
280
375
 
281
376
    def _write_inventory(self, inv):
282
377
        """Update the working inventory.
284
379
        That is to say, the inventory describing changes underway, that
285
380
        will be committed to the next revision.
286
381
        """
287
 
        self._need_writelock()
288
 
        ## TODO: factor out to atomicfile?  is rename safe on windows?
289
 
        ## TODO: Maybe some kind of clean/dirty marker on inventory?
290
 
        tmpfname = self.controlfilename('inventory.tmp')
291
 
        tmpf = file(tmpfname, 'wb')
292
 
        inv.write_xml(tmpf)
293
 
        tmpf.close()
294
 
        inv_fname = self.controlfilename('inventory')
295
 
        if sys.platform == 'win32':
296
 
            os.remove(inv_fname)
297
 
        os.rename(tmpfname, inv_fname)
 
382
        from bzrlib.atomicfile import AtomicFile
 
383
        from bzrlib.xml import pack_xml
 
384
        
 
385
        self.lock_write()
 
386
        try:
 
387
            f = AtomicFile(self.controlfilename('inventory'), 'wb')
 
388
            try:
 
389
                pack_xml(inv, f)
 
390
                f.commit()
 
391
            finally:
 
392
                f.close()
 
393
        finally:
 
394
            self.unlock()
 
395
        
298
396
        mutter('wrote working inventory')
299
 
 
 
397
            
300
398
 
301
399
    inventory = property(read_working_inventory, _write_inventory, None,
302
400
                         """Inventory for the working copy.""")
310
408
        This puts the files in the Added state, so that they will be
311
409
        recorded by the next commit.
312
410
 
 
411
        files
 
412
            List of paths to add, relative to the base of the tree.
 
413
 
 
414
        ids
 
415
            If set, use these instead of automatically generated ids.
 
416
            Must be the same length as the list of files, but may
 
417
            contain None for ids that are to be autogenerated.
 
418
 
313
419
        TODO: Perhaps have an option to add the ids even if the files do
314
 
               not (yet) exist.
 
420
              not (yet) exist.
315
421
 
316
422
        TODO: Perhaps return the ids of the files?  But then again it
317
 
               is easy to retrieve them if they're needed.
318
 
 
319
 
        TODO: Option to specify file id.
 
423
              is easy to retrieve them if they're needed.
320
424
 
321
425
        TODO: Adding a directory should optionally recurse down and
322
 
               add all non-ignored children.  Perhaps do that in a
323
 
               higher-level method.
 
426
              add all non-ignored children.  Perhaps do that in a
 
427
              higher-level method.
324
428
        """
325
 
        self._need_writelock()
326
 
 
327
429
        # TODO: Re-adding a file that is removed in the working copy
328
430
        # should probably put it back with the previous ID.
329
 
        if isinstance(files, types.StringTypes):
330
 
            assert(ids is None or isinstance(ids, types.StringTypes))
 
431
        if isinstance(files, basestring):
 
432
            assert(ids is None or isinstance(ids, basestring))
331
433
            files = [files]
332
434
            if ids is not None:
333
435
                ids = [ids]
336
438
            ids = [None] * len(files)
337
439
        else:
338
440
            assert(len(ids) == len(files))
339
 
        
340
 
        inv = self.read_working_inventory()
341
 
        for f,file_id in zip(files, ids):
342
 
            if is_control_file(f):
343
 
                bailout("cannot add control file %s" % quotefn(f))
344
 
 
345
 
            fp = splitpath(f)
346
 
 
347
 
            if len(fp) == 0:
348
 
                bailout("cannot add top-level %r" % f)
349
 
                
350
 
            fullpath = os.path.normpath(self.abspath(f))
351
 
 
352
 
            try:
353
 
                kind = file_kind(fullpath)
354
 
            except OSError:
355
 
                # maybe something better?
356
 
                bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
357
 
            
358
 
            if kind != 'file' and kind != 'directory':
359
 
                bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
360
 
 
361
 
            if file_id is None:
362
 
                file_id = gen_file_id(f)
363
 
            inv.add_path(f, kind=kind, file_id=file_id)
364
 
 
365
 
            if verbose:
366
 
                show_status('A', kind, quotefn(f))
367
 
                
368
 
            mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
369
 
            
370
 
        self._write_inventory(inv)
371
 
 
 
441
 
 
442
        self.lock_write()
 
443
        try:
 
444
            inv = self.read_working_inventory()
 
445
            for f,file_id in zip(files, ids):
 
446
                if is_control_file(f):
 
447
                    raise BzrError("cannot add control file %s" % quotefn(f))
 
448
 
 
449
                fp = splitpath(f)
 
450
 
 
451
                if len(fp) == 0:
 
452
                    raise BzrError("cannot add top-level %r" % f)
 
453
 
 
454
                fullpath = os.path.normpath(self.abspath(f))
 
455
 
 
456
                try:
 
457
                    kind = file_kind(fullpath)
 
458
                except OSError:
 
459
                    # maybe something better?
 
460
                    raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
 
461
 
 
462
                if kind != 'file' and kind != 'directory':
 
463
                    raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
 
464
 
 
465
                if file_id is None:
 
466
                    file_id = gen_file_id(f)
 
467
                inv.add_path(f, kind=kind, file_id=file_id)
 
468
 
 
469
                if verbose:
 
470
                    print 'added', quotefn(f)
 
471
 
 
472
                mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
 
473
 
 
474
            self._write_inventory(inv)
 
475
        finally:
 
476
            self.unlock()
 
477
            
372
478
 
373
479
    def print_file(self, file, revno):
374
480
        """Print `file` to stdout."""
375
 
        self._need_readlock()
376
 
        tree = self.revision_tree(self.lookup_revision(revno))
377
 
        # use inventory as it was in that revision
378
 
        file_id = tree.inventory.path2id(file)
379
 
        if not file_id:
380
 
            bailout("%r is not present in revision %d" % (file, revno))
381
 
        tree.print_file(file_id)
382
 
        
 
481
        self.lock_read()
 
482
        try:
 
483
            tree = self.revision_tree(self.lookup_revision(revno))
 
484
            # use inventory as it was in that revision
 
485
            file_id = tree.inventory.path2id(file)
 
486
            if not file_id:
 
487
                raise BzrError("%r is not present in revision %s" % (file, revno))
 
488
            tree.print_file(file_id)
 
489
        finally:
 
490
            self.unlock()
 
491
 
383
492
 
384
493
    def remove(self, files, verbose=False):
385
494
        """Mark nominated files for removal from the inventory.
397
506
        """
398
507
        ## TODO: Normalize names
399
508
        ## TODO: Remove nested loops; better scalability
400
 
        self._need_writelock()
401
 
 
402
 
        if isinstance(files, types.StringTypes):
 
509
        if isinstance(files, basestring):
403
510
            files = [files]
404
 
        
405
 
        tree = self.working_tree()
406
 
        inv = tree.inventory
407
 
 
408
 
        # do this before any modifications
409
 
        for f in files:
410
 
            fid = inv.path2id(f)
411
 
            if not fid:
412
 
                bailout("cannot remove unversioned file %s" % quotefn(f))
413
 
            mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
414
 
            if verbose:
415
 
                # having remove it, it must be either ignored or unknown
416
 
                if tree.is_ignored(f):
417
 
                    new_status = 'I'
418
 
                else:
419
 
                    new_status = '?'
420
 
                show_status(new_status, inv[fid].kind, quotefn(f))
421
 
            del inv[fid]
422
 
 
423
 
        self._write_inventory(inv)
424
 
 
 
511
 
 
512
        self.lock_write()
 
513
 
 
514
        try:
 
515
            tree = self.working_tree()
 
516
            inv = tree.inventory
 
517
 
 
518
            # do this before any modifications
 
519
            for f in files:
 
520
                fid = inv.path2id(f)
 
521
                if not fid:
 
522
                    raise BzrError("cannot remove unversioned file %s" % quotefn(f))
 
523
                mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
 
524
                if verbose:
 
525
                    # having remove it, it must be either ignored or unknown
 
526
                    if tree.is_ignored(f):
 
527
                        new_status = 'I'
 
528
                    else:
 
529
                        new_status = '?'
 
530
                    show_status(new_status, inv[fid].kind, quotefn(f))
 
531
                del inv[fid]
 
532
 
 
533
            self._write_inventory(inv)
 
534
        finally:
 
535
            self.unlock()
 
536
 
 
537
 
 
538
    # FIXME: this doesn't need to be a branch method
425
539
    def set_inventory(self, new_inventory_list):
426
 
        inv = Inventory()
 
540
        from bzrlib.inventory import Inventory, InventoryEntry
 
541
        inv = Inventory(self.get_root_id())
427
542
        for path, file_id, parent, kind in new_inventory_list:
428
543
            name = os.path.basename(path)
429
544
            if name == "":
451
566
        return self.working_tree().unknowns()
452
567
 
453
568
 
454
 
    def append_revision(self, revision_id):
455
 
        mutter("add {%s} to revision-history" % revision_id)
 
569
    def append_revision(self, *revision_ids):
 
570
        from bzrlib.atomicfile import AtomicFile
 
571
 
 
572
        for revision_id in revision_ids:
 
573
            mutter("add {%s} to revision-history" % revision_id)
 
574
 
456
575
        rev_history = self.revision_history()
457
 
 
458
 
        tmprhname = self.controlfilename('revision-history.tmp')
459
 
        rhname = self.controlfilename('revision-history')
460
 
        
461
 
        f = file(tmprhname, 'wt')
462
 
        rev_history.append(revision_id)
463
 
        f.write('\n'.join(rev_history))
464
 
        f.write('\n')
465
 
        f.close()
466
 
 
467
 
        if sys.platform == 'win32':
468
 
            os.remove(rhname)
469
 
        os.rename(tmprhname, rhname)
470
 
        
 
576
        rev_history.extend(revision_ids)
 
577
 
 
578
        f = AtomicFile(self.controlfilename('revision-history'))
 
579
        try:
 
580
            for rev_id in rev_history:
 
581
                print >>f, rev_id
 
582
            f.commit()
 
583
        finally:
 
584
            f.close()
 
585
 
 
586
 
 
587
    def get_revision_xml(self, revision_id):
 
588
        """Return XML file object for revision object."""
 
589
        if not revision_id or not isinstance(revision_id, basestring):
 
590
            raise InvalidRevisionId(revision_id)
 
591
 
 
592
        self.lock_read()
 
593
        try:
 
594
            try:
 
595
                return self.revision_store[revision_id]
 
596
            except IndexError:
 
597
                raise bzrlib.errors.NoSuchRevision(revision_id)
 
598
        finally:
 
599
            self.unlock()
471
600
 
472
601
 
473
602
    def get_revision(self, revision_id):
474
603
        """Return the Revision object for a named revision"""
475
 
        self._need_readlock()
476
 
        r = Revision.read_xml(self.revision_store[revision_id])
 
604
        xml_file = self.get_revision_xml(revision_id)
 
605
 
 
606
        try:
 
607
            r = unpack_xml(Revision, xml_file)
 
608
        except SyntaxError, e:
 
609
            raise bzrlib.errors.BzrError('failed to unpack revision_xml',
 
610
                                         [revision_id,
 
611
                                          str(e)])
 
612
            
477
613
        assert r.revision_id == revision_id
478
614
        return r
479
615
 
480
616
 
 
617
    def get_revision_delta(self, revno):
 
618
        """Return the delta for one revision.
 
619
 
 
620
        The delta is relative to its mainline predecessor, or the
 
621
        empty tree for revision 1.
 
622
        """
 
623
        assert isinstance(revno, int)
 
624
        rh = self.revision_history()
 
625
        if not (1 <= revno <= len(rh)):
 
626
            raise InvalidRevisionNumber(revno)
 
627
 
 
628
        # revno is 1-based; list is 0-based
 
629
 
 
630
        new_tree = self.revision_tree(rh[revno-1])
 
631
        if revno == 1:
 
632
            old_tree = EmptyTree()
 
633
        else:
 
634
            old_tree = self.revision_tree(rh[revno-2])
 
635
 
 
636
        return compare_trees(old_tree, new_tree)
 
637
 
 
638
        
 
639
 
 
640
    def get_revision_sha1(self, revision_id):
 
641
        """Hash the stored value of a revision, and return it."""
 
642
        # In the future, revision entries will be signed. At that
 
643
        # point, it is probably best *not* to include the signature
 
644
        # in the revision hash. Because that lets you re-sign
 
645
        # the revision, (add signatures/remove signatures) and still
 
646
        # have all hash pointers stay consistent.
 
647
        # But for now, just hash the contents.
 
648
        return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
 
649
 
 
650
 
481
651
    def get_inventory(self, inventory_id):
482
652
        """Get Inventory object by hash.
483
653
 
484
654
        TODO: Perhaps for this and similar methods, take a revision
485
655
               parameter which can be either an integer revno or a
486
656
               string hash."""
487
 
        self._need_readlock()
488
 
        i = Inventory.read_xml(self.inventory_store[inventory_id])
489
 
        return i
 
657
        from bzrlib.inventory import Inventory
 
658
        from bzrlib.xml import unpack_xml
 
659
 
 
660
        return unpack_xml(Inventory, self.inventory_store[inventory_id])
 
661
            
 
662
 
 
663
    def get_inventory_sha1(self, inventory_id):
 
664
        """Return the sha1 hash of the inventory entry
 
665
        """
 
666
        return sha_file(self.inventory_store[inventory_id])
490
667
 
491
668
 
492
669
    def get_revision_inventory(self, revision_id):
493
670
        """Return inventory of a past revision."""
494
 
        self._need_readlock()
 
671
        # bzr 0.0.6 imposes the constraint that the inventory_id
 
672
        # must be the same as its revision, so this is trivial.
495
673
        if revision_id == None:
496
 
            return Inventory()
 
674
            from bzrlib.inventory import Inventory
 
675
            return Inventory(self.get_root_id())
497
676
        else:
498
 
            return self.get_inventory(self.get_revision(revision_id).inventory_id)
 
677
            return self.get_inventory(revision_id)
499
678
 
500
679
 
501
680
    def revision_history(self):
504
683
        >>> ScratchBranch().revision_history()
505
684
        []
506
685
        """
507
 
        self._need_readlock()
508
 
        return [l.rstrip('\r\n') for l in self.controlfile('revision-history', 'r').readlines()]
509
 
 
510
 
 
511
 
    def enum_history(self, direction):
512
 
        """Return (revno, revision_id) for history of branch.
513
 
 
514
 
        direction
515
 
            'forward' is from earliest to latest
516
 
            'reverse' is from latest to earliest
517
 
        """
518
 
        rh = self.revision_history()
519
 
        if direction == 'forward':
520
 
            i = 1
521
 
            for rid in rh:
522
 
                yield i, rid
523
 
                i += 1
524
 
        elif direction == 'reverse':
525
 
            i = len(rh)
526
 
            while i > 0:
527
 
                yield i, rh[i-1]
528
 
                i -= 1
529
 
        else:
530
 
            raise ValueError('invalid history direction', direction)
 
686
        self.lock_read()
 
687
        try:
 
688
            return [l.rstrip('\r\n') for l in
 
689
                    self.controlfile('revision-history', 'r').readlines()]
 
690
        finally:
 
691
            self.unlock()
 
692
 
 
693
 
 
694
    def common_ancestor(self, other, self_revno=None, other_revno=None):
 
695
        """
 
696
        >>> import commit
 
697
        >>> sb = ScratchBranch(files=['foo', 'foo~'])
 
698
        >>> sb.common_ancestor(sb) == (None, None)
 
699
        True
 
700
        >>> commit.commit(sb, "Committing first revision", verbose=False)
 
701
        >>> sb.common_ancestor(sb)[0]
 
702
        1
 
703
        >>> clone = sb.clone()
 
704
        >>> commit.commit(sb, "Committing second revision", verbose=False)
 
705
        >>> sb.common_ancestor(sb)[0]
 
706
        2
 
707
        >>> sb.common_ancestor(clone)[0]
 
708
        1
 
709
        >>> commit.commit(clone, "Committing divergent second revision", 
 
710
        ...               verbose=False)
 
711
        >>> sb.common_ancestor(clone)[0]
 
712
        1
 
713
        >>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
 
714
        True
 
715
        >>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
 
716
        True
 
717
        >>> clone2 = sb.clone()
 
718
        >>> sb.common_ancestor(clone2)[0]
 
719
        2
 
720
        >>> sb.common_ancestor(clone2, self_revno=1)[0]
 
721
        1
 
722
        >>> sb.common_ancestor(clone2, other_revno=1)[0]
 
723
        1
 
724
        """
 
725
        my_history = self.revision_history()
 
726
        other_history = other.revision_history()
 
727
        if self_revno is None:
 
728
            self_revno = len(my_history)
 
729
        if other_revno is None:
 
730
            other_revno = len(other_history)
 
731
        indices = range(min((self_revno, other_revno)))
 
732
        indices.reverse()
 
733
        for r in indices:
 
734
            if my_history[r] == other_history[r]:
 
735
                return r+1, my_history[r]
 
736
        return None, None
531
737
 
532
738
 
533
739
    def revno(self):
549
755
            return None
550
756
 
551
757
 
 
758
    def missing_revisions(self, other, stop_revision=None):
 
759
        """
 
760
        If self and other have not diverged, return a list of the revisions
 
761
        present in other, but missing from self.
 
762
 
 
763
        >>> from bzrlib.commit import commit
 
764
        >>> bzrlib.trace.silent = True
 
765
        >>> br1 = ScratchBranch()
 
766
        >>> br2 = ScratchBranch()
 
767
        >>> br1.missing_revisions(br2)
 
768
        []
 
769
        >>> commit(br2, "lala!", rev_id="REVISION-ID-1")
 
770
        >>> br1.missing_revisions(br2)
 
771
        [u'REVISION-ID-1']
 
772
        >>> br2.missing_revisions(br1)
 
773
        []
 
774
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1")
 
775
        >>> br1.missing_revisions(br2)
 
776
        []
 
777
        >>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
 
778
        >>> br1.missing_revisions(br2)
 
779
        [u'REVISION-ID-2A']
 
780
        >>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
 
781
        >>> br1.missing_revisions(br2)
 
782
        Traceback (most recent call last):
 
783
        DivergedBranches: These branches have diverged.
 
784
        """
 
785
        self_history = self.revision_history()
 
786
        self_len = len(self_history)
 
787
        other_history = other.revision_history()
 
788
        other_len = len(other_history)
 
789
        common_index = min(self_len, other_len) -1
 
790
        if common_index >= 0 and \
 
791
            self_history[common_index] != other_history[common_index]:
 
792
            raise DivergedBranches(self, other)
 
793
 
 
794
        if stop_revision is None:
 
795
            stop_revision = other_len
 
796
        elif stop_revision > other_len:
 
797
            raise NoSuchRevision(self, stop_revision)
 
798
        
 
799
        return other_history[self_len:stop_revision]
 
800
 
 
801
 
 
802
    def update_revisions(self, other, stop_revision=None):
 
803
        """Pull in all new revisions from other branch.
 
804
        
 
805
        >>> from bzrlib.commit import commit
 
806
        >>> bzrlib.trace.silent = True
 
807
        >>> br1 = ScratchBranch(files=['foo', 'bar'])
 
808
        >>> br1.add('foo')
 
809
        >>> br1.add('bar')
 
810
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
 
811
        >>> br2 = ScratchBranch()
 
812
        >>> br2.update_revisions(br1)
 
813
        Added 2 texts.
 
814
        Added 1 inventories.
 
815
        Added 1 revisions.
 
816
        >>> br2.revision_history()
 
817
        [u'REVISION-ID-1']
 
818
        >>> br2.update_revisions(br1)
 
819
        Added 0 texts.
 
820
        Added 0 inventories.
 
821
        Added 0 revisions.
 
822
        >>> br1.text_store.total_size() == br2.text_store.total_size()
 
823
        True
 
824
        """
 
825
        from bzrlib.progress import ProgressBar
 
826
 
 
827
        pb = ProgressBar()
 
828
 
 
829
        pb.update('comparing histories')
 
830
        revision_ids = self.missing_revisions(other, stop_revision)
 
831
 
 
832
        if hasattr(other.revision_store, "prefetch"):
 
833
            other.revision_store.prefetch(revision_ids)
 
834
        if hasattr(other.inventory_store, "prefetch"):
 
835
            inventory_ids = [other.get_revision(r).inventory_id
 
836
                             for r in revision_ids]
 
837
            other.inventory_store.prefetch(inventory_ids)
 
838
                
 
839
        revisions = []
 
840
        needed_texts = set()
 
841
        i = 0
 
842
        for rev_id in revision_ids:
 
843
            i += 1
 
844
            pb.update('fetching revision', i, len(revision_ids))
 
845
            rev = other.get_revision(rev_id)
 
846
            revisions.append(rev)
 
847
            inv = other.get_inventory(str(rev.inventory_id))
 
848
            for key, entry in inv.iter_entries():
 
849
                if entry.text_id is None:
 
850
                    continue
 
851
                if entry.text_id not in self.text_store:
 
852
                    needed_texts.add(entry.text_id)
 
853
 
 
854
        pb.clear()
 
855
                    
 
856
        count = self.text_store.copy_multi(other.text_store, needed_texts)
 
857
        print "Added %d texts." % count 
 
858
        inventory_ids = [ f.inventory_id for f in revisions ]
 
859
        count = self.inventory_store.copy_multi(other.inventory_store, 
 
860
                                                inventory_ids)
 
861
        print "Added %d inventories." % count 
 
862
        revision_ids = [ f.revision_id for f in revisions]
 
863
        count = self.revision_store.copy_multi(other.revision_store, 
 
864
                                               revision_ids)
 
865
        for revision_id in revision_ids:
 
866
            self.append_revision(revision_id)
 
867
        print "Added %d revisions." % count
 
868
                    
 
869
        
552
870
    def commit(self, *args, **kw):
553
 
        """Deprecated"""
554
871
        from bzrlib.commit import commit
555
872
        commit(self, *args, **kw)
556
873
        
557
874
 
558
 
    def lookup_revision(self, revno):
559
 
        """Return revision hash for revision number."""
560
 
        if revno == 0:
561
 
            return None
562
 
 
563
 
        try:
564
 
            # list is 0-based; revisions are 1-based
565
 
            return self.revision_history()[revno-1]
566
 
        except IndexError:
567
 
            raise BzrError("no such revision %s" % revno)
568
 
 
 
875
    def lookup_revision(self, revision):
 
876
        """Return the revision identifier for a given revision information."""
 
877
        revno, info = self.get_revision_info(revision)
 
878
        return info
 
879
 
 
880
    def get_revision_info(self, revision):
 
881
        """Return (revno, revision id) for revision identifier.
 
882
 
 
883
        revision can be an integer, in which case it is assumed to be revno (though
 
884
            this will translate negative values into positive ones)
 
885
        revision can also be a string, in which case it is parsed for something like
 
886
            'date:' or 'revid:' etc.
 
887
        """
 
888
        if revision is None:
 
889
            return 0, None
 
890
        revno = None
 
891
        try:# Convert to int if possible
 
892
            revision = int(revision)
 
893
        except ValueError:
 
894
            pass
 
895
        revs = self.revision_history()
 
896
        if isinstance(revision, int):
 
897
            if revision == 0:
 
898
                return 0, None
 
899
            # Mabye we should do this first, but we don't need it if revision == 0
 
900
            if revision < 0:
 
901
                revno = len(revs) + revision + 1
 
902
            else:
 
903
                revno = revision
 
904
        elif isinstance(revision, basestring):
 
905
            for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
 
906
                if revision.startswith(prefix):
 
907
                    revno = func(self, revs, revision)
 
908
                    break
 
909
            else:
 
910
                raise BzrError('No namespace registered for string: %r' % revision)
 
911
 
 
912
        if revno is None or revno <= 0 or revno > len(revs):
 
913
            raise BzrError("no such revision %s" % revision)
 
914
        return revno, revs[revno-1]
 
915
 
 
916
    def _namespace_revno(self, revs, revision):
 
917
        """Lookup a revision by revision number"""
 
918
        assert revision.startswith('revno:')
 
919
        try:
 
920
            return int(revision[6:])
 
921
        except ValueError:
 
922
            return None
 
923
    REVISION_NAMESPACES['revno:'] = _namespace_revno
 
924
 
 
925
    def _namespace_revid(self, revs, revision):
 
926
        assert revision.startswith('revid:')
 
927
        try:
 
928
            return revs.index(revision[6:]) + 1
 
929
        except ValueError:
 
930
            return None
 
931
    REVISION_NAMESPACES['revid:'] = _namespace_revid
 
932
 
 
933
    def _namespace_last(self, revs, revision):
 
934
        assert revision.startswith('last:')
 
935
        try:
 
936
            offset = int(revision[5:])
 
937
        except ValueError:
 
938
            return None
 
939
        else:
 
940
            if offset <= 0:
 
941
                raise BzrError('You must supply a positive value for --revision last:XXX')
 
942
            return len(revs) - offset + 1
 
943
    REVISION_NAMESPACES['last:'] = _namespace_last
 
944
 
 
945
    def _namespace_tag(self, revs, revision):
 
946
        assert revision.startswith('tag:')
 
947
        raise BzrError('tag: namespace registered, but not implemented.')
 
948
    REVISION_NAMESPACES['tag:'] = _namespace_tag
 
949
 
 
950
    def _namespace_date(self, revs, revision):
 
951
        assert revision.startswith('date:')
 
952
        import datetime
 
953
        # Spec for date revisions:
 
954
        #   date:value
 
955
        #   value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
 
956
        #   it can also start with a '+/-/='. '+' says match the first
 
957
        #   entry after the given date. '-' is match the first entry before the date
 
958
        #   '=' is match the first entry after, but still on the given date.
 
959
        #
 
960
        #   +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
 
961
        #   -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
 
962
        #   =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
 
963
        #       May 13th, 2005 at 0:00
 
964
        #
 
965
        #   So the proper way of saying 'give me all entries for today' is:
 
966
        #       -r {date:+today}:{date:-tomorrow}
 
967
        #   The default is '=' when not supplied
 
968
        val = revision[5:]
 
969
        match_style = '='
 
970
        if val[:1] in ('+', '-', '='):
 
971
            match_style = val[:1]
 
972
            val = val[1:]
 
973
 
 
974
        today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
 
975
        if val.lower() == 'yesterday':
 
976
            dt = today - datetime.timedelta(days=1)
 
977
        elif val.lower() == 'today':
 
978
            dt = today
 
979
        elif val.lower() == 'tomorrow':
 
980
            dt = today + datetime.timedelta(days=1)
 
981
        else:
 
982
            import re
 
983
            # This should be done outside the function to avoid recompiling it.
 
984
            _date_re = re.compile(
 
985
                    r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
 
986
                    r'(,|T)?\s*'
 
987
                    r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
 
988
                )
 
989
            m = _date_re.match(val)
 
990
            if not m or (not m.group('date') and not m.group('time')):
 
991
                raise BzrError('Invalid revision date %r' % revision)
 
992
 
 
993
            if m.group('date'):
 
994
                year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
 
995
            else:
 
996
                year, month, day = today.year, today.month, today.day
 
997
            if m.group('time'):
 
998
                hour = int(m.group('hour'))
 
999
                minute = int(m.group('minute'))
 
1000
                if m.group('second'):
 
1001
                    second = int(m.group('second'))
 
1002
                else:
 
1003
                    second = 0
 
1004
            else:
 
1005
                hour, minute, second = 0,0,0
 
1006
 
 
1007
            dt = datetime.datetime(year=year, month=month, day=day,
 
1008
                    hour=hour, minute=minute, second=second)
 
1009
        first = dt
 
1010
        last = None
 
1011
        reversed = False
 
1012
        if match_style == '-':
 
1013
            reversed = True
 
1014
        elif match_style == '=':
 
1015
            last = dt + datetime.timedelta(days=1)
 
1016
 
 
1017
        if reversed:
 
1018
            for i in range(len(revs)-1, -1, -1):
 
1019
                r = self.get_revision(revs[i])
 
1020
                # TODO: Handle timezone.
 
1021
                dt = datetime.datetime.fromtimestamp(r.timestamp)
 
1022
                if first >= dt and (last is None or dt >= last):
 
1023
                    return i+1
 
1024
        else:
 
1025
            for i in range(len(revs)):
 
1026
                r = self.get_revision(revs[i])
 
1027
                # TODO: Handle timezone.
 
1028
                dt = datetime.datetime.fromtimestamp(r.timestamp)
 
1029
                if first <= dt and (last is None or dt <= last):
 
1030
                    return i+1
 
1031
    REVISION_NAMESPACES['date:'] = _namespace_date
569
1032
 
570
1033
    def revision_tree(self, revision_id):
571
1034
        """Return Tree for a revision on this branch.
574
1037
        an `EmptyTree` is returned."""
575
1038
        # TODO: refactor this to use an existing revision object
576
1039
        # so we don't need to read it in twice.
577
 
        self._need_readlock()
578
1040
        if revision_id == None:
579
1041
            return EmptyTree()
580
1042
        else:
606
1068
 
607
1069
        This can change the directory or the filename or both.
608
1070
        """
609
 
        self._need_writelock()
610
 
        tree = self.working_tree()
611
 
        inv = tree.inventory
612
 
        if not tree.has_filename(from_rel):
613
 
            bailout("can't rename: old working file %r does not exist" % from_rel)
614
 
        if tree.has_filename(to_rel):
615
 
            bailout("can't rename: new working file %r already exists" % to_rel)
616
 
            
617
 
        file_id = inv.path2id(from_rel)
618
 
        if file_id == None:
619
 
            bailout("can't rename: old name %r is not versioned" % from_rel)
620
 
 
621
 
        if inv.path2id(to_rel):
622
 
            bailout("can't rename: new name %r is already versioned" % to_rel)
623
 
 
624
 
        to_dir, to_tail = os.path.split(to_rel)
625
 
        to_dir_id = inv.path2id(to_dir)
626
 
        if to_dir_id == None and to_dir != '':
627
 
            bailout("can't determine destination directory id for %r" % to_dir)
628
 
 
629
 
        mutter("rename_one:")
630
 
        mutter("  file_id    {%s}" % file_id)
631
 
        mutter("  from_rel   %r" % from_rel)
632
 
        mutter("  to_rel     %r" % to_rel)
633
 
        mutter("  to_dir     %r" % to_dir)
634
 
        mutter("  to_dir_id  {%s}" % to_dir_id)
635
 
            
636
 
        inv.rename(file_id, to_dir_id, to_tail)
637
 
 
638
 
        print "%s => %s" % (from_rel, to_rel)
639
 
        
640
 
        from_abs = self.abspath(from_rel)
641
 
        to_abs = self.abspath(to_rel)
 
1071
        self.lock_write()
642
1072
        try:
643
 
            os.rename(from_abs, to_abs)
644
 
        except OSError, e:
645
 
            bailout("failed to rename %r to %r: %s"
646
 
                    % (from_abs, to_abs, e[1]),
647
 
                    ["rename rolled back"])
648
 
 
649
 
        self._write_inventory(inv)
650
 
            
 
1073
            tree = self.working_tree()
 
1074
            inv = tree.inventory
 
1075
            if not tree.has_filename(from_rel):
 
1076
                raise BzrError("can't rename: old working file %r does not exist" % from_rel)
 
1077
            if tree.has_filename(to_rel):
 
1078
                raise BzrError("can't rename: new working file %r already exists" % to_rel)
 
1079
 
 
1080
            file_id = inv.path2id(from_rel)
 
1081
            if file_id == None:
 
1082
                raise BzrError("can't rename: old name %r is not versioned" % from_rel)
 
1083
 
 
1084
            if inv.path2id(to_rel):
 
1085
                raise BzrError("can't rename: new name %r is already versioned" % to_rel)
 
1086
 
 
1087
            to_dir, to_tail = os.path.split(to_rel)
 
1088
            to_dir_id = inv.path2id(to_dir)
 
1089
            if to_dir_id == None and to_dir != '':
 
1090
                raise BzrError("can't determine destination directory id for %r" % to_dir)
 
1091
 
 
1092
            mutter("rename_one:")
 
1093
            mutter("  file_id    {%s}" % file_id)
 
1094
            mutter("  from_rel   %r" % from_rel)
 
1095
            mutter("  to_rel     %r" % to_rel)
 
1096
            mutter("  to_dir     %r" % to_dir)
 
1097
            mutter("  to_dir_id  {%s}" % to_dir_id)
 
1098
 
 
1099
            inv.rename(file_id, to_dir_id, to_tail)
 
1100
 
 
1101
            print "%s => %s" % (from_rel, to_rel)
 
1102
 
 
1103
            from_abs = self.abspath(from_rel)
 
1104
            to_abs = self.abspath(to_rel)
 
1105
            try:
 
1106
                os.rename(from_abs, to_abs)
 
1107
            except OSError, e:
 
1108
                raise BzrError("failed to rename %r to %r: %s"
 
1109
                        % (from_abs, to_abs, e[1]),
 
1110
                        ["rename rolled back"])
 
1111
 
 
1112
            self._write_inventory(inv)
 
1113
        finally:
 
1114
            self.unlock()
651
1115
 
652
1116
 
653
1117
    def move(self, from_paths, to_name):
661
1125
        Note that to_name is only the last component of the new name;
662
1126
        this doesn't change the directory.
663
1127
        """
664
 
        self._need_writelock()
665
 
        ## TODO: Option to move IDs only
666
 
        assert not isinstance(from_paths, basestring)
667
 
        tree = self.working_tree()
668
 
        inv = tree.inventory
669
 
        to_abs = self.abspath(to_name)
670
 
        if not isdir(to_abs):
671
 
            bailout("destination %r is not a directory" % to_abs)
672
 
        if not tree.has_filename(to_name):
673
 
            bailout("destination %r not in working directory" % to_abs)
674
 
        to_dir_id = inv.path2id(to_name)
675
 
        if to_dir_id == None and to_name != '':
676
 
            bailout("destination %r is not a versioned directory" % to_name)
677
 
        to_dir_ie = inv[to_dir_id]
678
 
        if to_dir_ie.kind not in ('directory', 'root_directory'):
679
 
            bailout("destination %r is not a directory" % to_abs)
680
 
 
681
 
        to_idpath = inv.get_idpath(to_dir_id)
682
 
 
683
 
        for f in from_paths:
684
 
            if not tree.has_filename(f):
685
 
                bailout("%r does not exist in working tree" % f)
686
 
            f_id = inv.path2id(f)
687
 
            if f_id == None:
688
 
                bailout("%r is not versioned" % f)
689
 
            name_tail = splitpath(f)[-1]
690
 
            dest_path = appendpath(to_name, name_tail)
691
 
            if tree.has_filename(dest_path):
692
 
                bailout("destination %r already exists" % dest_path)
693
 
            if f_id in to_idpath:
694
 
                bailout("can't move %r to a subdirectory of itself" % f)
695
 
 
696
 
        # OK, so there's a race here, it's possible that someone will
697
 
        # create a file in this interval and then the rename might be
698
 
        # left half-done.  But we should have caught most problems.
699
 
 
700
 
        for f in from_paths:
701
 
            name_tail = splitpath(f)[-1]
702
 
            dest_path = appendpath(to_name, name_tail)
703
 
            print "%s => %s" % (f, dest_path)
704
 
            inv.rename(inv.path2id(f), to_dir_id, name_tail)
705
 
            try:
706
 
                os.rename(self.abspath(f), self.abspath(dest_path))
707
 
            except OSError, e:
708
 
                bailout("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
709
 
                        ["rename rolled back"])
710
 
 
711
 
        self._write_inventory(inv)
712
 
 
 
1128
        self.lock_write()
 
1129
        try:
 
1130
            ## TODO: Option to move IDs only
 
1131
            assert not isinstance(from_paths, basestring)
 
1132
            tree = self.working_tree()
 
1133
            inv = tree.inventory
 
1134
            to_abs = self.abspath(to_name)
 
1135
            if not isdir(to_abs):
 
1136
                raise BzrError("destination %r is not a directory" % to_abs)
 
1137
            if not tree.has_filename(to_name):
 
1138
                raise BzrError("destination %r not in working directory" % to_abs)
 
1139
            to_dir_id = inv.path2id(to_name)
 
1140
            if to_dir_id == None and to_name != '':
 
1141
                raise BzrError("destination %r is not a versioned directory" % to_name)
 
1142
            to_dir_ie = inv[to_dir_id]
 
1143
            if to_dir_ie.kind not in ('directory', 'root_directory'):
 
1144
                raise BzrError("destination %r is not a directory" % to_abs)
 
1145
 
 
1146
            to_idpath = inv.get_idpath(to_dir_id)
 
1147
 
 
1148
            for f in from_paths:
 
1149
                if not tree.has_filename(f):
 
1150
                    raise BzrError("%r does not exist in working tree" % f)
 
1151
                f_id = inv.path2id(f)
 
1152
                if f_id == None:
 
1153
                    raise BzrError("%r is not versioned" % f)
 
1154
                name_tail = splitpath(f)[-1]
 
1155
                dest_path = appendpath(to_name, name_tail)
 
1156
                if tree.has_filename(dest_path):
 
1157
                    raise BzrError("destination %r already exists" % dest_path)
 
1158
                if f_id in to_idpath:
 
1159
                    raise BzrError("can't move %r to a subdirectory of itself" % f)
 
1160
 
 
1161
            # OK, so there's a race here, it's possible that someone will
 
1162
            # create a file in this interval and then the rename might be
 
1163
            # left half-done.  But we should have caught most problems.
 
1164
 
 
1165
            for f in from_paths:
 
1166
                name_tail = splitpath(f)[-1]
 
1167
                dest_path = appendpath(to_name, name_tail)
 
1168
                print "%s => %s" % (f, dest_path)
 
1169
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
 
1170
                try:
 
1171
                    os.rename(self.abspath(f), self.abspath(dest_path))
 
1172
                except OSError, e:
 
1173
                    raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
 
1174
                            ["rename rolled back"])
 
1175
 
 
1176
            self._write_inventory(inv)
 
1177
        finally:
 
1178
            self.unlock()
 
1179
 
 
1180
 
 
1181
    def revert(self, filenames, old_tree=None, backups=True):
 
1182
        """Restore selected files to the versions from a previous tree.
 
1183
 
 
1184
        backups
 
1185
            If true (default) backups are made of files before
 
1186
            they're renamed.
 
1187
        """
 
1188
        from bzrlib.errors import NotVersionedError, BzrError
 
1189
        from bzrlib.atomicfile import AtomicFile
 
1190
        from bzrlib.osutils import backup_file
 
1191
        
 
1192
        inv = self.read_working_inventory()
 
1193
        if old_tree is None:
 
1194
            old_tree = self.basis_tree()
 
1195
        old_inv = old_tree.inventory
 
1196
 
 
1197
        nids = []
 
1198
        for fn in filenames:
 
1199
            file_id = inv.path2id(fn)
 
1200
            if not file_id:
 
1201
                raise NotVersionedError("not a versioned file", fn)
 
1202
            if not old_inv.has_id(file_id):
 
1203
                raise BzrError("file not present in old tree", fn, file_id)
 
1204
            nids.append((fn, file_id))
 
1205
            
 
1206
        # TODO: Rename back if it was previously at a different location
 
1207
 
 
1208
        # TODO: If given a directory, restore the entire contents from
 
1209
        # the previous version.
 
1210
 
 
1211
        # TODO: Make a backup to a temporary file.
 
1212
 
 
1213
        # TODO: If the file previously didn't exist, delete it?
 
1214
        for fn, file_id in nids:
 
1215
            backup_file(fn)
 
1216
            
 
1217
            f = AtomicFile(fn, 'wb')
 
1218
            try:
 
1219
                f.write(old_tree.get_file(file_id).read())
 
1220
                f.commit()
 
1221
            finally:
 
1222
                f.close()
 
1223
 
 
1224
 
 
1225
    def pending_merges(self):
 
1226
        """Return a list of pending merges.
 
1227
 
 
1228
        These are revisions that have been merged into the working
 
1229
        directory but not yet committed.
 
1230
        """
 
1231
        cfn = self.controlfilename('pending-merges')
 
1232
        if not os.path.exists(cfn):
 
1233
            return []
 
1234
        p = []
 
1235
        for l in self.controlfile('pending-merges', 'r').readlines():
 
1236
            p.append(l.rstrip('\n'))
 
1237
        return p
 
1238
 
 
1239
 
 
1240
    def add_pending_merge(self, revision_id):
 
1241
        from bzrlib.revision import validate_revision_id
 
1242
 
 
1243
        validate_revision_id(revision_id)
 
1244
 
 
1245
        p = self.pending_merges()
 
1246
        if revision_id in p:
 
1247
            return
 
1248
        p.append(revision_id)
 
1249
        self.set_pending_merges(p)
 
1250
 
 
1251
 
 
1252
    def set_pending_merges(self, rev_list):
 
1253
        from bzrlib.atomicfile import AtomicFile
 
1254
        self.lock_write()
 
1255
        try:
 
1256
            f = AtomicFile(self.controlfilename('pending-merges'))
 
1257
            try:
 
1258
                for l in rev_list:
 
1259
                    print >>f, l
 
1260
                f.commit()
 
1261
            finally:
 
1262
                f.close()
 
1263
        finally:
 
1264
            self.unlock()
713
1265
 
714
1266
 
715
1267
 
724
1276
    >>> isdir(bd)
725
1277
    False
726
1278
    """
727
 
    def __init__(self, files=[], dirs=[]):
 
1279
    def __init__(self, files=[], dirs=[], base=None):
728
1280
        """Make a test branch.
729
1281
 
730
1282
        This creates a temporary directory and runs init-tree in it.
731
1283
 
732
1284
        If any files are listed, they are created in the working copy.
733
1285
        """
734
 
        Branch.__init__(self, tempfile.mkdtemp(), init=True)
 
1286
        from tempfile import mkdtemp
 
1287
        init = False
 
1288
        if base is None:
 
1289
            base = mkdtemp()
 
1290
            init = True
 
1291
        Branch.__init__(self, base, init=init)
735
1292
        for d in dirs:
736
1293
            os.mkdir(self.abspath(d))
737
1294
            
739
1296
            file(os.path.join(self.base, f), 'w').write('content of %s' % f)
740
1297
 
741
1298
 
 
1299
    def clone(self):
 
1300
        """
 
1301
        >>> orig = ScratchBranch(files=["file1", "file2"])
 
1302
        >>> clone = orig.clone()
 
1303
        >>> os.path.samefile(orig.base, clone.base)
 
1304
        False
 
1305
        >>> os.path.isfile(os.path.join(clone.base, "file1"))
 
1306
        True
 
1307
        """
 
1308
        from shutil import copytree
 
1309
        from tempfile import mkdtemp
 
1310
        base = mkdtemp()
 
1311
        os.rmdir(base)
 
1312
        copytree(self.base, base, symlinks=True)
 
1313
        return ScratchBranch(base=base)
 
1314
        
742
1315
    def __del__(self):
743
1316
        self.destroy()
744
1317
 
745
1318
    def destroy(self):
746
1319
        """Destroy the test branch, removing the scratch directory."""
 
1320
        from shutil import rmtree
747
1321
        try:
748
 
            mutter("delete ScratchBranch %s" % self.base)
749
 
            shutil.rmtree(self.base)
 
1322
            if self.base:
 
1323
                mutter("delete ScratchBranch %s" % self.base)
 
1324
                rmtree(self.base)
750
1325
        except OSError, e:
751
1326
            # Work around for shutil.rmtree failing on Windows when
752
1327
            # readonly files are encountered
754
1329
            for root, dirs, files in os.walk(self.base, topdown=False):
755
1330
                for name in files:
756
1331
                    os.chmod(os.path.join(root, name), 0700)
757
 
            shutil.rmtree(self.base)
 
1332
            rmtree(self.base)
758
1333
        self.base = None
759
1334
 
760
1335
    
785
1360
    cope with just randomness because running uuidgen every time is
786
1361
    slow."""
787
1362
    import re
 
1363
    from binascii import hexlify
 
1364
    from time import time
788
1365
 
789
1366
    # get last component
790
1367
    idx = name.rfind('/')
802
1379
    name = re.sub(r'[^\w.]', '', name)
803
1380
 
804
1381
    s = hexlify(rand_bytes(8))
805
 
    return '-'.join((name, compact_date(time.time()), s))
 
1382
    return '-'.join((name, compact_date(time()), s))
 
1383
 
 
1384
 
 
1385
def gen_root_id():
 
1386
    """Return a new tree-root file id."""
 
1387
    return gen_file_id('TREE_ROOT')
 
1388