/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

  • Committer: Robert Collins
  • Date: 2007-07-04 08:08:13 UTC
  • mfrom: (2572 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2587.
  • Revision ID: robertc@robertcollins.net-20070704080813-wzebx0r88fvwj5rq
Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tree.py
18
18
"""
19
19
 
20
20
import os
 
21
from collections import deque
21
22
from cStringIO import StringIO
22
 
from warnings import warn
23
23
 
24
24
import bzrlib
25
 
from bzrlib import delta
 
25
from bzrlib import (
 
26
    delta,
 
27
    osutils,
 
28
    symbol_versioning,
 
29
    )
26
30
from bzrlib.decorators import needs_read_lock
27
31
from bzrlib.errors import BzrError, BzrCheckError
28
32
from bzrlib import errors
29
 
from bzrlib.inventory import Inventory
 
33
from bzrlib.inventory import Inventory, InventoryFile
30
34
from bzrlib.inter import InterObject
31
35
from bzrlib.osutils import fingerprint_file
32
36
import bzrlib.revision
54
58
    """
55
59
    
56
60
    def changes_from(self, other, want_unchanged=False, specific_files=None,
57
 
        extra_trees=None, require_versioned=False, include_root=False):
 
61
        extra_trees=None, require_versioned=False, include_root=False,
 
62
        want_unversioned=False):
58
63
        """Return a TreeDelta of the changes from other to this tree.
59
64
 
60
65
        :param other: A tree to compare with.
69
74
        :param require_versioned: An optional boolean (defaults to False). When
70
75
            supplied and True all the 'specific_files' must be versioned, or
71
76
            a PathsNotVersionedError will be thrown.
 
77
        :param want_unversioned: Scan for unversioned paths.
72
78
 
73
79
        The comparison will be performed by an InterTree object looked up on 
74
80
        self and other.
81
87
            specific_files=specific_files,
82
88
            extra_trees=extra_trees,
83
89
            require_versioned=require_versioned,
84
 
            include_root=include_root
 
90
            include_root=include_root,
 
91
            want_unversioned=want_unversioned,
85
92
            )
 
93
 
 
94
    def _iter_changes(self, from_tree, include_unchanged=False,
 
95
                     specific_files=None, pb=None, extra_trees=None,
 
96
                     require_versioned=True, want_unversioned=False):
 
97
        intertree = InterTree.get(from_tree, self)
 
98
        return intertree._iter_changes(include_unchanged, specific_files, pb,
 
99
            extra_trees, require_versioned, want_unversioned=want_unversioned)
86
100
    
87
101
    def conflicts(self):
88
102
        """Get a list of the conflicts in the tree.
91
105
        """
92
106
        return []
93
107
 
 
108
    def extras(self):
 
109
        """For trees that can have unversioned files, return all such paths."""
 
110
        return []
 
111
 
94
112
    def get_parent_ids(self):
95
113
        """Get the parent ids for this tree. 
96
114
 
105
123
        raise NotImplementedError()
106
124
 
107
125
    def has_id(self, file_id):
 
126
        file_id = osutils.safe_file_id(file_id)
108
127
        return self.inventory.has_id(file_id)
109
128
 
110
129
    __contains__ = has_id
111
130
 
112
131
    def has_or_had_id(self, file_id):
 
132
        file_id = osutils.safe_file_id(file_id)
113
133
        if file_id == self.inventory.root.file_id:
114
134
            return True
115
135
        return self.inventory.has_id(file_id)
116
136
 
 
137
    def is_ignored(self, filename):
 
138
        """Check whether the filename is ignored by this tree.
 
139
 
 
140
        :param filename: The relative filename within the tree.
 
141
        :return: True if the filename is ignored.
 
142
        """
 
143
        return False
 
144
 
117
145
    def __iter__(self):
118
146
        return iter(self.inventory)
119
147
 
120
148
    def id2path(self, file_id):
 
