← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

  • Committer: Vincent Ladeuil
  • Date: 2010-02-10 15:46:03 UTC
  • mfrom: (4985.3.21 update)
  • mto: This revision was merged to the branch mainline in revision 5021.
  • Revision ID: v.ladeuil+lp@free.fr-20100210154603-k4no1gvfuqpzrw7p
https://launchpad.net/bugs/113809
Update performs two merges in a more logical order but stop on conflicts

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tree.py
1
 
# Copyright (C) 2005 Canonical Ltd
 
1
# Copyright (C) 2005, 2009 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
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
"""Tree classes, representing directory at point in time.
18
18
"""
19
19
 
20
20
import os
21
21
from collections import deque
22
 
from cStringIO import StringIO
23
22
 
24
23
import bzrlib
25
24
from bzrlib import (
26
25
    conflicts as _mod_conflicts,
 
26
    debug,
27
27
    delta,
 
28
    filters,
28
29
    osutils,
29
30
    revision as _mod_revision,
30
31
    rules,
31
 
    symbol_versioning,
32
32
    )
33
33
from bzrlib.decorators import needs_read_lock
34
 
from bzrlib.errors import BzrError, BzrCheckError, NoSuchId
 
34
from bzrlib.errors import BzrError, NoSuchId
35
35
from bzrlib import errors
36
 
from bzrlib.inventory import Inventory, InventoryFile
 
36
from bzrlib.inventory import InventoryFile
37
37
from bzrlib.inter import InterObject
38
38
from bzrlib.osutils import fingerprint_file
39
39
import bzrlib.revision
40
40
from bzrlib.symbol_versioning import deprecated_function, deprecated_in
41
 
from bzrlib.trace import mutter, note
 
41
from bzrlib.trace import note
42
42
 
43
43
 
44
44
class Tree(object):
45
45
    """Abstract file tree.
46
46
 
47
47
    There are several subclasses:
48
 
    
 
48
 
49
49
    * `WorkingTree` exists as files on disk editable by the user.
50
50
 
51
51
    * `RevisionTree` is a tree as recorded at some point in the past.
60
60
    Trees can be compared, etc, regardless of whether they are working
61
61
    trees or versioned trees.
62
62
    """
63
 
    
 
63
 
64
64
    def changes_from(self, other, want_unchanged=False, specific_files=None,
65
65
        extra_trees=None, require_versioned=False, include_root=False,
66
66
        want_unversioned=False):
80
80
            a PathsNotVersionedError will be thrown.
81
81
        :param want_unversioned: Scan for unversioned paths.
82
82
 
83
 
        The comparison will be performed by an InterTree object looked up on 
 
83
        The comparison will be performed by an InterTree object looked up on
84
84
        self and other.
85
85
        """
86
86
        # Martin observes that Tree.changes_from returns a TreeDelta and this
95
95
            want_unversioned=want_unversioned,
96
96
            )
97
97
 
98
 
    @symbol_versioning.deprecated_method(symbol_versioning.one_three)
99
 
    def _iter_changes(self, *args, **kwargs):
100
 
        return self.iter_changes(*args, **kwargs)
101
 
 
102
98
    def iter_changes(self, from_tree, include_unchanged=False,
103
99
                     specific_files=None, pb=None, extra_trees=None,
104
100
                     require_versioned=True, want_unversioned=False):
105
101
        intertree = InterTree.get(from_tree, self)
106
102
        return intertree.iter_changes(include_unchanged, specific_files, pb,
107
103
            extra_trees, require_versioned, want_unversioned=want_unversioned)
108
 
    
 
104
 
109
105
    def conflicts(self):
110
106
        """Get a list of the conflicts in the tree.
111
107
 
118
114
        return []
119
115
 
120
116
    def get_parent_ids(self):
121
 
        """Get the parent ids for this tree. 
 
117
        """Get the parent ids for this tree.
122
118
 
123
119
        :return: a list of parent ids. [] is returned to indicate
124
120
        a tree with no parents.
125
121
        :raises: BzrError if the parents are not known.
126
122
        """
127
123
        raise NotImplementedError(self.get_parent_ids)
128
 
    
 
124
 
129
125
    def has_filename(self, filename):
130
126
        """True if the tree has given filename."""
131
127
        raise NotImplementedError(self.has_filename)
137
133
        return self.has_id(file_id)
138
134
 
139
135
    def has_or_had_id(self, file_id):
140
 
        if file_id == self.inventory.root.file_id:
141
 
            return True
142
136
        return self.inventory.has_id(file_id)
143
137
 
144
138
    def is_ignored(self, filename):
165
159
 
166
160
    def is_control_filename(self, filename):
167
161
        """True if filename is the name of a control file in this tree.
