~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/mutabletree.py

  • Committer: Matt Nordhoff
  • Date: 2009-04-04 02:50:01 UTC
  • mfrom: (4253 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4256.
  • Revision ID: mnordhoff@mattnordhoff.com-20090404025001-z1403k0tatmc8l91
Merge bzr.dev, fixing conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""MutableTree object.
18
18
 
28
28
    add,
29
29
    bzrdir,
30
30
    hooks,
 
31
    symbol_versioning,
31
32
    )
32
33
from bzrlib.osutils import dirname
33
34
from bzrlib.revisiontree import RevisionTree
41
42
    )
42
43
from bzrlib.decorators import needs_read_lock, needs_write_lock
43
44
from bzrlib.osutils import splitpath
44
 
from bzrlib.symbol_versioning import DEPRECATED_PARAMETER
45
45
 
46
46
 
47
47
def needs_tree_write_lock(unbound):
69
69
    entirely in memory.
70
70
 
71
71
    For now, we are not treating MutableTree as an interface to provide
72
 
    conformance tests for - rather we are testing MemoryTree specifically, and 
 
72
    conformance tests for - rather we are testing MemoryTree specifically, and
73
73
    interface testing implementations of WorkingTree.
74
74
 
75
75
    A mutable tree always has an associated Branch and BzrDir object - the
130
130
            if self.is_control_filename(f):
131
131
                raise errors.ForbiddenControlFileError(filename=f)
132
132
            fp = splitpath(f)
133
 
        # fill out file kinds for all files [not needed when we stop 
 
133
        # fill out file kinds for all files [not needed when we stop
134
134
        # caring about the instantaneous file kind within a uncommmitted tree
135
135
        #
136
136
        self._gather_kinds(files, kinds)
192
192
            revprops['branch-nick'] = self.branch._get_nick(
193
193
                kwargs.get('local', False),
194
194
                possible_master_transports)
 
195
        authors = kwargs.pop('authors', None)
195
196
        author = kwargs.pop('author', None)
 
197
        if authors is not None:
 
198
            if author is not None:
 
199
                raise AssertionError('Specifying both author and authors '
 
200
                        'is not allowed. Specify just authors instead')
 
201
            if 'author' in revprops or 'authors' in revprops:
 
202
                # XXX: maybe we should just accept one of them?
 
203
                raise AssertionError('author property given twice')
 
204
            if authors:
 
205
                for individual in authors:
 
206
                    if '\n' in individual:
 
207
                        raise AssertionError('\\n is not a valid character '
 
208
                                'in an author identity')
 
209
                revprops['authors'] = '\n'.join(authors)
196
210
        if author is not None:
197
 
            if 'author' in revprops:
 
211
            symbol_versioning.warn('The parameter author was deprecated'
 
212
                   ' in version 1.13. Use authors instead',
 
213
                   DeprecationWarning)
 
214
            if 'author' in revprops or 'authors' in revprops:
198
215
                # XXX: maybe we should just accept one of them?
199
216
                raise AssertionError('author property given twice')
200
 
            revprops['author'] = author
 
217
            if '\n' in author:
 
218
                raise AssertionError('\\n is not a valid character '
 
219
                        'in an author identity')
 
220
            revprops['authors'] = author
201
221
        # args for wt.commit start at message from the Commit.commit method,
202
222
        args = (message, ) + args
203
223
        for hook in MutableTree.hooks['start_commit']:
233
253
        In early tree formats the result of last_revision is the same as the
234
254
        branch last_revision, but that is no longer the case for modern tree
235
255
        formats.
236
 
        
 
256
 
237
257
        last_revision returns the left most parent id, or None if there are no
238
258
        parents.
239
259
 
256
276
    def lock_write(self):
257
277
        """Lock the tree and its branch. This allows mutating calls to be made.
258
278
 
259
 
        Some mutating methods will take out implicit write locks, but in 
 
279
        Some mutating methods will take out implicit write locks, but in
260
280
        general you should always obtain a write lock before calling mutating
261
281
        methods on a tree.
262
282
        """
278
298
        The intent of this function is to allow trees that have a hashcache to
279
299
        update the hashcache during commit. If the observed file is too new
280
300
        (based on the stat_value) to be safely hash-cached the tree will ignore
281
 
        it. 
 
301
        it.
282
302
 
283
303
        The default implementation does nothing.
284
304
 
298
318
    @needs_write_lock
299
319
    def put_file_bytes_non_atomic(self, file_id, bytes):
300
320
        """Update the content of a file in the tree.
301
 
        
 
321
 
302
322
        Note that the file is written in-place rather than being
303
323
        written to a temporary location and renamed. As a consequence,
304
324
        readers can potentially see the file half-written.
318
338
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
319
339
        """Set the parents of the working tree.
320
340
 
321
 
        :param parents_list: A list of (revision_id, tree) tuples. 
 
341
        :param parents_list: A list of (revision_id, tree) tuples.
322
342
            If tree is None, then that element is treated as an unreachable
323
343
            parent tree - i.e. a ghost.