149
        """Return the path for a file id.
 
150
 
 
151
        :raises NoSuchId:
 
152
        """
 
153
        file_id = osutils.safe_file_id(file_id)
121
154
        return self.inventory.id2path(file_id)
122
155
 
123
156
    def is_control_filename(self, filename):
132
165
        """
133
166
        return self.bzrdir.is_control_filename(filename)
134
167
 
135
 
    def iter_entries_by_dir(self):
 
168
    @needs_read_lock
 
169
    def iter_entries_by_dir(self, specific_file_ids=None):
136
170
        """Walk the tree in 'by_dir' order.
137
171
 
138
172
        This will yield each entry in the tree as a (path, entry) tuple. The
140
174
        preceeded by the parent of a directory, and all the contents of a 
141
175
        directory are grouped together.
142
176
        """
143
 
        return self.inventory.iter_entries_by_dir()
 
177
        return self.inventory.iter_entries_by_dir(
 
178
            specific_file_ids=specific_file_ids)
 
179
 
 
180
    def iter_references(self):
 
181
        for path, entry in self.iter_entries_by_dir():
 
182
            if entry.kind == 'tree-reference':
 
183
                yield path, entry.file_id
144
184
 
145
185
    def kind(self, file_id):
146
 
        raise NotImplementedError("subclasses must implement kind")
 
186
        raise NotImplementedError("Tree subclass %s must implement kind"
 
187
            % self.__class__.__name__)
 
188
 
 
189
    def get_reference_revision(self, file_id, path=None):
 
190
        raise NotImplementedError("Tree subclass %s must implement "
 
191
                                  "get_reference_revision"
 
192
            % self.__class__.__name__)
 
193
 
 
194
    def _comparison_data(self, entry, path):
 
195
        """Return a tuple of kind, executable, stat_value for a file.
 
196
 
 
197
        entry may be None if there is no inventory entry for the file, but
 
198
        path must always be supplied.
 
199
 
 
200
        kind is None if there is no file present (even if an inventory id is
 
201
        present).  executable is False for non-file entries.
 
202
        """
 
203
        raise NotImplementedError(self._comparison_data)
 
204
 
 
205
    def _file_size(self, entry, stat_value):
 
206
        raise NotImplementedError(self._file_size)
147
207
 
148
208
    def _get_inventory(self):
149
209
        return self._inventory
151
211
    def get_file(self, file_id):
152
212
        """Return a file object for the file file_id in the tree."""
153
213
        raise NotImplementedError(self.get_file)
154
 
    
 
214
 
 
215
    def get_file_mtime(self, file_id, path=None):
 
216
        """Return the modification time for a file.
 
217
 
 
218
        :param file_id: The handle for this file.
 
219
        :param path: The path that this file can be found at.
 
220
            These must point to the same object.
 
221
        """
 
222
        raise NotImplementedError(self.get_file_mtime)
 
223
 
155
224
    def get_file_by_path(self, path):
156
225
        return self.get_file(self._inventory.path2id(path))
157
226
 
 
227
    def get_symlink_target(self, file_id):
 
228
        """Get the target for a given file_id.
 
229
 
 
230
        It is assumed that the caller already knows that file_id is referencing
 
231
        a symlink.
 
232
        :param file_id: Handle for the symlink entry.
 
233
        :return: The path the symlink points to.
 
234
        """
 
235
        raise NotImplementedError(self.get_symlink_target)
 
236
 
 
237
    def annotate_iter(self, file_id):
 
238
        """Return an iterator of revision_id, line tuples
 
239
 
 
240
        For working trees (and mutable trees in general), the special
 
241
        revision_id 'current:' will be used for lines that are new in this
 
242
        tree, e.g. uncommitted changes.
 
243
        :param file_id: The file to produce an annotated version from
 
