/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-05-10 03:50:45 UTC
  • Revision ID: mbp@sourcefrog.net-20050510035045-c70b89a0b0a705b7
- External-command patch from mpe

Show diffs side-by-side

added added

removed removed

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