~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Martin Pool
  • Date: 2005-04-29 00:43:34 UTC
  • Revision ID: mbp@sourcefrog.net-20050429004334-bbb9dc81ce0d9de3
- update install instructions

Show diffs side-by-side

added added

removed removed

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