244
        """
 
245
        raise NotImplementedError(self.annotate_iter)
 
246
 
158
247
    inventory = property(_get_inventory,
159
248
                         doc="Inventory of this Tree")
160
249
 
177
266
                     "file is actually %s" % fp['sha1'],
178
267
                     "store is probably damaged/corrupt"])
179
268
 
 
269
    @needs_read_lock
180
270
    def path2id(self, path):
181
271
        """Return the id for path in this tree."""
182
272
        return self._inventory.path2id(path)
183
273
 
 
274
    def paths2ids(self, paths, trees=[], require_versioned=True):
 
275
        """Return all the ids that can be reached by walking from paths.
 
276
        
 
277
        Each path is looked up in each this tree and any extras provided in
 
278
        trees, and this is repeated recursively: the children in an extra tree
 
279
        of a directory that has been renamed under a provided path in this tree
 
280
        are all returned, even if none exist until a provided path in this
 
281
        tree, and vice versa.
 
282
 
 
283
        :param paths: An iterable of paths to start converting to ids from.
 
284
            Alternatively, if paths is None, no ids should be calculated and None
 
285
            will be returned. This is offered to make calling the api unconditional
 
286
            for code that *might* take a list of files.
 
287
        :param trees: Additional trees to consider.
 
288
        :param require_versioned: If False, do not raise NotVersionedError if
 
289
            an element of paths is not versioned in this tree and all of trees.
 
290
        """
 
291
        return find_ids_across_trees(paths, [self] + list(trees), require_versioned)
 
292
 
184
293
    def print_file(self, file_id):
185
294
        """Print file with id `file_id` to stdout."""
 
295
        file_id = osutils.safe_file_id(file_id)
186
296
        import sys
187
297
        sys.stdout.write(self.get_file_text(file_id))
188
298
 
189
299
    def lock_read(self):
190
300
        pass
191
301
 
 
302
    def revision_tree(self, revision_id):
 
303
        """Obtain a revision tree for the revision revision_id.
 
304
 
 
305
        The intention of this method is to allow access to possibly cached
 
306
        tree data. Implementors of this method should raise NoSuchRevision if
 
307
        the tree is not locally available, even if they could obtain the 
 
308
        tree via a repository or some other means. Callers are responsible 
 
309
        for finding the ultimate source for a revision tree.
 
310
 
 
311
        :param revision_id: The revision_id of the requested tree.
 
312
        :return: A Tree.
 
313
        :raises: NoSuchRevision if the tree cannot be obtained.
 
314
        """
 
315
        raise errors.NoSuchRevisionInTree(self, revision_id)
 
316
 
192
317
    def unknowns(self):
193
318
        """What files are present in this tree and unknown.
194
319
        
200
325
        pass
201
326
 
202
327
    def filter_unversioned_files(self, paths):
203
 
        """Filter out paths that are not versioned.
 
328
        """Filter out paths that are versioned.
204
329
 
205
330
        :return: set of paths.
206
331
        """
210
335
        pred = self.inventory.has_filename
211
336
        return set((p for p in paths if not pred(p)))
212
337
 
213
 
 
214
 
# for compatibility
215
 
from bzrlib.revisiontree import RevisionTree
216
 
 
 
338
    def walkdirs(self, prefix=""):
 
339
        """Walk the contents of this tree from path down.
 
340
 
 
341
        This yields all the data about the contents of a directory at a time.
 
342
        After each directory has been yielded, if the caller has mutated the
 
343
        list to exclude some directories, they are then not descended into.
 
344
        
 
345
        The data yielded is of the form:
 
346
        ((directory-relpath, directory-path-from-root, directory-fileid),
 
347
        [(relpath, basename, kind, lstat, path_from_tree_root, file_id, 
 
348
          versioned_kind), ...]),
 
349
         - directory-relpath is the containing dirs relpath from prefix
 
350
         - directory-path-from-root is the containing dirs path from /
 
351
         - directory-fileid is the id of the directory if it is versioned.
 
352
         - relpath is the relative path within the subtree being walked.
 
353
         - basename is the basename
 
