~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: mbp at sourcefrog
  • Date: 2005-03-09 04:51:05 UTC
  • Revision ID: mbp@sourcefrog.net-20050309045105-d02cd410a115da2c
import all docs from arch

Show diffs side-by-side

added added

removed removed

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