~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Martin Pool
  • Date: 2005-05-16 01:57:48 UTC
  • Revision ID: mbp@sourcefrog.net-20050516015748-e217422f1da5794a
- disallow slash in store ids

Show diffs side-by-side

added added

removed removed

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