354
         - kind is the kind of the file now. If unknonwn then the file is not
 
355
           present within the tree - but it may be recorded as versioned. See
 
356
           versioned_kind.
 
357
         - lstat is the stat data *if* the file was statted.
 
358
         - path_from_tree_root is the path from the root of the tree.
 
359
         - file_id is the file_id is the entry is versioned.
 
360
         - versioned_kind is the kind of the file as last recorded in the 
 
361
           versioning system. If 'unknown' the file is not versioned.
 
362
        One of 'kind' and 'versioned_kind' must not be 'unknown'.
 
363
 
 
364
        :param prefix: Start walking from prefix within the tree rather than
 
365
        at the root. This allows one to walk a subtree but get paths that are
 
366
        relative to a tree rooted higher up.
 
367
        :return: an iterator over the directory data.
 
368
        """
 
369
        raise NotImplementedError(self.walkdirs)
 
370
 
217
371
 
218
372
class EmptyTree(Tree):
219
373
 
220
374
    def __init__(self):
221
 
        self._inventory = Inventory()
222
 
        warn('EmptyTree is deprecated as of bzr 0.9 please use '
223
 
            'repository.revision_tree instead.',
224
 
            DeprecationWarning, stacklevel=2)
 
375
        self._inventory = Inventory(root_id=None)
 
376
        symbol_versioning.warn('EmptyTree is deprecated as of bzr 0.9 please'
 
377
                               ' use repository.revision_tree instead.',
 
378
                               DeprecationWarning, stacklevel=2)
225
379
 
226
380
    def get_parent_ids(self):
227
381
        return []
233
387
        return False
234
388
 
235
389
    def kind(self, file_id):
 
390
        file_id = osutils.safe_file_id(file_id)
236
391
        assert self._inventory[file_id].kind == "directory"
237
392
        return "directory"
238
393
 
239
 
    def list_files(self):
 
394
    def list_files(self, include_root=False):
240
395
        return iter([])
241
396
    
242
397
    def __contains__(self, file_id):
 
398
        file_id = osutils.safe_file_id(file_id)
243
399
        return (file_id in self._inventory)
244
400
 
245
 
    def get_file_sha1(self, file_id, path=None):
 
401
    def get_file_sha1(self, file_id, path=None, stat_value=None):
246
402
        return None
247
403
 
248
404
 
317
473
    All matches in all trees will be used, and all children of matched
318
474
    directories will be used.
319
475
 
320
 
    :param filenames: The filenames to find file_ids for
 
476
    :param filenames: The filenames to find file_ids for (if None, returns
 
477
        None)
321
478
    :param trees: The trees to find file_ids within
322
479
    :param require_versioned: if true, all specified filenames must occur in
323
480
    at least one tree.
325
482
    """
326
483
    if not filenames:
327
484
        return None
328
 
    specified_ids = _find_filename_ids_across_trees(filenames, trees, 
329
 
                                                    require_versioned)
330
 
    return _find_children_across_trees(specified_ids, trees)
331
 
 
332
 
 
333
 
def _find_filename_ids_across_trees(filenames, trees, require_versioned):
 
485
    specified_path_ids = _find_ids_across_trees(filenames, trees,
 
486
        require_versioned)
 
487
    return _find_children_across_trees(specified_path_ids, trees)
 
488
 
 
489
 
 
490
def _find_ids_across_trees(filenames, trees, require_versioned):
334
491
    """Find the ids corresponding to specified filenames.
335
492
    
336
 
    All matches in all trees will be used.
 
493
    All matches in all trees will be used, but subdirectories are not scanned.
337
494
 
338
495
    :param filenames: The filenames to find file_ids for
339
496
    :param trees: The trees to find file_ids within
340
497
    :param require_versioned: if true, all specified filenames must occur in
341
 
    at least one tree.
342
 
    :return: a set of file ids for the specified filenames
 
498
        at least one tree.
 
499
    :return: a set of (path, file ids) for the specified filenames
343
500
    """