324
344
        """
332
352
        For the specific behaviour see the help for cmd_add().
333
353
 
334
354
        :param action: A reporter to be called with the inventory, parent_ie,
335
 
            path and kind of the path being added. It may return a file_id if 
 
355
            path and kind of the path being added. It may return a file_id if
336
356
            a specific one should be used.
337
357
        :param save: Save the inventory after completing the adds. If False
338
358
            this provides dry-run functionality by doing the add and not saving
346
366
        from bzrlib.inventory import InventoryEntry
347
367
        if action is None:
348
368
            action = add.AddAction()
349
 
        
 
369
 
350
370
        if not file_list:
351
371
            # no paths supplied: add the entire tree.
352
372
            file_list = [u'.']
357
377
        dirs_to_add = []
358
378
        user_dirs = set()
359
379
 
360
 
        # validate user file paths and convert all paths to tree 
 
380
        # validate user file paths and convert all paths to tree
361
381
        # relative : it's cheaper to make a tree relative path an abspath
362
382
        # than to convert an abspath to tree relative, and it's cheaper to
363
383
        # perform the canonicalization in bulk.
364
384
        for filepath in osutils.canonical_relpaths(self.basedir, file_list):
365
385
            rf = _FastPath(filepath)
366
386
            # validate user parameters. Our recursive code avoids adding new files
367
 
            # that need such validation 
 
387
            # that need such validation
368
388
            if self.is_control_filename(rf.raw_path):
369
389
                raise errors.ForbiddenControlFileError(filename=rf.raw_path)
370
 
            
 
390
 
371
391
            abspath = self.abspath(rf.raw_path)
372
392
            kind = osutils.file_kind(abspath)
373
393
            if kind == 'directory':
378
398
                    raise errors.BadFileKindError(filename=abspath, kind=kind)
379
399
            # ensure the named path is added, so that ignore rules in the later directory
380
400
            # walk dont skip it.
381
 
            # we dont have a parent ie known yet.: use the relatively slower inventory 
 
401
            # we dont have a parent ie known yet.: use the relatively slower inventory
382
402
            # probing method
383
403
            versioned = inv.has_filename(rf.raw_path)
384
404
            if versioned:
421
441
            if parent_ie is not None:
422
442
                versioned = directory.base_path in parent_ie.children
423
443
            else:
424
 
                # without the parent ie, use the relatively slower inventory 
 
444
                # without the parent ie, use the relatively slower inventory
425
445
                # probing method
426
446
                versioned = inv.has_filename(
427
447
                        self._fix_case_of_inventory_path(directory.raw_path))
445
465
                # mutter("%r is already versioned", abspath)
446
466
            elif sub_tree:
447
467
                # XXX: This is wrong; people *might* reasonably be trying to add
448
 
                # subtrees as subtrees.  This should probably only be done in formats 
 
468
                # subtrees as subtrees.  This should probably only be done in formats
449
469
                # which can represent subtrees, and even then perhaps only when
450
470
                # the user asked to add subtrees.  At the moment you can add them
451
471
                # specially through 'join --reference', which is perhaps
461
481
                    # must be present:
462
482
                    this_ie = parent_ie.children[directory.base_path]
463
483
                else:
464
 
                    # without the parent ie, use the relatively slower inventory 
 
484
                    # without the parent ie, use the relatively slower inventory
465
485
                    # probing method
466
486
                    this_id = inv.path2id(
467
487
                            self._fix_case_of_inventory_path(directory.raw_path))
471
491
                        this_ie = inv[this_id]
472
492
 
473
493
                for subf in sorted(os.listdir(abspath)):
474
 
                    # here we could use TreeDirectory rather than 
 
494
                    # here we could use TreeDirectory rather than
475
495
                    # string concatenation.
476
496
                    subp = osutils.pathjoin(directory.raw_path, subf)
477
 
                    # TODO: is_control_filename is very slow. Make it faster. 
478
 
                    # TreeDirectory.is_control_filename could also make this 
479
 
                    # faster - its impossible for a non root dir to have a 
 
497
                    # TODO: is_control_filename is very slow. Make it faster.
 
498
                    # TreeDirectory.is_control_filename could also make this
 
499
                    # faster - its impossible for a non root dir to have a
480
500
                    # control file.
481
501
                    if self.is_control_filename(subp):
482
502
                        mutter("skip control directory %r", subp)
532
552
        # WorkingTree classes for optimised versions for specific format trees.
533
553
        basis = self.basis_tree()
534
554
        basis.lock_read()
535
 
        inventory = basis.inventory
 
555
        # TODO: Consider re-evaluating the need for this with CHKInventory
 
556
        # we don't strictly need to mutate an inventory for this
 
557
        # it only makes sense when apply_delta is cheaper than get_inventory()
 
558
        inventory = basis.inventory._get_mutable_inventory()
536
559
        basis.unlock()
537
560
        inventory.apply_delta(delta)
538
561
        rev_tree = RevisionTree(self.branch.repository, inventory, new_revid)
540
563
 
541
564
 
542
565
class MutableTreeHooks(hooks.Hooks):
543
 
    """A dictionary mapping a hook name to a list of callables for mutabletree 
 
566
    """A dictionary mapping a hook name to a list of callables for mutabletree
544
567
    hooks.
545
568
    """
546
569
 
549
572
 
550
573
        """
551
574
        hooks.Hooks.__init__(self)
552
 
        # Invoked before a commit is done in a tree. New in 1.4
553
 
        self['start_commit'] = []
 
575
        self.create_hook(hooks.HookPoint('start_commit',
 
576
            "Called before a commit is performed on a tree. The start commit "
 
577
            "hook is able to change the tree before the commit takes place. "
 
578
            "start_commit is called with the bzrlib.tree.MutableTree that the "
 
579
            "commit is being performed on.", (1, 4), None))
554
580
 
555
581
 
556
582
# install the default hooks into the MutableTree class.