168
 
        
 
162
 
169
163
        :param filename: A filename within the tree. This is a relative path
170
164
        from the root of this tree.
171
165
 
176
170
        return self.bzrdir.is_control_filename(filename)
177
171
 
178
172
    @needs_read_lock
179
 
    def iter_entries_by_dir(self, specific_file_ids=None):
 
173
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
180
174
        """Walk the tree in 'by_dir' order.
181
175
 
182
176
        This will yield each entry in the tree as a (path, entry) tuple.
199
193
 
200
194
        The yield order (ignoring root) would be::
201
195
          a, f, a/b, a/d, a/b/c, a/d/e, f/g
 
196
 
 
197
        :param yield_parents: If True, yield the parents from the root leading
 
198
            down to specific_file_ids that have been requested. This has no
 
199
            impact if specific_file_ids is None.
202
200
        """
203
201
        return self.inventory.iter_entries_by_dir(
204
 
            specific_file_ids=specific_file_ids)
 
202
            specific_file_ids=specific_file_ids, yield_parents=yield_parents)
205
203
 
206
204
    def iter_references(self):
207
 
        for path, entry in self.iter_entries_by_dir():
208
 
            if entry.kind == 'tree-reference':
209
 
                yield path, entry.file_id
 
205
        if self.supports_tree_reference():
 
206
            for path, entry in self.iter_entries_by_dir():
 
207
                if entry.kind == 'tree-reference':
 
208
                    yield path, entry.file_id
210
209
 
211
210
    def kind(self, file_id):