344
501
    not_versioned = []
345
502
    interesting_ids = set()
346
503
    for tree_path in filenames:
347
504
        not_found = True
348
505
        for tree in trees:
349
 
            file_id = tree.inventory.path2id(tree_path)
 
506
            file_id = tree.path2id(tree_path)
350
507
            if file_id is not None:
351
508
                interesting_ids.add(file_id)
352
509
                not_found = False
373
530
        new_pending = set()
374
531
        for file_id in pending:
375
532
            for tree in trees:
376
 
                if file_id not in tree:
 
533
                if not tree.has_id(file_id):
377
534
                    continue
378
535
                entry = tree.inventory[file_id]
379
536
                for child in getattr(entry, 'children', {}).itervalues():
399
556
 
400
557
    @needs_read_lock
401
558
    def compare(self, want_unchanged=False, specific_files=None,
402
 
        extra_trees=None, require_versioned=False, include_root=False):
 
559
        extra_trees=None, require_versioned=False, include_root=False,
 
560
        want_unversioned=False):
403
561
        """Return the changes from source to target.
404
562
 
405
563
        :return: A TreeDelta.
414
572
        :param require_versioned: An optional boolean (defaults to False). When
415
573
            supplied and True all the 'specific_files' must be versioned, or
416
574
            a PathsNotVersionedError will be thrown.
 
575
        :param want_unversioned: Scan for unversioned paths.
417
576
        """
418
 
        # NB: show_status depends on being able to pass in non-versioned files and
419
 
        # report them as unknown
420
 
        trees = (self.source, self.target)
 
577
        # NB: show_status depends on being able to pass in non-versioned files
 
578
        # and report them as unknown
 
579
        trees = (self.source,)
421
580
        if extra_trees is not None:
422
581
            trees = trees + tuple(extra_trees)
423
 
        specific_file_ids = find_ids_across_trees(specific_files,
424
 
            trees, require_versioned=require_versioned)
 
582
        # target is usually the newer tree:
 
583
        specific_file_ids = self.target.paths2ids(specific_files, trees,
 
584
            require_versioned=require_versioned)
425
585
        if specific_files and not specific_file_ids:
426
586
            # All files are unversioned, so just return an empty delta
427
587
            # _compare_trees would think we want a complete delta
428
 
            return delta.TreeDelta()
 
588
            result = delta.TreeDelta()
 
589
            fake_entry = InventoryFile('unused', 'unused', 'unused')
 
590
            result.unversioned = [(path, None,
 
591
                self.target._comparison_data(fake_entry, path)[0]) for path in
 
592
                specific_files]
 
593
            return result
429
594
        return delta._compare_trees(self.source, self.target, want_unchanged,
430
 
            specific_file_ids, include_root)
 
595
            specific_files, include_root, extra_trees=extra_trees,
 
596
            want_unversioned=want_unversioned)
 
597
 
 
598
    def _iter_changes(self, include_unchanged=False,
 
599
                      specific_files=None, pb=None, extra_trees=[],
 
600
                      require_versioned=True, want_unversioned=False):
 
601
        """Generate an iterator of changes between trees.
 
602
 
 
603
        A tuple is returned:
 
604
        (file_id, (path_in_source, path_in_target),
 
605
         changed_content, versioned, parent, name, kind,
 
606
         executable)
 
607
 
 
608
        Changed_content is True if the file's content has changed.  This
 
609
        includes changes to its kind, and to a symlink's target.
 
610
 
 
611
        versioned, parent, name, kind, executable are tuples of (from, to).
 
612
        If a file is missing in a tree, its kind is None.
 
613
 
 
614
        Iteration is done in parent-to-child order, relative to the target
 
615
        tree.
 
616
 
 
617
        There is no guarantee that all paths are in sorted order: the
 
618
        requirement to expand the search due to renames may result in children
 
619
        that should be found early being found late in the search, after
 
620
        lexically later results have been returned.
 
621
        :param require_versioned: Raise errors.PathsNotVersionedError if a
 
622
            path in the specific_files list is not versioned in one of
 
623
            source, target or extra_trees.
 
624
        :param want_unversioned: Should unversioned files be returned in the
 
625
            output. An unversioned file is defined as one with (False, False)
 
626
            for the versioned pair.
 
627
        """
 
