/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 breezy/mutabletree.py

  • Committer: Jelmer Vernooij
  • Author(s): Richard Wilbur
  • Date: 2017-05-30 23:37:11 UTC
  • mto: This revision was merged to the branch mainline in revision 6645.
  • Revision ID: jelmer@jelmer.uk-20170530233711-r0m0qp8hpkqzpopw
Fix order in which files are processed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
19
19
See MutableTree for more details.
20
20
"""
21
21
 
 
22
from __future__ import absolute_import
22
23
 
23
 
from bzrlib.lazy_import import lazy_import
 
24
from .lazy_import import lazy_import
24
25
lazy_import(globals(), """
 
26
import operator
25
27
import os
26
28
import re
27
29
 
28
 
from bzrlib import (
 
30
from breezy import (
29
31
    add,
30
 
    bzrdir,
 
32
    controldir,
31
33
    errors,
32
34
    hooks,
 
35
    inventory as _mod_inventory,
33
36
    osutils,
34
37
    revisiontree,
35
 
    symbol_versioning,
36
38
    trace,
 
39
    transport as _mod_transport,
37
40
    tree,
38
41
    )
39
42
""")
40
43
 
41
 
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
44
from .decorators import needs_read_lock, needs_write_lock
42
45
 
43
46
 
44
47
def needs_tree_write_lock(unbound):
61
64
    context, and will revert if the lock is broken abnormally - but this cannot
62
65
    be guaranteed - depending on the exact implementation of the mutable state.
63
66
 
64
 
    The most common form of Mutable Tree is WorkingTree, see bzrlib.workingtree.
 
67
    The most common form of Mutable Tree is WorkingTree, see breezy.workingtree.
65
68
    For tests we also have MemoryTree which is a MutableTree whose contents are
66
69
    entirely in memory.
67
70
 
69
72
    conformance tests for - rather we are testing MemoryTree specifically, and
70
73
    interface testing implementations of WorkingTree.
71
74
 
72
 
    A mutable tree always has an associated Branch and BzrDir object - the
 
75
    A mutable tree always has an associated Branch and ControlDir object - the
73
76
    branch and bzrdir attributes.
74
77
    """
75
78
    def __init__(self, *args, **kw):
79
82
        # used on media which doesn't differentiate the case of names.
80
83
        self.case_sensitive = True
81
84
 
 
85
    def is_control_filename(self, filename):
 
86
        """True if filename is the name of a control file in this tree.
 
87
 
 
88
        :param filename: A filename within the tree. This is a relative path
 
89
            from the root of this tree.
 
90
 
 
91
        This is true IF and ONLY IF the filename is part of the meta data
 
92
        that bzr controls in this tree. I.E. a random .bzr directory placed
 
93
        on disk will not be a control file for this tree.
 
94
        """
 
95
        raise NotImplementedError(self.is_control_filename)
 
96
 
82
97
    @needs_tree_write_lock
83
98
    def add(self, files, ids=None, kinds=None):
84
99
        """Add paths to the set of versioned paths.
148
163
        if sub_tree_id == self.get_root_id():
149
164
            raise errors.BadReferenceTarget(self, sub_tree,
150
165
                                     'Trees have the same root id.')
151
 
        if sub_tree_id in self.inventory:
 
166
        if self.has_id(sub_tree_id):
152
167
            raise errors.BadReferenceTarget(self, sub_tree,
153
168
                                            'Root id already present in tree')
154
169
        self._add([sub_tree_path], [sub_tree_id], ['tree-reference'])
163
178
        """
164
179
        raise NotImplementedError(self._add)
165
180
 
166
 
    @needs_tree_write_lock
167
181
    def apply_inventory_delta(self, changes):
168
182
        """Apply changes to the inventory as an atomic operation.
169
183
 
172
186
        :return None:
173
187
        :seealso Inventory.apply_delta: For details on the changes parameter.
174
188
        """
175
 
        self.flush()
176
 
        inv = self.inventory
177
 
        inv.apply_delta(changes)
178
 
        self._write_inventory(inv)
 
189
        raise NotImplementedError(self.apply_inventory_delta)
179
190
 
180
191
    @needs_write_lock
181
 
    def commit(self, message=None, revprops=None, *args,
182
 
               **kwargs):
 
192
    def commit(self, message=None, revprops=None, *args, **kwargs):
183
193
        # avoid circular imports
184
 
        from bzrlib import commit
185
 
        if revprops is None:
186
 
            revprops = {}
 
194
        from breezy import commit
187
195
        possible_master_transports=[]
188
 
        if not 'branch-nick' in revprops:
189
 
            revprops['branch-nick'] = self.branch._get_nick(
 
196
        revprops = commit.Commit.update_revprops(
 
197
                revprops,
 
198
                self.branch,
 
199
                kwargs.pop('authors', None),
190
200
                kwargs.get('local', False),
191
201
                possible_master_transports)
192
 
        authors = kwargs.pop('authors', None)
193
 
        author = kwargs.pop('author', None)
194
 
        if authors is not None:
195
 
            if author is not None:
196
 
                raise AssertionError('Specifying both author and authors '
197
 
                        'is not allowed. Specify just authors instead')
198
 
            if 'author' in revprops or 'authors' in revprops:
199
 
                # XXX: maybe we should just accept one of them?
200
 
                raise AssertionError('author property given twice')
201
 
            if authors:
202
 
                for individual in authors:
203
 
                    if '\n' in individual:
204
 
                        raise AssertionError('\\n is not a valid character '
205
 
                                'in an author identity')
206
 
                revprops['authors'] = '\n'.join(authors)
207
 
        if author is not None:
208
 
            symbol_versioning.warn('The parameter author was deprecated'
209
 
                   ' in version 1.13. Use authors instead',
210
 
                   DeprecationWarning)
211
 
            if 'author' in revprops or 'authors' in revprops:
212
 
                # XXX: maybe we should just accept one of them?
213
 
                raise AssertionError('author property given twice')
214
 
            if '\n' in author:
215
 
                raise AssertionError('\\n is not a valid character '
216
 
                        'in an author identity')
217
 
            revprops['authors'] = author
218
202
        # args for wt.commit start at message from the Commit.commit method,
219
203
        args = (message, ) + args
220
204
        for hook in MutableTree.hooks['start_commit']:
248
232
            _from_tree = self.basis_tree()
249
233
        changes = self.iter_changes(_from_tree)
250
234
        try:
251
 
            change = changes.next()
 
235
            change = next(changes)
252
236
            # Exclude root (talk about black magic... --vila 20090629)
253
237
            if change[4] == (None, None):
254
 
                change = changes.next()
 
238
                change = next(changes)
255
239
            return True
256
240
        except StopIteration:
257
241
            # No changes
275
259
        :param more_warning: Details about what is happening.
276
260
        """
277
261
        if strict is None:
278
 
            strict = self.branch.get_config().get_user_option_as_bool(opt_name)
 
262
            strict = self.branch.get_config_stack().get(opt_name)
279
263
        if strict is not False:
280
264
            err_class = None
281
265
            if (self.has_changes()):
341
325
        """
342
326
        raise NotImplementedError(self.mkdir)
343
327
 
344
 
    def _observed_sha1(self, file_id, path, (sha1, stat_value)):
 
328
    def _observed_sha1(self, file_id, path, sha_and_stat):
345
329
        """Tell the tree we have observed a paths sha1.
346
330
 
347
331
        The intent of this function is to allow trees that have a hashcache to
353
337
 
354
338
        :param file_id: The file id
355
339
        :param path: The file path
356
 
        :param sha1: The sha 1 that was observed.
357
 
        :param stat_value: A stat result for the file the sha1 was read from.
 
340
        :param sha_and_stat: The sha 1 and stat result observed.
358
341
        :return: None
359
342
        """
360
343
 
361
 
    def _fix_case_of_inventory_path(self, path):
362
 
        """If our tree isn't case sensitive, return the canonical path"""
363
 
        if not self.case_sensitive:
364
 
            path = self.get_canonical_inventory_path(path)
365
 
        return path
366
 
 
367
344
    @needs_write_lock
368
345
    def put_file_bytes_non_atomic(self, file_id, bytes):
369
346
        """Update the content of a file in the tree.
393
370
        """
394
371
        raise NotImplementedError(self.set_parent_trees)
395
372
 
396
 
    @needs_tree_write_lock
397
 
    def smart_add(self, file_list, recurse=True, action=None, save=True):
398
 
        """Version file_list, optionally recursing into directories.
399
 
 
400
 
        This is designed more towards DWIM for humans than API clarity.
401
 
        For the specific behaviour see the help for cmd_add().
402
 
 
403
 
        :param action: A reporter to be called with the inventory, parent_ie,
404
 
            path and kind of the path being added. It may return a file_id if
405
 
            a specific one should be used.
406
 
        :param save: Save the inventory after completing the adds. If False
407
 
            this provides dry-run functionality by doing the add and not saving
408
 
            the inventory.
409
 
        :return: A tuple - files_added, ignored_files. files_added is the count
410
 
            of added files, and ignored_files is a dict mapping files that were
411
 
            ignored to the rule that caused them to be ignored.
412
 
        """
413
 
        # not in an inner loop; and we want to remove direct use of this,
414
 
        # so here as a reminder for now. RBC 20070703
415
 
        from bzrlib.inventory import InventoryEntry
416
 
        if action is None:
417
 
            action = add.AddAction()
418
 
 
419
 
        if not file_list:
420
 
            # no paths supplied: add the entire tree.
421
 
            # FIXME: this assumes we are running in a working tree subdir :-/
422
 
            # -- vila 20100208
423
 
            file_list = [u'.']
424
 
        # mutter("smart add of %r")
425
 
        inv = self.inventory
426
 
        added = []
427
 
        ignored = {}
428
 
        dirs_to_add = []
429
 
        user_dirs = set()
430
 
        conflicts_related = set()
 
373
    def smart_add(self, file_list, recurse=True, action=None, save=True):
 
374
        """Version file_list, optionally recursing into directories.
 
375
 
 
376
        This is designed more towards DWIM for humans than API clarity.
 
377
        For the specific behaviour see the help for cmd_add().
 
378
 
 
379
        :param file_list: List of zero or more paths.  *NB: these are 
 
380
            interpreted relative to the process cwd, not relative to the 
 
381
            tree.*  (Add and most other tree methods use tree-relative
 
382
            paths.)
 
383
        :param action: A reporter to be called with the inventory, parent_ie,
 
384
            path and kind of the path being added. It may return a file_id if
 
385
            a specific one should be used.
 
386
        :param save: Save the inventory after completing the adds. If False
 
387
            this provides dry-run functionality by doing the add and not saving
 
388
            the inventory.
 
389
        :return: A tuple - files_added, ignored_files. files_added is the count
 
390
            of added files, and ignored_files is a dict mapping files that were
 
391
            ignored to the rule that caused them to be ignored.
 
392
        """
 
393
        raise NotImplementedError(self.smart_add)
 
394
 
 
395
 
 
396
class MutableInventoryTree(MutableTree, tree.InventoryTree):
 
397
 
 
398
    @needs_tree_write_lock
 
399
    def apply_inventory_delta(self, changes):
 
400
        """Apply changes to the inventory as an atomic operation.
 
401
 
 
402
        :param changes: An inventory delta to apply to the working tree's
 
403
            inventory.
 
404
        :return None:
 
405
        :seealso Inventory.apply_delta: For details on the changes parameter.
 
406
        """
 
407
        self.flush()
 
408
        inv = self.root_inventory
 
409
        inv.apply_delta(changes)
 
410
        self._write_inventory(inv)
 
411
 
 
412
    def _fix_case_of_inventory_path(self, path):
 
413
        """If our tree isn't case sensitive, return the canonical path"""
 
414
        if not self.case_sensitive:
 
415
            path = self.get_canonical_inventory_path(path)
 
416
        return path
 
417
 
 
418
    @needs_tree_write_lock
 
419
    def smart_add(self, file_list, recurse=True, action=None, save=True):
 
420
        """Version file_list, optionally recursing into directories.
 
421
 
 
422
        This is designed more towards DWIM for humans than API clarity.
 
423
        For the specific behaviour see the help for cmd_add().
 
424
 
 
425
        :param file_list: List of zero or more paths.  *NB: these are 
 
426
            interpreted relative to the process cwd, not relative to the 
 
427
            tree.*  (Add and most other tree methods use tree-relative
 
428
            paths.)
 
429
        :param action: A reporter to be called with the inventory, parent_ie,
 
430
            path and kind of the path being added. It may return a file_id if
 
431
            a specific one should be used.
 
432
        :param save: Save the inventory after completing the adds. If False
 
433
            this provides dry-run functionality by doing the add and not saving
 
434
            the inventory.
 
435
        :return: A tuple - files_added, ignored_files. files_added is the count
 
436
            of added files, and ignored_files is a dict mapping files that were
 
437
            ignored to the rule that caused them to be ignored.
 
438
        """
431
439
        # Not all mutable trees can have conflicts
432
440
        if getattr(self, 'conflicts', None) is not None:
433
441
            # Collect all related files without checking whether they exist or
434
442
            # are versioned. It's cheaper to do that once for all conflicts
435
443
            # than trying to find the relevant conflict for each added file.
 
444
            conflicts_related = set()
436
445
            for c in self.conflicts():
437
446
                conflicts_related.update(c.associated_filenames())
438
 
 
 
447
        else:
 
448
            conflicts_related = None
 
449
        adder = _SmartAddHelper(self, action, conflicts_related)
 
450
        adder.add(file_list, recurse=recurse)
 
451
        if save:
 
452
            invdelta = adder.get_inventory_delta()
 
453
            self.apply_inventory_delta(invdelta)
 
454
        return adder.added, adder.ignored
 
455
 
 
456
    def update_basis_by_delta(self, new_revid, delta):
 
457
        """Update the parents of this tree after a commit.
 
458
 
 
459
        This gives the tree one parent, with revision id new_revid. The
 
460
        inventory delta is applied to the current basis tree to generate the
 
461
        inventory for the parent new_revid, and all other parent trees are
 
462
        discarded.
 
463
 
 
464
        All the changes in the delta should be changes synchronising the basis
 
465
        tree with some or all of the working tree, with a change to a directory
 
466
        requiring that its contents have been recursively included. That is,
 
467
        this is not a general purpose tree modification routine, but a helper
 
468
        for commit which is not required to handle situations that do not arise
 
469
        outside of commit.
 
470
 
 
471
        See the inventory developers documentation for the theory behind
 
472
        inventory deltas.
 
473
 
 
474
        :param new_revid: The new revision id for the trees parent.
 
475
        :param delta: An inventory delta (see apply_inventory_delta) describing
 
476
            the changes from the current left most parent revision to new_revid.
 
477
        """
 
478
        # if the tree is updated by a pull to the branch, as happens in
 
479
        # WorkingTree2, when there was no separation between branch and tree,
 
480
        # then just clear merges, efficiency is not a concern for now as this
 
481
        # is legacy environments only, and they are slow regardless.
 
482
        if self.last_revision() == new_revid:
 
483
            self.set_parent_ids([new_revid])
 
484
            return
 
485
        # generic implementation based on Inventory manipulation. See
 
486
        # WorkingTree classes for optimised versions for specific format trees.
 
487
        basis = self.basis_tree()
 
488
        basis.lock_read()
 
489
        # TODO: Consider re-evaluating the need for this with CHKInventory
 
490
        # we don't strictly need to mutate an inventory for this
 
491
        # it only makes sense when apply_delta is cheaper than get_inventory()
 
492
        inventory = _mod_inventory.mutable_inventory_from_tree(basis)
 
493
        basis.unlock()
 
494
        inventory.apply_delta(delta)
 
495
        rev_tree = revisiontree.InventoryRevisionTree(self.branch.repository,
 
496
                                             inventory, new_revid)
 
497
        self.set_parent_trees([(new_revid, rev_tree)])
 
498
 
 
499
 
 
500
class MutableTreeHooks(hooks.Hooks):
 
501
    """A dictionary mapping a hook name to a list of callables for mutabletree
 
502
    hooks.
 
503
    """
 
504
 
 
505
    def __init__(self):
 
506
        """Create the default hooks.
 
507
 
 
508
        """
 
509
        hooks.Hooks.__init__(self, "breezy.mutabletree", "MutableTree.hooks")
 
510
        self.add_hook('start_commit',
 
511
            "Called before a commit is performed on a tree. The start commit "
 
512
            "hook is able to change the tree before the commit takes place. "
 
513
            "start_commit is called with the breezy.mutabletree.MutableTree "
 
514
            "that the commit is being performed on.", (1, 4))
 
515
        self.add_hook('post_commit',
 
516
            "Called after a commit is performed on a tree. The hook is "
 
517
            "called with a breezy.mutabletree.PostCommitHookParams object. "
 
518
            "The mutable tree the commit was performed on is available via "
 
519
            "the mutable_tree attribute of that object.", (2, 0))
 
520
        self.add_hook('pre_transform',
 
521
            "Called before a tree transform on this tree. The hook is called "
 
522
            "with the tree that is being transformed and the transform.",
 
523
            (2, 5))
 
524
        self.add_hook('post_build_tree',
 
525
            "Called after a completely new tree is built. The hook is "
 
526
            "called with the tree as its only argument.", (2, 5))
 
527
        self.add_hook('post_transform',
 
528
            "Called after a tree transform has been performed on a tree. "
 
529
            "The hook is called with the tree that is being transformed and "
 
530
            "the transform.",
 
531
            (2, 5))
 
532
 
 
533
# install the default hooks into the MutableTree class.
 
534
MutableTree.hooks = MutableTreeHooks()
 
535
 
 
536
 
 
537
class PostCommitHookParams(object):
 
538
    """Parameters for the post_commit hook.
 
539
 
 
540
    To access the parameters, use the following attributes:
 
541
 
 
542
    * mutable_tree - the MutableTree object
 
543
    """
 
544
 
 
545
    def __init__(self, mutable_tree):
 
546
        """Create the parameters for the post_commit hook."""
 
547
        self.mutable_tree = mutable_tree
 
548
 
 
549
 
 
550
class _SmartAddHelper(object):
 
551
    """Helper for MutableTree.smart_add."""
 
552
 
 
553
    def get_inventory_delta(self):
 
554
        return self._invdelta.values()
 
555
 
 
556
    def _get_ie(self, inv_path):
 
557
        """Retrieve the most up to date inventory entry for a path.
 
558
 
 
559
        :param inv_path: Normalized inventory path
 
560
        :return: Inventory entry (with possibly invalid .children for
 
561
            directories)
 
562
        """
 
563
        entry = self._invdelta.get(inv_path)
 
564
        if entry is not None:
 
565
            return entry[3]
 
566
        # Find a 'best fit' match if the filesystem is case-insensitive
 
567
        inv_path = self.tree._fix_case_of_inventory_path(inv_path)
 
568
        file_id = self.tree.path2id(inv_path)
 
569
        if file_id is not None:
 
570
            return self.tree.iter_entries_by_dir([file_id]).next()[1]
 
571
        return None
 
572
 
 
573
    def _convert_to_directory(self, this_ie, inv_path):
 
574
        """Convert an entry to a directory.
 
575
 
 
576
        :param this_ie: Inventory entry
 
577
        :param inv_path: Normalized path for the inventory entry
 
578
        :return: The new inventory entry
 
579
        """
 
580
        # Same as in _add_one below, if the inventory doesn't
 
581
        # think this is a directory, update the inventory
 
582
        this_ie = _mod_inventory.InventoryDirectory(
 
583
            this_ie.file_id, this_ie.name, this_ie.parent_id)
 
584
        self._invdelta[inv_path] = (inv_path, inv_path, this_ie.file_id,
 
585
            this_ie)
 
586
        return this_ie
 
587
 
 
588
    def _add_one_and_parent(self, parent_ie, path, kind, inv_path):
 
589
        """Add a new entry to the inventory and automatically add unversioned parents.
 
590
 
 
591
        :param parent_ie: Parent inventory entry if known, or None.  If
 
592
            None, the parent is looked up by name and used if present, otherwise it
 
593
            is recursively added.
 
594
        :param path: 
 
595
        :param kind: Kind of new entry (file, directory, etc)
 
596
        :param inv_path:
 
597
        :return: Inventory entry for path and a list of paths which have been added.
 
598
        """
 
599
        # Nothing to do if path is already versioned.
 
600
        # This is safe from infinite recursion because the tree root is
 
601
        # always versioned.
 
602
        inv_dirname = osutils.dirname(inv_path)
 
603
        dirname, basename = osutils.split(path)
 
604
        if parent_ie is None:
 
605
            # slower but does not need parent_ie
 
606
            this_ie = self._get_ie(inv_path)
 
607
            if this_ie is not None:
 
608
                return this_ie
 
609
            # its really not there : add the parent
 
610
            # note that the dirname use leads to some extra str copying etc but as
 
611
            # there are a limited number of dirs we can be nested under, it should
 
612
            # generally find it very fast and not recurse after that.
 
613
            parent_ie = self._add_one_and_parent(None,
 
614
                dirname, 'directory', 
 
615
                inv_dirname)
 
616
        # if the parent exists, but isn't a directory, we have to do the
 
617
        # kind change now -- really the inventory shouldn't pretend to know
 
618
        # the kind of wt files, but it does.
 
619
        if parent_ie.kind != 'directory':
 
620
            # nb: this relies on someone else checking that the path we're using
 
621
            # doesn't contain symlinks.
 
622
            parent_ie = self._convert_to_directory(parent_ie, inv_dirname)
 
623
        file_id = self.action(self.tree, parent_ie, path, kind)
 
624
        entry = _mod_inventory.make_entry(kind, basename, parent_ie.file_id,
 
625
            file_id=file_id)
 
626
        self._invdelta[inv_path] = (None, inv_path, entry.file_id, entry)
 
627
        self.added.append(inv_path)
 
628
        return entry
 
629
 
 
630
    def _gather_dirs_to_add(self, user_dirs):
 
631
        # only walk the minimal parents needed: we have user_dirs to override
 
632
        # ignores.
 
633
        prev_dir = None
 
634
 
 
635
        is_inside = osutils.is_inside_or_parent_of_any
 
636
        for path, (inv_path, this_ie) in sorted(
 
637
                user_dirs.iteritems(), key=operator.itemgetter(0)):
 
638
            if (prev_dir is None or not is_inside([prev_dir], path)):
 
639
                yield (path, inv_path, this_ie, None)
 
640
            prev_dir = path
 
641
        
 
642
    def __init__(self, tree, action, conflicts_related=None):
 
643
        self.tree = tree
 
644
        if action is None:
 
645
            self.action = add.AddAction()
 
646
        else:
 
647
            self.action = action
 
648
        self._invdelta = {}
 
649
        self.added = []
 
650
        self.ignored = {}
 
651
        if conflicts_related is None:
 
652
            self.conflicts_related = frozenset()
 
653
        else:
 
654
            self.conflicts_related = conflicts_related
 
655
 
 
656
    def add(self, file_list, recurse=True):
 
657
        from breezy.inventory import InventoryEntry
 
658
        if not file_list:
 
659
            # no paths supplied: add the entire tree.
 
660
            # FIXME: this assumes we are running in a working tree subdir :-/
 
661
            # -- vila 20100208
 
662
            file_list = [u'.']
 
663
 
 
664
        # expand any symlinks in the directory part, while leaving the
 
665
        # filename alone
 
666
        # only expanding if symlinks are supported avoids windows path bugs
 
667
        if osutils.has_symlinks():
 
668
            file_list = list(map(osutils.normalizepath, file_list))
 
669
 
 
670
        user_dirs = {}
439
671
        # validate user file paths and convert all paths to tree
440
672
        # relative : it's cheaper to make a tree relative path an abspath
441
673
        # than to convert an abspath to tree relative, and it's cheaper to
442
674
        # perform the canonicalization in bulk.
443
 
        for filepath in osutils.canonical_relpaths(self.basedir, file_list):
444
 
            rf = _FastPath(filepath)
 
675
        for filepath in osutils.canonical_relpaths(self.tree.basedir, file_list):
445
676
            # validate user parameters. Our recursive code avoids adding new
446
677
            # files that need such validation
447
 
            if self.is_control_filename(rf.raw_path):
448
 
                raise errors.ForbiddenControlFileError(filename=rf.raw_path)
 
678
            if self.tree.is_control_filename(filepath):
 
679
                raise errors.ForbiddenControlFileError(filename=filepath)
449
680
 
450
 
            abspath = self.abspath(rf.raw_path)
 
681
            abspath = self.tree.abspath(filepath)
451
682
            kind = osutils.file_kind(abspath)
452
 
            if kind == 'directory':
453
 
                # schedule the dir for scanning
454
 
                user_dirs.add(rf)
455
 
            else:
456
 
                if not InventoryEntry.versionable_kind(kind):
457
 
                    raise errors.BadFileKindError(filename=abspath, kind=kind)
458
683
            # ensure the named path is added, so that ignore rules in the later
459
684
            # directory walk dont skip it.
460
685
            # we dont have a parent ie known yet.: use the relatively slower
461
686
            # inventory probing method
462
 
            versioned = inv.has_filename(rf.raw_path)
463
 
            if versioned:
464
 
                continue
465
 
            added.extend(_add_one_and_parent(self, inv, None, rf, kind, action))
 
687
            inv_path, _ = osutils.normalized_filename(filepath)
 
688
            this_ie = self._get_ie(inv_path)
 
689
            if this_ie is None:
 
690
                this_ie = self._add_one_and_parent(None, filepath, kind, inv_path)
 
691
            if kind == 'directory':
 
692
                # schedule the dir for scanning
 
693
                user_dirs[filepath] = (inv_path, this_ie)
466
694
 
467
695
        if not recurse:
468
696
            # no need to walk any directories at all.
469
 
            if len(added) > 0 and save:
470
 
                self._write_inventory(inv)
471
 
            return added, ignored
472
 
 
473
 
        # only walk the minimal parents needed: we have user_dirs to override
474
 
        # ignores.
475
 
        prev_dir = None
476
 
 
477
 
        is_inside = osutils.is_inside_or_parent_of_any
478
 
        for path in sorted(user_dirs):
479
 
            if (prev_dir is None or not is_inside([prev_dir], path.raw_path)):
480
 
                dirs_to_add.append((path, None))
481
 
            prev_dir = path.raw_path
 
697
            return
 
698
 
 
699
        things_to_add = list(self._gather_dirs_to_add(user_dirs))
482
700
 
483
701
        illegalpath_re = re.compile(r'[\r\n]')
484
 
        # dirs_to_add is initialised to a list of directories, but as we scan
485
 
        # directories we append files to it.
486
 
        # XXX: We should determine kind of files when we scan them rather than
487
 
        # adding to this list. RBC 20070703
488
 
        for directory, parent_ie in dirs_to_add:
 
702
        for directory, inv_path, this_ie, parent_ie in things_to_add:
489
703
            # directory is tree-relative
490
 
            abspath = self.abspath(directory.raw_path)
 
704
            abspath = self.tree.abspath(directory)
491
705
 
492
706
            # get the contents of this directory.
493
707
 
494
 
            # find the kind of the path being added.
495
 
            kind = osutils.file_kind(abspath)
496
 
 
 
708
            # find the kind of the path being added, and save stat_value
 
709
            # for reuse
 
710
            stat_value = None
 
711
            if this_ie is None:
 
712
                stat_value = osutils.file_stat(abspath)
 
713
                kind = osutils.file_kind_from_stat_mode(stat_value.st_mode)
 
714
            else:
 
715
                kind = this_ie.kind
 
716
            
 
717
            # allow AddAction to skip this file
 
718
            if self.action.skip_file(self.tree,  abspath,  kind,  stat_value):
 
719
                continue
497
720
            if not InventoryEntry.versionable_kind(kind):
498
721
                trace.warning("skipping %s (can't add file of kind '%s')",
499
722
                              abspath, kind)
500
723
                continue
501
 
            if illegalpath_re.search(directory.raw_path):
 
724
            if illegalpath_re.search(directory):
502
725
                trace.warning("skipping %r (contains \\n or \\r)" % abspath)
503
726
                continue
504
 
            if directory.raw_path in conflicts_related:
 
727
            if directory in self.conflicts_related:
505
728
                # If the file looks like one generated for a conflict, don't
506
729
                # add it.
507
730
                trace.warning(
509
732
                    abspath)
510
733
                continue
511
734
 
512
 
            if parent_ie is not None:
513
 
                versioned = directory.base_path in parent_ie.children
514
 
            else:
515
 
                # without the parent ie, use the relatively slower inventory
516
 
                # probing method
517
 
                versioned = inv.has_filename(
518
 
                        self._fix_case_of_inventory_path(directory.raw_path))
519
 
 
520
 
            if kind == 'directory':
 
735
            if kind == 'directory' and directory != '':
521
736
                try:
522
 
                    sub_branch = bzrdir.BzrDir.open(abspath)
 
737
                    transport = _mod_transport.get_transport_from_path(abspath)
 
738
                    controldir.ControlDirFormat.find_format(transport)
523
739
                    sub_tree = True
524
740
                except errors.NotBranchError:
525
741
                    sub_tree = False
528
744
            else:
529
745
                sub_tree = False
530
746
 
531
 
            if directory.raw_path == '':
532
 
                # mutter("tree root doesn't need to be added")
533
 
                sub_tree = False
534
 
            elif versioned:
 
747
            if this_ie is not None:
535
748
                pass
536
 
                # mutter("%r is already versioned", abspath)
537
749
            elif sub_tree:
538
750
                # XXX: This is wrong; people *might* reasonably be trying to
539
751
                # add subtrees as subtrees.  This should probably only be done
543
755
                # which is perhaps reasonable: adding a new reference is a
544
756
                # special operation and can have a special behaviour.  mbp
545
757
                # 20070306
546
 
                trace.mutter("%r is a nested bzr tree", abspath)
 
758
                trace.warning("skipping nested tree %r", abspath)
547
759
            else:
548
 
                _add_one(self, inv, parent_ie, directory, kind, action)
549
 
                added.append(directory.raw_path)
 
760
                this_ie = self._add_one_and_parent(parent_ie, directory, kind,
 
761
                    inv_path)
550
762
 
551
763
            if kind == 'directory' and not sub_tree:
552
 
                if parent_ie is not None:
553
 
                    # must be present:
554
 
                    this_ie = parent_ie.children[directory.base_path]
555
 
                else:
556
 
                    # without the parent ie, use the relatively slower inventory
557
 
                    # probing method
558
 
                    this_id = inv.path2id(
559
 
                        self._fix_case_of_inventory_path(directory.raw_path))
560
 
                    if this_id is None:
561
 
                        this_ie = None
562
 
                    else:
563
 
                        this_ie = inv[this_id]
 
764
                if this_ie.kind != 'directory':
 
765
                    this_ie = self._convert_to_directory(this_ie, inv_path)
564
766
 
565
767
                for subf in sorted(os.listdir(abspath)):
 
768
                    inv_f, _ = osutils.normalized_filename(subf)
566
769
                    # here we could use TreeDirectory rather than
567
770
                    # string concatenation.
568
 
                    subp = osutils.pathjoin(directory.raw_path, subf)
 
771
                    subp = osutils.pathjoin(directory, subf)
569
772
                    # TODO: is_control_filename is very slow. Make it faster.
570
773
                    # TreeDirectory.is_control_filename could also make this
571
774
                    # faster - its impossible for a non root dir to have a
572
775
                    # control file.
573
 
                    if self.is_control_filename(subp):
 
776
                    if self.tree.is_control_filename(subp):
574
777
                        trace.mutter("skip control directory %r", subp)
575
 
                    elif subf in this_ie.children:
 
778
                        continue
 
779
                    sub_invp = osutils.pathjoin(inv_path, inv_f)
 
780
                    entry = self._invdelta.get(sub_invp)
 
781
                    if entry is not None:
 
782
                        sub_ie = entry[3]
 
783
                    else:
 
784
                        sub_ie = this_ie.children.get(inv_f)
 
785
                    if sub_ie is not None:
576
786
                        # recurse into this already versioned subdir.
577
 
                        dirs_to_add.append((_FastPath(subp, subf), this_ie))
 
787
                        things_to_add.append((subp, sub_invp, sub_ie, this_ie))
578
788
                    else:
579
 
                        # user selection overrides ignoes
 
789
                        # user selection overrides ignores
580
790
                        # ignore while selecting files - if we globbed in the
581
791
                        # outer loop we would ignore user files.
582
 
                        ignore_glob = self.is_ignored(subp)
 
792
                        ignore_glob = self.tree.is_ignored(subp)
583
793
                        if ignore_glob is not None:
584
 
                            # mutter("skip ignored sub-file %r", subp)
585
 
                            ignored.setdefault(ignore_glob, []).append(subp)
 
794
                            self.ignored.setdefault(ignore_glob, []).append(subp)
586
795
                        else:
587
 
                            #mutter("queue to add sub-file %r", subp)
588
 
                            dirs_to_add.append((_FastPath(subp, subf), this_ie))
589
 
 
590
 
        if len(added) > 0:
591
 
            if save:
592
 
                self._write_inventory(inv)
593
 
            else:
594
 
                self.read_working_inventory()
595
 
        return added, ignored
596
 
 
597
 
    def update_basis_by_delta(self, new_revid, delta):
598
 
        """Update the parents of this tree after a commit.
599
 
 
600
 
        This gives the tree one parent, with revision id new_revid. The
601
 
        inventory delta is applied to the current basis tree to generate the
602
 
        inventory for the parent new_revid, and all other parent trees are
603
 
        discarded.
604
 
 
605
 
        All the changes in the delta should be changes synchronising the basis
606
 
        tree with some or all of the working tree, with a change to a directory
607
 
        requiring that its contents have been recursively included. That is,
608
 
        this is not a general purpose tree modification routine, but a helper
609
 
        for commit which is not required to handle situations that do not arise
610
 
        outside of commit.
611
 
 
612
 
        See the inventory developers documentation for the theory behind
613
 
        inventory deltas.
614
 
 
615
 
        :param new_revid: The new revision id for the trees parent.
616
 
        :param delta: An inventory delta (see apply_inventory_delta) describing
617
 
            the changes from the current left most parent revision to new_revid.
618
 
        """
619
 
        # if the tree is updated by a pull to the branch, as happens in
620
 
        # WorkingTree2, when there was no separation between branch and tree,
621
 
        # then just clear merges, efficiency is not a concern for now as this
622
 
        # is legacy environments only, and they are slow regardless.
623
 
        if self.last_revision() == new_revid:
624
 
            self.set_parent_ids([new_revid])
625
 
            return
626
 
        # generic implementation based on Inventory manipulation. See
627
 
        # WorkingTree classes for optimised versions for specific format trees.
628
 
        basis = self.basis_tree()
629
 
        basis.lock_read()
630
 
        # TODO: Consider re-evaluating the need for this with CHKInventory
631
 
        # we don't strictly need to mutate an inventory for this
632
 
        # it only makes sense when apply_delta is cheaper than get_inventory()
633
 
        inventory = basis.inventory._get_mutable_inventory()
634
 
        basis.unlock()
635
 
        inventory.apply_delta(delta)
636
 
        rev_tree = revisiontree.RevisionTree(self.branch.repository,
637
 
                                             inventory, new_revid)
638
 
        self.set_parent_trees([(new_revid, rev_tree)])
639
 
 
640
 
 
641
 
class MutableTreeHooks(hooks.Hooks):
642
 
    """A dictionary mapping a hook name to a list of callables for mutabletree
643
 
    hooks.
644
 
    """
645
 
 
646
 
    def __init__(self):
647
 
        """Create the default hooks.
648
 
 
649
 
        """
650
 
        hooks.Hooks.__init__(self)
651
 
        self.create_hook(hooks.HookPoint('start_commit',
652
 
            "Called before a commit is performed on a tree. The start commit "
653
 
            "hook is able to change the tree before the commit takes place. "
654
 
            "start_commit is called with the bzrlib.mutabletree.MutableTree "
655
 
            "that the commit is being performed on.", (1, 4), None))
656
 
        self.create_hook(hooks.HookPoint('post_commit',
657
 
            "Called after a commit is performed on a tree. The hook is "
658
 
            "called with a bzrlib.mutabletree.PostCommitHookParams object. "
659
 
            "The mutable tree the commit was performed on is available via "
660
 
            "the mutable_tree attribute of that object.", (2, 0), None))
661
 
 
662
 
 
663
 
# install the default hooks into the MutableTree class.
664
 
MutableTree.hooks = MutableTreeHooks()
665
 
 
666
 
 
667
 
class PostCommitHookParams(object):
668
 
    """Parameters for the post_commit hook.
669
 
 
670
 
    To access the parameters, use the following attributes:
671
 
 
672
 
    * mutable_tree - the MutableTree object
673
 
    """
674
 
 
675
 
    def __init__(self, mutable_tree):
676
 
        """Create the parameters for the post_commit hook."""
677
 
        self.mutable_tree = mutable_tree
678
 
 
679
 
 
680
 
class _FastPath(object):
681
 
    """A path object with fast accessors for things like basename."""
682
 
 
683
 
    __slots__ = ['raw_path', 'base_path']
684
 
 
685
 
    def __init__(self, path, base_path=None):
686
 
        """Construct a FastPath from path."""
687
 
        if base_path is None:
688
 
            self.base_path = osutils.basename(path)
689
 
        else:
690
 
            self.base_path = base_path
691
 
        self.raw_path = path
692
 
 
693
 
    def __cmp__(self, other):
694
 
        return cmp(self.raw_path, other.raw_path)
695
 
 
696
 
    def __hash__(self):
697
 
        return hash(self.raw_path)
698
 
 
699
 
 
700
 
def _add_one_and_parent(tree, inv, parent_ie, path, kind, action):
701
 
    """Add a new entry to the inventory and automatically add unversioned parents.
702
 
 
703
 
    :param inv: Inventory which will receive the new entry.
704
 
    :param parent_ie: Parent inventory entry if known, or None.  If
705
 
        None, the parent is looked up by name and used if present, otherwise it
706
 
        is recursively added.
707
 
    :param kind: Kind of new entry (file, directory, etc)
708
 
    :param action: callback(inv, parent_ie, path, kind); return ignored.
709
 
    :return: A list of paths which have been added.
710
 
    """
711
 
    # Nothing to do if path is already versioned.
712
 
    # This is safe from infinite recursion because the tree root is
713
 
    # always versioned.
714
 
    if parent_ie is not None:
715
 
        # we have a parent ie already
716
 
        added = []
717
 
    else:
718
 
        # slower but does not need parent_ie
719
 
        if inv.has_filename(tree._fix_case_of_inventory_path(path.raw_path)):
720
 
            return []
721
 
        # its really not there : add the parent
722
 
        # note that the dirname use leads to some extra str copying etc but as
723
 
        # there are a limited number of dirs we can be nested under, it should
724
 
        # generally find it very fast and not recurse after that.
725
 
        added = _add_one_and_parent(tree, inv, None,
726
 
            _FastPath(osutils.dirname(path.raw_path)), 'directory', action)
727
 
        parent_id = inv.path2id(osutils.dirname(path.raw_path))
728
 
        parent_ie = inv[parent_id]
729
 
    _add_one(tree, inv, parent_ie, path, kind, action)
730
 
    return added + [path.raw_path]
731
 
 
732
 
 
733
 
def _add_one(tree, inv, parent_ie, path, kind, file_id_callback):
734
 
    """Add a new entry to the inventory.
735
 
 
736
 
    :param inv: Inventory which will receive the new entry.
737
 
    :param parent_ie: Parent inventory entry.
738
 
    :param kind: Kind of new entry (file, directory, etc)
739
 
    :param file_id_callback: callback(inv, parent_ie, path, kind); return a
740
 
        file_id or None to generate a new file id
741
 
    :returns: None
742
 
    """
743
 
    file_id = file_id_callback(inv, parent_ie, path, kind)
744
 
    entry = inv.make_entry(kind, path.base_path, parent_ie.file_id,
745
 
        file_id=file_id)
746
 
    inv.add(entry)
 
796
                            things_to_add.append((subp, sub_invp, None, this_ie))