212
211
        raise NotImplementedError("Tree subclass %s must implement kind"
222
221
 
223
222
    def path_content_summary(self, path):
224
223
        """Get a summary of the information about path.
225
 
        
 
224
 
 
225
        All the attributes returned are for the canonical form, not the
 
226
        convenient form (if content filters are in use.)
 
227
 
226
228
        :param path: A relative path within the tree.
227
229
        :return: A tuple containing kind, size, exec, sha1-or-link.
228
230
            Kind is always present (see tree.kind()).
229
 
            size is present if kind is file, None otherwise.
 
231
            size is present if kind is file and the size of the 
 
232
                canonical form can be cheaply determined, None otherwise.
230
233
            exec is None unless kind is file and the platform supports the 'x'
231
234
                bit.
232
235
            sha1-or-link is the link target if kind is symlink, or the sha1 if
255
258
 
256
259
    def _get_inventory(self):
257
260
        return self._inventory
258
 
    
 
261
 
259
262
    def get_file(self, file_id, path=None):
260
263
        """Return a file object for the file file_id in the tree.
261
 
        
 
264
 
262
265
        If both file_id and path are defined, it is implementation defined as
263
266
        to which one is used.
264
267
        """
265
268
        raise NotImplementedError(self.get_file)
266
269
 
 
270
    def get_file_with_stat(self, file_id, path=None):
 
271
        """Get a file handle and stat object for file_id.
 
272
 
 
273
        The default implementation returns (self.get_file, None) for backwards
 
274
        compatibility.
 
275
 
 
276
        :param file_id: The file id to read.
 
277
        :param path: The path of the file, if it is known.
 
278
        :return: A tuple (file_handle, stat_value_or_None). If the tree has
 
279
            no stat facility, or need for a stat cache feedback during commit,
 
280
            it may return None for the second element of the tuple.
 
281
        """
 
282
        return (self.get_file(file_id, path), None)
 
283
 
267
284
    def get_file_text(self, file_id, path=None):
268
285
        """Return the byte content of a file.
269
286
 
424
441
        raise NotImplementedError(self.annotate_iter)
425
442
 
426
443
    def _get_plan_merge_data(self, file_id, other, base):
427
 
        from bzrlib import merge, versionedfile
 
444
        from bzrlib import versionedfile
428
445
        vf = versionedfile._PlanMergeVersionedFile(file_id)
429
446
        last_revision_a = self._get_file_revision(file_id, vf, 'this:')
430
447
        last_revision_b = other._get_file_revision(file_id, vf, 'other:')
500
517
 
501
518
    def _check_retrieved(self, ie, f):
502
519
        if not __debug__:
503
 
            return  
 
520
            return
504
521
        fp = fingerprint_file(f)
505
522
        f.seek(0)
506
 
        
 
523
 
507
524
        if ie.text_size is not None:
508
525
            if ie.text_size != fp['size']:
509
526
                raise BzrError("mismatched size for file %r in %r" % (ie.file_id, self._store),
524
541
 
525
542
    def paths2ids(self, paths, trees=[], require_versioned=True):
526
543
        """Return all the ids that can be reached by walking from paths.
527
 
        
 
544
 
528
545
        Each path is looked up in this tree and any extras provided in
529
546
        trees, and this is repeated recursively: the children in an extra tree
530
547
        of a directory that has been renamed under a provided path in this tree
546
563
        for child in getattr(entry, 'children', {}).itervalues():
547
564
            yield child.file_id
548
565
 
549
 
    @symbol_versioning.deprecated_method(symbol_versioning.one_six)
550
 
    def print_file(self, file_id):
551
 
        """Print file with id `file_id` to stdout."""
552
 
        import sys
553
 
        sys.stdout.write(self.get_file_text(file_id))
554
 
 
555
566
    def lock_read(self):
556
567
        pass
557
568
 
560
571
 
561
572
        The intention of this method is to allow access to possibly cached
562
573
        tree data. Implementors of this method should raise NoSuchRevision if
563
 
        the tree is not locally available, even if they could obtain the 
564
 
        tree via a repository or some other means. Callers are responsible 
 
574
        the tree is not locally available, even if they could obtain the
 
575
        tree via a repository or some other means. Callers are responsible
565
576
        for finding the ultimate source for a revision tree.
566
577
 
567
578
        :param revision_id: The revision_id of the requested tree.
572
583
 
573
584
    def unknowns(self):
574
585
        """What files are present in this tree and unknown.
575
 
        
 
586
 
576
587
        :return: an iterator over the unknown files.
577
588
        """
578
589
        return iter([])
586
597
        :return: set of paths.
587
598
        """
588
599
        # NB: we specifically *don't* call self.has_filename, because for
589
 
        # WorkingTrees that can indicate files that exist on disk but that 
 
600
        # WorkingTrees that can indicate files that exist on disk but that
590
601
        # are not versioned.
591
602
        pred = self.inventory.has_filename
592
603
        return set((p for p in paths if not pred(p)))
597
608
        This yields all the data about the contents of a directory at a time.
598
609
        After each directory has been yielded, if the caller has mutated the
599
610
        list to exclude some directories, they are then not descended into.
600
 
        
 
611
 
601
612
        The data yielded is of the form:
602
613
        ((directory-relpath, directory-path-from-root, directory-fileid),
603
 
        [(relpath, basename, kind, lstat, path_from_tree_root, file_id, 
 
614
        [(relpath, basename, kind, lstat, path_from_tree_root, file_id,
604
615
          versioned_kind), ...]),
605
616
         - directory-relpath is the containing dirs relpath from prefix
606
617
         - directory-path-from-root is the containing dirs path from /
613
624
         - lstat is the stat data *if* the file was statted.
614
625
         - path_from_tree_root is the path from the root of the tree.
615
626
         - file_id is the file_id if the entry is versioned.
616
 
         - versioned_kind is the kind of the file as last recorded in the 
 
627
         - versioned_kind is the kind of the file as last recorded in the
617
628
           versioning system. If 'unknown' the file is not versioned.
618
629
        One of 'kind' and 'versioned_kind' must not be 'unknown'.
619
630
 
627
638
    def supports_content_filtering(self):
628
639
        return False
629
640
 
 
641
    def _content_filter_stack(self, path=None, file_id=None):
 
642
        """The stack of content filters for a path if filtering is supported.
 
643
 
 
644
        Readers will be applied in first-to-last order.
 
645
        Writers will be applied in last-to-first order.
 
646
        Either the path or the file-id needs to be provided.
 
647
 
 
648
        :param path: path relative to the root of the tree
 
649
            or None if unknown
 
650
        :param file_id: file_id or None if unknown
 
651
        :return: the list of filters - [] if there are none
 
652
        """
 
653
        filter_pref_names = filters._get_registered_names()
 
654
        if len(filter_pref_names) == 0:
 
655
            return []
 
656
        if path is None:
 
657
            path = self.id2path(file_id)
 
658
        prefs = self.iter_search_rules([path], filter_pref_names).next()
 
659
        stk = filters._get_filter_stack_for(prefs)
 
660
        if 'filters' in debug.debug_flags:
 
661
            note("*** %s content-filter: %s => %r" % (path,prefs,stk))
 
662
        return stk
 
663
 
 
664
    def _content_filter_stack_provider(self):
 
665
        """A function that returns a stack of ContentFilters.
 
666
 
 
667
        The function takes a path (relative to the top of the tree) and a
 
668
        file-id as parameters.
 
669
 
 
670
        :return: None if content filtering is not supported by this tree.
 
671
        """
 
672
        if self.supports_content_filtering():
 
673
            return lambda path, file_id: \
 
674
                    self._content_filter_stack(path, file_id)
 
675
        else:
 
676
            return None
 
677
 
630
678
    def iter_search_rules(self, path_names, pref_names=None,
631
 
        _default_searcher=rules._per_user_searcher):
 
679
        _default_searcher=None):
632
680
        """Find the preferences for filenames in a tree.
633
681
 
634
682
        :param path_names: an iterable of paths to find attributes for.
638
686
        :return: an iterator of tuple sequences, one per path-name.
639
687
          See _RulesSearcher.get_items for details on the tuple sequence.
640
688
        """
 
689
        if _default_searcher is None:
 
690
            _default_searcher = rules._per_user_searcher
641
691
        searcher = self._get_rules_searcher(_default_searcher)
642
692
        if searcher is not None:
643
693
            if pref_names is not None:
647
697
                for path in path_names:
648
698
                    yield searcher.get_items(path)
649
699
 
650
 
    @needs_read_lock
651
700
    def _get_rules_searcher(self, default_searcher):
652
701
        """Get the RulesSearcher for this tree given the default one."""
653
702
        searcher = default_searcher
654
703
        return searcher
655
704
 
656
705
 
657
 
class EmptyTree(Tree):
658
 
 
659
 
    def __init__(self):
660
 
        self._inventory = Inventory(root_id=None)
661
 
        symbol_versioning.warn('EmptyTree is deprecated as of bzr 0.9 please'
662
 
                               ' use repository.revision_tree instead.',
663
 
                               DeprecationWarning, stacklevel=2)
664
 
 
665
 
    def get_parent_ids(self):
666
 
        return []
667
 
 
668
 
    def get_symlink_target(self, file_id):
669
 
        return None
670
 
 
671
 
    def has_filename(self, filename):
672
 
        return False
673
 
 
674
 
    def kind(self, file_id):
675
 
        return "directory"
676
 
 
677
 
    def list_files(self, include_root=False):
678
 
        return iter([])
679
 
    
680
 
    def __contains__(self, file_id):
681
 
        return (file_id in self._inventory)
682
 
 
683
 
    def get_file_sha1(self, file_id, path=None, stat_value=None):
684
 
        return None
685
 
 
686
 
 
687
706
######################################################################
688
707
# diff
689
708
 
736
755
 
737
756
    return 'wtf?'
738
757
 
739
 
    
 
758
 
740
759
@deprecated_function(deprecated_in((1, 9, 0)))
741
760
def find_renames(old_inv, new_inv):
742
761
    for file_id in old_inv:
750
769
 
751
770
def find_ids_across_trees(filenames, trees, require_versioned=True):
752
771
    """Find the ids corresponding to specified filenames.
753
 
    
 
772
 
754
773
    All matches in all trees will be used, and all children of matched
755
774
    directories will be used.
756
775
 
770
789
 
771
790
def _find_ids_across_trees(filenames, trees, require_versioned):
772
791
    """Find the ids corresponding to specified filenames.
773
 
    
 
792
 
774
793
    All matches in all trees will be used, but subdirectories are not scanned.
775
794
 
776
795
    :param filenames: The filenames to find file_ids for
797
816
 
798
817
def _find_children_across_trees(specified_ids, trees):
799
818
    """Return a set including specified ids and their children.
800
 
    
 
819
 
801
820
    All matches in all trees will be used.
802
821
 
803
822
    :param trees: The trees to find file_ids within
804
 
    :return: a set containing all specified ids and their children 
 
823
    :return: a set containing all specified ids and their children
805
824
    """
806
825
    interesting_ids = set(specified_ids)
807
826
    pending = interesting_ids
811
830
        new_pending = set()
812
831
        for file_id in pending:
813
832
            for tree in trees:
814
 
                if not tree.has_id(file_id):
 
833
                if not tree.has_or_had_id(file_id):
815
834
                    continue
816
835
                for child_id in tree.iter_children(file_id):
817
836
                    if child_id not in interesting_ids:
832
851
    will pass through to InterTree as appropriate.
833
852
    """
834
853
 
 
854
    # Formats that will be used to test this InterTree. If both are
 
855
    # None, this InterTree will not be tested (e.g. because a complex
 
856
    # setup is required)
 
857
    _matching_from_tree_format = None
 
858
    _matching_to_tree_format = None
 
859
 
835
860
    _optimisers = []
836
861
 
 
862
    def _changes_from_entries(self, source_entry, target_entry,
 
863
        source_path=None, target_path=None):
 
864
        """Generate a iter_changes tuple between source_entry and target_entry.
 
865
 
 
866
        :param source_entry: An inventory entry from self.source, or None.
 
867
        :param target_entry: An inventory entry from self.target, or None.
 
868
        :param source_path: The path of source_entry, if known. If not known
 
869
            it will be looked up.
 
870
        :param target_path: The path of target_entry, if known. If not known
 
871
            it will be looked up.
 
872
        :return: A tuple, item 0 of which is an iter_changes result tuple, and
 
873
            item 1 is True if there are any changes in the result tuple.
 
874
        """
 
875
        if source_entry is None:
 
876
            if target_entry is None:
 
877
                return None
 
878
            file_id = target_entry.file_id
 
879
        else:
 
880
            file_id = source_entry.file_id
 
881
        if source_entry is not None:
 
882
            source_versioned = True
 
883
            source_name = source_entry.name
 
884
            source_parent = source_entry.parent_id
 
885
            if source_path is None:
 
886
                source_path = self.source.id2path(file_id)
 
887
            source_kind, source_executable, source_stat = \
 
888
                self.source._comparison_data(source_entry, source_path)
 
889
        else:
 
890
            source_versioned = False
 
891
            source_name = None
 
892
            source_parent = None
 
893
            source_kind = None
 
894
            source_executable = None
 
895
        if target_entry is not None:
 
896
            target_versioned = True
 
897
            target_name = target_entry.name
 
898
            target_parent = target_entry.parent_id
 
899
            if target_path is None:
 
900
                target_path = self.target.id2path(file_id)
 
901
            target_kind, target_executable, target_stat = \
 
902
                self.target._comparison_data(target_entry, target_path)
 
903
        else:
 
904
            target_versioned = False
 
905
            target_name = None
 
906
            target_parent = None
 
907
            target_kind = None
 
908
            target_executable = None
 
909
        versioned = (source_versioned, target_versioned)
 
910
        kind = (source_kind, target_kind)
 
911
        changed_content = False
 
912
        if source_kind != target_kind:
 
913
            changed_content = True
 
914
        elif source_kind == 'file':
 
915
            if (self.source.get_file_sha1(file_id, source_path, source_stat) !=
 
916
                self.target.get_file_sha1(file_id, target_path, target_stat)):
 
917
                changed_content = True
 
918
        elif source_kind == 'symlink':
 
919
            if (self.source.get_symlink_target(file_id) !=
 
920
                self.target.get_symlink_target(file_id)):
 
921
                changed_content = True
 
922
            # XXX: Yes, the indentation below is wrong. But fixing it broke
 
923
            # test_merge.TestMergerEntriesLCAOnDisk.
 
924
            # test_nested_tree_subtree_renamed_and_modified. We'll wait for
 
925
            # the fix from bzr.dev -- vila 2009026
 
926
            elif source_kind == 'tree-reference':
 
927
                if (self.source.get_reference_revision(file_id, source_path)
 
928
                    != self.target.get_reference_revision(file_id, target_path)):
 
929
                    changed_content = True
 
930
        parent = (source_parent, target_parent)
 
931
        name = (source_name, target_name)
 
932
        executable = (source_executable, target_executable)
 
933
        if (changed_content is not False or versioned[0] != versioned[1]
 
934
            or parent[0] != parent[1] or name[0] != name[1] or
 
935
            executable[0] != executable[1]):
 
936
            changes = True
 
937
        else:
 
938
            changes = False
 
939
        return (file_id, (source_path, target_path), changed_content,
 
940
                versioned, parent, name, kind, executable), changes
 
941
 
837
942
    @needs_read_lock
838
943
    def compare(self, want_unchanged=False, specific_files=None,
839
944
        extra_trees=None, require_versioned=False, include_root=False,
854
959
            a PathsNotVersionedError will be thrown.
855
960
        :param want_unversioned: Scan for unversioned paths.
856
961
        """
857
 
        # NB: show_status depends on being able to pass in non-versioned files
858
 
        # and report them as unknown
859
962
        trees = (self.source,)
860
963
        if extra_trees is not None:
861
964
            trees = trees + tuple(extra_trees)
902
1005
        :param require_versioned: Raise errors.PathsNotVersionedError if a
903
1006
            path in the specific_files list is not versioned in one of
904
1007
            source, target or extra_trees.
 
1008
        :param specific_files: An optional list of file paths to restrict the
 
1009
            comparison to. When mapping filenames to ids, all matches in all
 
1010
            trees (including optional extra_trees) are used, and all children
 
1011
            of matched directories are included. The parents in the target tree
 
1012
            of the specific files up to and including the root of the tree are
 
1013
            always evaluated for changes too.
905
1014
        :param want_unversioned: Should unversioned files be returned in the
906
1015
            output. An unversioned file is defined as one with (False, False)
907
1016
            for the versioned pair.
908
1017
        """
909
 
        result = []
910
1018
        lookup_trees = [self.source]
911
1019
        if extra_trees:
912
1020
             lookup_trees.extend(extra_trees)
 
1021
        # The ids of items we need to examine to insure delta consistency.
 
1022
        precise_file_ids = set()
 
1023
        changed_file_ids = []
913
1024
        if specific_files == []:
914
1025
            specific_file_ids = []
915
1026
        else:
916
1027
            specific_file_ids = self.target.paths2ids(specific_files,
917
1028
                lookup_trees, require_versioned=require_versioned)
 
1029
        if specific_files is not None:
 
1030
            # reparented or added entries must have their parents included
 
1031
            # so that valid deltas can be created. The seen_parents set
 
1032
            # tracks the parents that we need to have.
 
1033
            # The seen_dirs set tracks directory entries we've yielded.
 
1034
            # After outputting version object in to_entries we set difference
 
1035
            # the two seen sets and start checking parents.
 
1036
            seen_parents = set()
 
1037
            seen_dirs = set()
918
1038
        if want_unversioned:
919
1039
            all_unversioned = sorted([(p.split('/'), p) for p in
920
1040
                                     self.target.extras()
931
1051
            specific_file_ids=specific_file_ids))
932
1052
        num_entries = len(from_entries_by_dir) + len(to_entries_by_dir)
933
1053
        entry_count = 0
934
 
        # the unversioned path lookup only occurs on real trees - where there 
 
1054
        # the unversioned path lookup only occurs on real trees - where there
935
1055
        # can be extras. So the fake_entry is solely used to look up
936
1056
        # executable it values when execute is not supported.
937
1057
        fake_entry = InventoryFile('unused', 'unused', 'unused')
938
 
        for to_path, to_entry in to_entries_by_dir:
939
 
            while all_unversioned and all_unversioned[0][0] < to_path.split('/'):
 
1058
        for target_path, target_entry in to_entries_by_dir:
 
1059
            while (all_unversioned and
 
1060
                all_unversioned[0][0] < target_path.split('/')):
940
1061
                unversioned_path = all_unversioned.popleft()
941
 
                to_kind, to_executable, to_stat = \
 
1062
                target_kind, target_executable, target_stat = \
942
1063
                    self.target._comparison_data(fake_entry, unversioned_path[1])
943
1064
                yield (None, (None, unversioned_path[1]), True, (False, False),
944
1065
                    (None, None),
945
1066
                    (None, unversioned_path[0][-1]),
946
 
                    (None, to_kind),
947
 
                    (None, to_executable))
948
 
            file_id = to_entry.file_id
949
 
            to_paths[file_id] = to_path
 
1067
                    (None, target_kind),
 
1068
                    (None, target_executable))
 
1069
            source_path, source_entry = from_data.get(target_entry.file_id,
 
1070
                (None, None))
 
1071
            result, changes = self._changes_from_entries(source_entry,
 
1072
                target_entry, source_path=source_path, target_path=target_path)
 
1073
            to_paths[result[0]] = result[1][1]
950
1074
            entry_count += 1
951
 
            changed_content = False
952
 
            from_path, from_entry = from_data.get(file_id, (None, None))
953
 
            from_versioned = (from_entry is not None)
954
 
            if from_entry is not None:
955
 
                from_versioned = True
956
 
                from_name = from_entry.name
957
 
                from_parent = from_entry.parent_id
958
 
                from_kind, from_executable, from_stat = \
959
 
                    self.source._comparison_data(from_entry, from_path)
 
1075
            if result[3][0]:
960
1076
                entry_count += 1
961
 
            else:
962
 
                from_versioned = False
963
 
                from_kind = None
964
 
                from_parent = None
965
 
                from_name = None
966
 
                from_executable = None
967
 
            versioned = (from_versioned, True)
968
 
            to_kind, to_executable, to_stat = \
969
 
                self.target._comparison_data(to_entry, to_path)
970
 
            kind = (from_kind, to_kind)
971
 
            if kind[0] != kind[1]:
972
 
                changed_content = True
973
 
            elif from_kind == 'file':
974
 
                from_size = self.source._file_size(from_entry, from_stat)
975
 
                to_size = self.target._file_size(to_entry, to_stat)
976
 
                if from_size != to_size:
977
 
                    changed_content = True
978
 
                elif (self.source.get_file_sha1(file_id, from_path, from_stat) !=
979
 
                    self.target.get_file_sha1(file_id, to_path, to_stat)):
980
 
                    changed_content = True
981
 
            elif from_kind == 'symlink':
982
 
                if (self.source.get_symlink_target(file_id) !=
983
 
                    self.target.get_symlink_target(file_id)):
984
 
                    changed_content = True
985
 
                elif from_kind == 'tree-reference':
986
 
                    if (self.source.get_reference_revision(file_id, from_path)
987
 
                        != self.target.get_reference_revision(file_id, to_path)):
988
 
                        changed_content = True 
989
 
            parent = (from_parent, to_entry.parent_id)
990
 
            name = (from_name, to_entry.name)
991
 
            executable = (from_executable, to_executable)
992
1077
            if pb is not None:
993
1078
                pb.update('comparing files', entry_count, num_entries)
994
 
            if (changed_content is not False or versioned[0] != versioned[1]
995
 
                or parent[0] != parent[1] or name[0] != name[1] or 
996
 
                executable[0] != executable[1] or include_unchanged):
997
 
                yield (file_id, (from_path, to_path), changed_content,
998
 
                    versioned, parent, name, kind, executable)
999
 
 
 
1079
            if changes or include_unchanged:
 
1080
                if specific_file_ids is not None:
 
1081
                    new_parent_id = result[4][1]
 
1082
                    precise_file_ids.add(new_parent_id)
 
1083
                    changed_file_ids.append(result[0])
 
1084
                yield result
 
1085
            # Ensure correct behaviour for reparented/added specific files.
 
1086
            if specific_files is not None:
 
1087
                # Record output dirs
 
1088
                if result[6][1] == 'directory':
 
1089
                    seen_dirs.add(result[0])
 
1090
                # Record parents of reparented/added entries.
 
1091
                versioned = result[3]
 
1092
                parents = result[4]
 
1093
                if not versioned[0] or parents[0] != parents[1]:
 
1094
                    seen_parents.add(parents[1])
1000
1095
        while all_unversioned:
1001
1096
            # yield any trailing unversioned paths
1002
1097
            unversioned_path = all_unversioned.popleft()
1007
1102
                (None, unversioned_path[0][-1]),
1008
1103
                (None, to_kind),
1009
1104
                (None, to_executable))
1010
 
 
1011
 
        def get_to_path(to_entry):
1012
 
            if to_entry.parent_id is None:
1013
 
                to_path = '' # the root
1014
 
            else:
1015
 
                if to_entry.parent_id not in to_paths:
1016
 
                    # recurse up
1017
 
                    return get_to_path(self.target.inventory[to_entry.parent_id])
1018
 
                to_path = osutils.pathjoin(to_paths[to_entry.parent_id],
1019
 
                                           to_entry.name)
1020
 
            to_paths[to_entry.file_id] = to_path
1021
 
            return to_path
1022
 
 
 
1105
        # Yield all remaining source paths
1023
1106
        for path, from_entry in from_entries_by_dir:
1024
1107
            file_id = from_entry.file_id
1025
1108
            if file_id in to_paths:
1026
1109
                # already returned
1027
1110
                continue
1028
 
            if not file_id in self.target.all_file_ids():
 
1111
            if file_id not in self.target.all_file_ids():
1029
1112
                # common case - paths we have not emitted are not present in
1030
1113
                # target.
1031
1114
                to_path = None
1032
1115
            else:
1033
 
                to_path = get_to_path(self.target.inventory[file_id])
 
1116
                to_path = self.target.id2path(file_id)
1034
1117
            entry_count += 1
1035
1118
            if pb is not None:
1036
1119
                pb.update('comparing files', entry_count, num_entries)
1043
1126
            executable = (from_executable, None)
1044
1127
            changed_content = from_kind is not None
1045
1128
            # the parent's path is necessarily known at this point.
 
1129
            changed_file_ids.append(file_id)
1046
1130
            yield(file_id, (path, to_path), changed_content, versioned, parent,
1047
1131
                  name, kind, executable)
 
1132
        changed_file_ids = set(changed_file_ids)
 
1133
        if specific_file_ids is not None:
 
1134
            for result in self._handle_precise_ids(precise_file_ids,
 
1135
                changed_file_ids):
 
1136
                yield result
 
1137
 
 
1138
    def _get_entry(self, tree, file_id):
 
1139
        """Get an inventory entry from a tree, with missing entries as None.
 
1140
 
 
1141
        If the tree raises NotImplementedError on accessing .inventory, then
 
1142
        this is worked around using iter_entries_by_dir on just the file id
 
1143
        desired.
 
1144
 
 
1145
        :param tree: The tree to lookup the entry in.
 
1146
        :param file_id: The file_id to lookup.
 
1147
        """
 
1148
        try:
 
1149
            inventory = tree.inventory
 
1150
        except NotImplementedError:
 
1151
            # No inventory available.
 
1152
            try:
 
1153
                iterator = tree.iter_entries_by_dir(specific_file_ids=[file_id])
 
1154
                return iterator.next()[1]
 
1155
            except StopIteration:
 
1156
                return None
 
1157
        else:
 
1158
            try:
 
1159
                return inventory[file_id]
 
1160
            except errors.NoSuchId:
 
1161
                return None
 
1162
 
 
1163
    def _handle_precise_ids(self, precise_file_ids, changed_file_ids,
 
1164
        discarded_changes=None):
 
1165
        """Fill out a partial iter_changes to be consistent.
 
1166
 
 
1167
        :param precise_file_ids: The file ids of parents that were seen during
 
1168
            the iter_changes.
 
1169
        :param changed_file_ids: The file ids of already emitted items.
 
1170
        :param discarded_changes: An optional dict of precalculated
 
1171
            iter_changes items which the partial iter_changes had not output
 
1172
            but had calculated.
 
1173
        :return: A generator of iter_changes items to output.
 
1174
        """
 
1175
        # process parents of things that had changed under the users
 
1176
        # requested paths to prevent incorrect paths or parent ids which
 
1177
        # aren't in the tree.
 
1178
        while precise_file_ids:
 
1179
            precise_file_ids.discard(None)
 
1180
            # Don't emit file_ids twice
 
1181
            precise_file_ids.difference_update(changed_file_ids)
 
1182
            if not precise_file_ids:
 
1183
                break
 
1184
            # If the there was something at a given output path in source, we
 
1185
            # have to include the entry from source in the delta, or we would
 
1186
            # be putting this entry into a used path.
 
1187
            paths = []
 
1188
            for parent_id in precise_file_ids:
 
1189
                try:
 
1190
                    paths.append(self.target.id2path(parent_id))
 
1191
                except errors.NoSuchId:
 
1192
                    # This id has been dragged in from the source by delta
 
1193
                    # expansion and isn't present in target at all: we don't
 
1194
                    # need to check for path collisions on it.
 
1195
                    pass
 
1196
            for path in paths:
 
1197
                old_id = self.source.path2id(path)
 
1198
                precise_file_ids.add(old_id)
 
1199
            precise_file_ids.discard(None)
 
1200
            current_ids = precise_file_ids
 
1201
            precise_file_ids = set()
 
1202
            # We have to emit all of precise_file_ids that have been altered.
 
1203
            # We may have to output the children of some of those ids if any
 
1204
            # directories have stopped being directories.
 
1205
            for file_id in current_ids:
 
1206
                # Examine file_id
 
1207
                if discarded_changes:
 
1208
                    result = discarded_changes.get(file_id)
 
1209
                    old_entry = None
 
1210
                else:
 
1211
                    result = None
 
1212
                if result is None:
 
1213
                    old_entry = self._get_entry(self.source, file_id)
 
1214
                    new_entry = self._get_entry(self.target, file_id)
 
1215
                    result, changes = self._changes_from_entries(
 
1216
                        old_entry, new_entry)
 
1217
                else:
 
1218
                    changes = True
 
1219
                # Get this parents parent to examine.
 
1220
                new_parent_id = result[4][1]
 
1221
                precise_file_ids.add(new_parent_id)
 
1222
                if changes:
 
1223
                    if (result[6][0] == 'directory' and
 
1224
                        result[6][1] != 'directory'):
 
1225
                        # This stopped being a directory, the old children have
 
1226
                        # to be included.
 
1227
                        if old_entry is None:
 
1228
                            # Reusing a discarded change.
 
1229
                            old_entry = self._get_entry(self.source, file_id)
 
1230
                        for child in old_entry.children.values():
 
1231
                            precise_file_ids.add(child.file_id)
 
1232
                    changed_file_ids.add(result[0])
 
1233
                    yield result
1048
1234
 
1049
1235
 
1050
1236
class MultiWalker(object):
1167
1353
 
1168
1354
    def _walk_master_tree(self):
1169
1355
        """First pass, walk all trees in lock-step.
1170
 
        
 
1356
 
1171
1357
        When we are done, all nodes in the master_tree will have been
1172
1358
        processed. _other_walkers, _other_entries, and _others_extra will be
1173
1359
        set on 'self' for future processing.