628
        result = []
 
629
        lookup_trees = [self.source]
 
630
        if extra_trees:
 
631
             lookup_trees.extend(extra_trees)
 
632
        specific_file_ids = self.target.paths2ids(specific_files,
 
633
            lookup_trees, require_versioned=require_versioned)
 
634
        if want_unversioned:
 
635
            all_unversioned = sorted([(p.split('/'), p) for p in self.target.extras()
 
636
                if not specific_files or
 
637
                    osutils.is_inside_any(specific_files, p)])
 
638
            all_unversioned = deque(all_unversioned)
 
639
        else:
 
640
            all_unversioned = deque()
 
641
        to_paths = {}
 
642
        from_entries_by_dir = list(self.source.inventory.iter_entries_by_dir(
 
643
            specific_file_ids=specific_file_ids))
 
644
        from_data = dict((e.file_id, (p, e)) for p, e in from_entries_by_dir)
 
645
        to_entries_by_dir = list(self.target.inventory.iter_entries_by_dir(
 
646
            specific_file_ids=specific_file_ids))
 
647
        num_entries = len(from_entries_by_dir) + len(to_entries_by_dir)
 
648
        entry_count = 0
 
649
        # the unversioned path lookup only occurs on real trees - where there 
 
650
        # can be extras. So the fake_entry is solely used to look up
 
651
        # executable it values when execute is not supported.
 
652
        fake_entry = InventoryFile('unused', 'unused', 'unused')
 
653
        for to_path, to_entry in to_entries_by_dir:
 
654
            while all_unversioned and all_unversioned[0][0] < to_path.split('/'):
 
655
                unversioned_path = all_unversioned.popleft()
 
656
                to_kind, to_executable, to_stat = \
 
657
                    self.target._comparison_data(fake_entry, unversioned_path[1])
 
658
                yield (None, (None, unversioned_path[1]), True, (False, False),
 
659
                    (None, None),
 
660
                    (None, unversioned_path[0][-1]),
 
661
                    (None, to_kind),
 
662
                    (None, to_executable))
 
663
            file_id = to_entry.file_id
 
664
            to_paths[file_id] = to_path
 
665
            entry_count += 1
 
666
            changed_content = False
 
667
            from_path, from_entry = from_data.get(file_id, (None, None))
 
668
            from_versioned = (from_entry is not None)
 
669
            if from_entry is not None:
 
670
                from_versioned = True
 
671
                from_name = from_entry.name
 
672
                from_parent = from_entry.parent_id
 
673
                from_kind, from_executable, from_stat = \
 
674
                    self.source._comparison_data(from_entry, from_path)
 
675
                entry_count += 1
 
676
            else:
 
677
                from_versioned = False
 
678
                from_kind = None
 
679
                from_parent = None
 
680
                from_name = None
 
681
                from_executable = None
 
682
            versioned = (from_versioned, True)
 
683
            to_kind, to_executable, to_stat = \
 
684
                self.target._comparison_data(to_entry, to_path)
 
685
            kind = (from_kind, to_kind)
 
686
            if kind[0] != kind[1]:
 
687
                changed_content = True
 
688
            elif from_kind == 'file':
 
689
                from_size = self.source._file_size(from_entry, from_stat)
 
690
                to_size = self.target._file_size(to_entry, to_stat)
 
691
                if from_size != to_size:
 
692
                    changed_content = True
 
693
                elif (self.source.get_file_sha1(file_id, from_path, from_stat) !=
 
694
                    self.target.get_file_sha1(file_id, to_path, to_stat)):
 
