/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

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

Show diffs side-by-side

added added

removed removed

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