695
                    changed_content = True
 
696
            elif from_kind == 'symlink':
 
697
                if (self.source.get_symlink_target(file_id) !=
 
698
                    self.target.get_symlink_target(file_id)):
 
699
                    changed_content = True
 
700
                elif from_kind == 'tree-reference':
 
701
                    if (self.source.get_reference_revision(file_id, from_path)
 
702
                        != self.target.get_reference_revision(file_id, to_path)):
 
703
                        changed_content = True 
 
704
            parent = (from_parent, to_entry.parent_id)
 
705
            name = (from_name, to_entry.name)
 
706
            executable = (from_executable, to_executable)
 
707
            if pb is not None:
 
708
                pb.update('comparing files', entry_count, num_entries)
 
709
            if (changed_content is not False or versioned[0] != versioned[1]
 
710
                or parent[0] != parent[1] or name[0] != name[1] or 
 
711
                executable[0] != executable[1] or include_unchanged):
 
712
                yield (file_id, (from_path, to_path), changed_content,
 
713
                    versioned, parent, name, kind, executable)
 
714
 
 
715
        while all_unversioned:
 
716
            # yield any trailing unversioned paths
 
717
            unversioned_path = all_unversioned.popleft()
 
718
            to_kind, to_executable, to_stat = \
 
719
                self.target._comparison_data(fake_entry, unversioned_path[1])
 
720
            yield (None, (None, unversioned_path[1]), True, (False, False),
 
721
                (None, None),
 
722
                (None, unversioned_path[0][-1]),
 
723
                (None, to_kind),
 
724
                (None, to_executable))
 
725
 
 
726
        def get_to_path(to_entry):
 
727
            if to_entry.parent_id is None:
 
728
                to_path = '' # the root
 
729
            else:
 
730
                if to_entry.parent_id not in to_paths:
 
731
                    # recurse up
 
732
                    return get_to_path(self.target.inventory[to_entry.parent_id])
 
733
                to_path = osutils.pathjoin(to_paths[to_entry.parent_id],
 
734
                                           to_entry.name)
 
735
            to_paths[to_entry.file_id] = to_path
 
736
            return to_path
 
737
 
 
738
        for path, from_entry in from_entries_by_dir:
 
739
            file_id = from_entry.file_id
 
740
            if file_id in to_paths:
 
741
                # already returned
 
742
                continue
 
743
            if not file_id in self.target.inventory:
 
744
                # common case - paths we have not emitted are not present in
 
745
                # target.
 
746
                to_path = None
 
747
            else:
 
748
                to_path = get_to_path(self.target.inventory[file_id])
 
749
            entry_count += 1
 
750
            if pb is not None:
 
751
                pb.update('comparing files', entry_count, num_entries)
 
752
            versioned = (True, False)
 
753
            parent = (from_entry.parent_id, None)
 
754
            name = (from_entry.name, None)
 
755
            from_kind, from_executable, stat_value = \
 
756
                self.source._comparison_data(from_entry, path)
 
757
            kind = (from_kind, None)
 
758
            executable = (from_executable, None)
 
759
            changed_content = True
 
760
            # the parent's path is necessarily known at this point.
 
761
            yield(file_id, (path, to_path), changed_content, versioned, parent,
 
762
                  name, kind, executable)
 
763
 
 
764
 
 
765
# This was deprecated before 0.12, but did not have an official warning
 
766
@symbol_versioning.deprecated_function(symbol_versioning.zero_twelve)
 
767
def RevisionTree(*args, **kwargs):
 
768
    """RevisionTree has moved to bzrlib.revisiontree.RevisionTree()
 
769
 
 
770
    Accessing it as bzrlib.tree.RevisionTree has been deprecated as of
 
771
    bzr 0.12.
 
772
    """
 
773
    from bzrlib.revisiontree import RevisionTree as _RevisionTree
 
774
    return _RevisionTree(*args, **kwargs)
 
775
 
 
776