← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

  • Committer: John Arbash Meinel
  • Date: 2009-10-12 21:44:27 UTC
  • mto: This revision was merged to the branch mainline in revision 4737.
  • Revision ID: john@arbash-meinel.com-20091012214427-zddi1kmc2jlf7v31
Py_ssize_t and its associated function typedefs are not available w/ python 2.4

So we define them in python-compat.h
Even further, gcc issued a warning for:
static int
_workaround_pyrex_096()
So we changed it to:
_workaround_pyrex_096(void)

Also, some python api funcs were incorrectly defined as 'char *' when they meant
'const char *'. Work around that with a (char *) cast, to avoid compiler warnings.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tree.py
1
 
# Copyright (C) 2005-2011 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
18
18
"""
19
19
 
20
20
import os
21
 
 
22
 
from bzrlib.lazy_import import lazy_import
23
 
lazy_import(globals(), """
24
 
import collections
25
 
 
 
21
from collections import deque
 
22
 
 
23
import bzrlib
26
24
from bzrlib import (
27
25
    conflicts as _mod_conflicts,
28
26
    debug,
29
27
    delta,
30
 
    errors,
31
28
    filters,
32
 
    inventory,
33
29
    osutils,
34
30
    revision as _mod_revision,
35
31
    rules,
36
 
    trace,
37
32
    )
38
 
""")
39
 
 
40
33
from bzrlib.decorators import needs_read_lock
 
34
from bzrlib.errors import BzrError, NoSuchId
 
35
from bzrlib import errors
 
36
from bzrlib.inventory import InventoryFile
41
37
from bzrlib.inter import InterObject
42
 
from bzrlib.symbol_versioning import (
43
 
    deprecated_in,
44
 
    deprecated_method,
45
 
    )
 
38
from bzrlib.osutils import fingerprint_file
 
39
import bzrlib.revision
 
40
from bzrlib.symbol_versioning import deprecated_function, deprecated_in
 
41
from bzrlib.trace import note
46
42
 
47
43
 
48
44
class Tree(object):
54
50
 
55
51
    * `RevisionTree` is a tree as recorded at some point in the past.
56
52
 
 
53
    Trees contain an `Inventory` object, and also know how to retrieve
 
54
    file texts mentioned in the inventory, either from a working
 
55
    directory or from a store.
 
56
 
 
57
    It is possible for trees to contain files that are not described
 
58
    in their inventory or vice versa; for this use `filenames()`.
 
59
 
57
60
    Trees can be compared, etc, regardless of whether they are working
58
61
    trees or versioned trees.
59
62
    """
95
98
    def iter_changes(self, from_tree, include_unchanged=False,
96
99
                     specific_files=None, pb=None, extra_trees=None,
97
100
                     require_versioned=True, want_unversioned=False):
98
 
        """See InterTree.iter_changes"""
99
101
        intertree = InterTree.get(from_tree, self)
100
102
        return intertree.iter_changes(include_unchanged, specific_files, pb,
101
103
            extra_trees, require_versioned, want_unversioned=want_unversioned)
125
127
        raise NotImplementedError(self.has_filename)
126
128
 
127
129
    def has_id(self, file_id):
128
 
        raise NotImplementedError(self.has_id)
 
130
        return self.inventory.has_id(file_id)
129
131
 
130
 
    @deprecated_method(deprecated_in((2, 4, 0)))
131
132
    def __contains__(self, file_id):
132
133
        return self.has_id(file_id)
133
134
 
134
135
    def has_or_had_id(self, file_id):
135
 
        raise NotImplementedError(self.has_or_had_id)
 
136
        return self.inventory.has_id(file_id)
136
137
 
137
138
    def is_ignored(self, filename):
138
139
        """Check whether the filename is ignored by this tree.
142
143
        """
143
144
        return False
144
145
 
 
146
    def __iter__(self):
 
147
        return iter(self.inventory)
 
148
 
145
149
    def all_file_ids(self):
146
150
        """Iterate through all file ids, including ids for missing files."""
147
 
        raise NotImplementedError(self.all_file_ids)
 
151
        return set(self.inventory)
148
152
 
149
153
    def id2path(self, file_id):
150
154
        """Return the path for a file id.
151
155
 
152
156
        :raises NoSuchId:
153
157
        """
154
 
        raise NotImplementedError(self.id2path)
155
 
 
 
158
        return self.inventory.id2path(file_id)
 
159
 
 
160
    def is_control_filename(self, filename):
 
161
        """True if filename is the name of a control file in this tree.
 
162
 
 
163
        :param filename: A filename within the tree. This is a relative path
 
164
        from the root of this tree.
 
165
 
 
166
        This is true IF and ONLY IF the filename is part of the meta data
 
167
        that bzr controls in this tree. I.E. a random .bzr directory placed
 
168
        on disk will not be a control file for this tree.
 
169
        """
 
170
        return self.bzrdir.is_control_filename(filename)
 
171
 
 
172
    @needs_read_lock
156
173
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
157
174
        """Walk the tree in 'by_dir' order.
158
175
 
175
192
             g
176
193
 
177
194
        The yield order (ignoring root) would be::
178
 
 
179
195
          a, f, a/b, a/d, a/b/c, a/d/e, f/g
180
196
 
181
197
        :param yield_parents: If True, yield the parents from the root leading
182
198
            down to specific_file_ids that have been requested. This has no
183
199
            impact if specific_file_ids is None.
184
200
        """
185
 
        raise NotImplementedError(self.iter_entries_by_dir)
186
 
 
187
 
    def list_files(self, include_root=False, from_dir=None, recursive=True):
188
 
        """List all files in this tree.
189
 
 
190
 
        :param include_root: Whether to include the entry for the tree root
191
 
        :param from_dir: Directory under which to list files
192
 
        :param recursive: Whether to list files recursively
193
 
        :return: iterator over tuples of (path, versioned, kind, file_id,
194
 
            inventory entry)
195
 
        """
196
 
        raise NotImplementedError(self.list_files)
 
201
        return self.inventory.iter_entries_by_dir(
 
202
            specific_file_ids=specific_file_ids, yield_parents=yield_parents)
197
203
 
198
204
    def iter_references(self):
199
205
        if self.supports_tree_reference():
250
256
    def _file_size(self, entry, stat_value):
251
257
        raise NotImplementedError(self._file_size)
252
258
 
 
259
    def _get_inventory(self):
 
260
        return self._inventory
 
261
 
253
262
    def get_file(self, file_id, path=None):
254
263
        """Return a file object for the file file_id in the tree.
255
264
 
291
300
 
292
301
        :param file_id: The file_id of the file.
293
302
        :param path: The path of the file.
294
 
 
295
303
        If both file_id and path are supplied, an implementation may use
296
304
        either one.
297
305
        """
298
306
        return osutils.split_lines(self.get_file_text(file_id, path))
299
307
 
300
 
    def get_file_sha1(self, file_id, path=None, stat_value=None):
301
 
        """Return the SHA1 file for a file.
302
 
 
303
 
        :param file_id: The handle for this file.
304
 
        :param path: The path that this file can be found at.
305
 
            These must point to the same object.
306
 
        :param stat_value: Optional stat value for the object
307
 
        """
308
 
        raise NotImplementedError(self.get_file_sha1)
309
 
 
310
308
    def get_file_mtime(self, file_id, path=None):
311
309
        """Return the modification time for a file.
312
310
 
326
324
        raise NotImplementedError(self.get_file_size)
327
325
 
328
326
    def get_file_by_path(self, path):
329
 
        raise NotImplementedError(self.get_file_by_path)
330
 
 
331
 
    def is_executable(self, file_id, path=None):
332
 
        """Check if a file is executable.
333
 
 
334
 
        :param file_id: The handle for this file.
335
 
        :param path: The path that this file can be found at.
336
 
            These must point to the same object.
337
 
        """
338
 
        raise NotImplementedError(self.is_executable)
 
327
        return self.get_file(self._inventory.path2id(path), path)
339
328
 
340
329
    def iter_files_bytes(self, desired_files):
341
330
        """Iterate through file contents.
363
352
            cur_file = (self.get_file_text(file_id),)
364
353
            yield identifier, cur_file
365
354
 
366
 
    def get_symlink_target(self, file_id, path=None):
 
355
    def get_symlink_target(self, file_id):
367
356
        """Get the target for a given file_id.
368
357
 
369
358
        It is assumed that the caller already knows that file_id is referencing
370
359
        a symlink.
371
360
        :param file_id: Handle for the symlink entry.
372
 
        :param path: The path of the file.
373
 
        If both file_id and path are supplied, an implementation may use
374
 
        either one.
375
361
        :return: The path the symlink points to.
376
362
        """
377
363
        raise NotImplementedError(self.get_symlink_target)
378
364
 
 
365
    def get_canonical_inventory_paths(self, paths):
 
366
        """Like get_canonical_inventory_path() but works on multiple items.
 
367
 
 
368
        :param paths: A sequence of paths relative to the root of the tree.
 
369
        :return: A list of paths, with each item the corresponding input path
 
370
        adjusted to account for existing elements that match case
 
371
        insensitively.
 
372
        """
 
373
        return list(self._yield_canonical_inventory_paths(paths))
 
374
 
 
375
    def get_canonical_inventory_path(self, path):
 
376
        """Returns the first inventory item that case-insensitively matches path.
 
377
 
 
378
        If a path matches exactly, it is returned. If no path matches exactly
 
379
        but more than one path matches case-insensitively, it is implementation
 
380
        defined which is returned.
 
381
 
 
382
        If no path matches case-insensitively, the input path is returned, but
 
383
        with as many path entries that do exist changed to their canonical
 
384
        form.
 
385
 
 
386
        If you need to resolve many names from the same tree, you should
 
387
        use get_canonical_inventory_paths() to avoid O(N) behaviour.
 
388
 
 
389
        :param path: A paths relative to the root of the tree.
 
390
        :return: The input path adjusted to account for existing elements
 
391
        that match case insensitively.
 
392
        """
 
393
        return self._yield_canonical_inventory_paths([path]).next()
 
394
 
 
395
    def _yield_canonical_inventory_paths(self, paths):
 
396
        for path in paths:
 
397
            # First, if the path as specified exists exactly, just use it.
 
398
            if self.path2id(path) is not None:
 
399
                yield path
 
400
                continue
 
401
            # go walkin...
 
402
            cur_id = self.get_root_id()
 
403
            cur_path = ''
 
404
            bit_iter = iter(path.split("/"))
 
405
            for elt in bit_iter:
 
406
                lelt = elt.lower()
 
407
                for child in self.iter_children(cur_id):
 
408
                    try:
 
409
                        child_base = os.path.basename(self.id2path(child))
 
410
                        if child_base.lower() == lelt:
 
411
                            cur_id = child
 
412
                            cur_path = osutils.pathjoin(cur_path, child_base)
 
413
                            break
 
414
                    except NoSuchId:
 
415
                        # before a change is committed we can see this error...
 
416
                        continue
 
417
                else:
 
418
                    # got to the end of this directory and no entries matched.
 
419
                    # Return what matched so far, plus the rest as specified.
 
420
                    cur_path = osutils.pathjoin(cur_path, elt, *list(bit_iter))
 
421
                    break
 
422
            yield cur_path
 
423
        # all done.
 
424
 
379
425
    def get_root_id(self):
380
426
        """Return the file_id for the root of this tree."""
381
427
        raise NotImplementedError(self.get_root_id)
439
485
            except errors.NoSuchRevisionInTree:
440
486
                yield self.repository.revision_tree(revision_id)
441
487
 
 
488
    @staticmethod
 
489
    def _file_revision(revision_tree, file_id):
 
490
        """Determine the revision associated with a file in a given tree."""
 
491
        revision_tree.lock_read()
 
492
        try:
 
493
            return revision_tree.inventory[file_id].revision
 
494
        finally:
 
495
            revision_tree.unlock()
 
496
 
442
497
    def _get_file_revision(self, file_id, vf, tree_revision):
443
498
        """Ensure that file_id, tree_revision is in vf to plan the merge."""
444
499
 
445
500
        if getattr(self, '_repository', None) is None:
446
501
            last_revision = tree_revision
447
 
            parent_keys = [(file_id, t.get_file_revision(file_id)) for t in
 
502
            parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
448
503
                self._iter_parent_trees()]
449
504
            vf.add_lines((file_id, last_revision), parent_keys,
450
 
                         self.get_file_lines(file_id))
 
505
                         self.get_file(file_id).readlines())
451
506
            repo = self.branch.repository
452
507
            base_vf = repo.texts
453
508
        else:
454
 
            last_revision = self.get_file_revision(file_id)
 
509
            last_revision = self._file_revision(self, file_id)
455
510
            base_vf = self._repository.texts
456
511
        if base_vf not in vf.fallback_versionedfiles:
457
512
            vf.fallback_versionedfiles.append(base_vf)
458
513
        return last_revision
459
514
 
 
515
    inventory = property(_get_inventory,
 
516
                         doc="Inventory of this Tree")
 
517
 
460
518
    def _check_retrieved(self, ie, f):
461
519
        if not __debug__:
462
520
            return
463
 
        fp = osutils.fingerprint_file(f)
 
521
        fp = fingerprint_file(f)
464
522
        f.seek(0)
465
523
 
466
524
        if ie.text_size is not None:
467
525
            if ie.text_size != fp['size']:
468
 
                raise errors.BzrError(
469
 
                        "mismatched size for file %r in %r" %
470
 
                        (ie.file_id, self._store),
 
526
                raise BzrError("mismatched size for file %r in %r" % (ie.file_id, self._store),
471
527
                        ["inventory expects %d bytes" % ie.text_size,
472
528
                         "file is actually %d bytes" % fp['size'],
473
529
                         "store is probably damaged/corrupt"])
474
530
 
475
531
        if ie.text_sha1 != fp['sha1']:
476
 
            raise errors.BzrError("wrong SHA-1 for file %r in %r" %
477
 
                    (ie.file_id, self._store),
 
532
            raise BzrError("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
478
533
                    ["inventory expects %s" % ie.text_sha1,
479
534
                     "file is actually %s" % fp['sha1'],
480
535
                     "store is probably damaged/corrupt"])
481
536
 
 
537
    @needs_read_lock
482
538
    def path2id(self, path):
483
539
        """Return the id for path in this tree."""
484
 
        raise NotImplementedError(self.path2id)
 
540
        return self._inventory.path2id(path)
485
541
 
486
542
    def paths2ids(self, paths, trees=[], require_versioned=True):
487
543
        """Return all the ids that can be reached by walking from paths.
508
564
            yield child.file_id
509
565
 
510
566
    def lock_read(self):
511
 
        """Lock this tree for multiple read only operations.
512
 
        
513
 
        :return: A bzrlib.lock.LogicalLockResult.
514
 
        """
515
567
        pass
516
568
 
517
569
    def revision_tree(self, revision_id):
544
596
 
545
597
        :return: set of paths.
546
598
        """
547
 
        raise NotImplementedError(self.filter_unversioned_files)
 
599
        # NB: we specifically *don't* call self.has_filename, because for
 
600
        # WorkingTrees that can indicate files that exist on disk but that
 
601
        # are not versioned.
 
602
        pred = self.inventory.has_filename
 
603
        return set((p for p in paths if not pred(p)))
548
604
 
549
605
    def walkdirs(self, prefix=""):
550
606
        """Walk the contents of this tree from path down.
602
658
        prefs = self.iter_search_rules([path], filter_pref_names).next()
603
659
        stk = filters._get_filter_stack_for(prefs)
604
660
        if 'filters' in debug.debug_flags:
605
 
            trace.note("*** %s content-filter: %s => %r" % (path,prefs,stk))
 
661
            note("*** %s content-filter: %s => %r" % (path,prefs,stk))
606
662
        return stk
607
663
 
608
664
    def _content_filter_stack_provider(self):
641
697
                for path in path_names:
642
698
                    yield searcher.get_items(path)
643
699
 
 
700
    @needs_read_lock
644
701
    def _get_rules_searcher(self, default_searcher):
645
702
        """Get the RulesSearcher for this tree given the default one."""
646
703
        searcher = default_searcher
647
704
        return searcher
648
705
 
649
706
 
650
 
class InventoryTree(Tree):
651
 
    """A tree that relies on an inventory for its metadata.
652
 
 
653
 
    Trees contain an `Inventory` object, and also know how to retrieve
654
 
    file texts mentioned in the inventory, either from a working
655
 
    directory or from a store.
656
 
 
657
 
    It is possible for trees to contain files that are not described
658
 
    in their inventory or vice versa; for this use `filenames()`.
659
 
 
660
 
    Subclasses should set the _inventory attribute, which is considered
661
 
    private to external API users.
 
707
######################################################################
 
708
# diff
 
709
 
 
710
# TODO: Merge these two functions into a single one that can operate
 
711
# on either a whole tree or a set of files.
 
712
 
 
713
# TODO: Return the diff in order by filename, not by category or in
 
714
# random order.  Can probably be done by lock-stepping through the
 
715
# filenames from both trees.
 
716
 
 
717
 
 
718
def file_status(filename, old_tree, new_tree):
 
719
    """Return single-letter status, old and new names for a file.
 
720
 
 
721
    The complexity here is in deciding how to represent renames;
 
722
    many complex cases are possible.
662
723
    """
663
 
 
664
 
    def get_canonical_inventory_paths(self, paths):
665
 
        """Like get_canonical_inventory_path() but works on multiple items.
666
 
 
667
 
        :param paths: A sequence of paths relative to the root of the tree.
668
 
        :return: A list of paths, with each item the corresponding input path
669
 
        adjusted to account for existing elements that match case
670
 
        insensitively.
671
 
        """
672
 
        return list(self._yield_canonical_inventory_paths(paths))
673
 
 
674
 
    def get_canonical_inventory_path(self, path):
675
 
        """Returns the first inventory item that case-insensitively matches path.
676
 
 
677
 
        If a path matches exactly, it is returned. If no path matches exactly
678
 
        but more than one path matches case-insensitively, it is implementation
679
 
        defined which is returned.
680
 
 
681
 
        If no path matches case-insensitively, the input path is returned, but
682
 
        with as many path entries that do exist changed to their canonical
683
 
        form.
684
 
 
685
 
        If you need to resolve many names from the same tree, you should
686
 
        use get_canonical_inventory_paths() to avoid O(N) behaviour.
687
 
 
688
 
        :param path: A paths relative to the root of the tree.
689
 
        :return: The input path adjusted to account for existing elements
690
 
        that match case insensitively.
691
 
        """
692
 
        return self._yield_canonical_inventory_paths([path]).next()
693
 
 
694
 
    def _yield_canonical_inventory_paths(self, paths):
695
 
        for path in paths:
696
 
            # First, if the path as specified exists exactly, just use it.
697
 
            if self.path2id(path) is not None:
698
 
                yield path
699
 
                continue
700
 
            # go walkin...
701
 
            cur_id = self.get_root_id()
702
 
            cur_path = ''
703
 
            bit_iter = iter(path.split("/"))
704
 
            for elt in bit_iter:
705
 
                lelt = elt.lower()
706
 
                new_path = None
707
 
                for child in self.iter_children(cur_id):
708
 
                    try:
709
 
                        # XXX: it seem like if the child is known to be in the
710
 
                        # tree, we shouldn't need to go from its id back to
711
 
                        # its path -- mbp 2010-02-11
712
 
                        #
713
 
                        # XXX: it seems like we could be more efficient
714
 
                        # by just directly looking up the original name and
715
 
                        # only then searching all children; also by not
716
 
                        # chopping paths so much. -- mbp 2010-02-11
717
 
                        child_base = os.path.basename(self.id2path(child))
718
 
                        if (child_base == elt):
719
 
                            # if we found an exact match, we can stop now; if
720
 
                            # we found an approximate match we need to keep
721
 
                            # searching because there might be an exact match
722
 
                            # later.  
723
 
                            cur_id = child
724
 
                            new_path = osutils.pathjoin(cur_path, child_base)
725
 
                            break
726
 
                        elif child_base.lower() == lelt:
727
 
                            cur_id = child
728
 
                            new_path = osutils.pathjoin(cur_path, child_base)
729
 
                    except errors.NoSuchId:
730
 
                        # before a change is committed we can see this error...
731
 
                        continue
732
 
                if new_path:
733
 
                    cur_path = new_path
734
 
                else:
735
 
                    # got to the end of this directory and no entries matched.
736
 
                    # Return what matched so far, plus the rest as specified.
737
 
                    cur_path = osutils.pathjoin(cur_path, elt, *list(bit_iter))
738
 
                    break
739
 
            yield cur_path
740
 
        # all done.
741
 
 
742
 
    def _get_inventory(self):
743
 
        return self._inventory
744
 
 
745
 
    inventory = property(_get_inventory,
746
 
                         doc="Inventory of this Tree")
747
 
 
748
 
    @needs_read_lock
749
 
    def path2id(self, path):
750
 
        """Return the id for path in this tree."""
751
 
        return self._inventory.path2id(path)
752
 
 
753
 
    def id2path(self, file_id):
754
 
        """Return the path for a file id.
755
 
 
756
 
        :raises NoSuchId:
757
 
        """
758
 
        return self.inventory.id2path(file_id)
759
 
 
760
 
    def has_id(self, file_id):
761
 
        return self.inventory.has_id(file_id)
762
 
 
763
 
    def has_or_had_id(self, file_id):
764
 
        return self.inventory.has_id(file_id)
765
 
 
766
 
    def all_file_ids(self):
767
 
        return set(self.inventory)
768
 
 
769
 
    @deprecated_method(deprecated_in((2, 4, 0)))
770
 
    def __iter__(self):
771
 
        return iter(self.inventory)
772
 
 
773
 
    def filter_unversioned_files(self, paths):
774
 
        """Filter out paths that are versioned.
775
 
 
776
 
        :return: set of paths.
777
 
        """
778
 
        # NB: we specifically *don't* call self.has_filename, because for
779
 
        # WorkingTrees that can indicate files that exist on disk but that
780
 
        # are not versioned.
781
 
        pred = self.inventory.has_filename
782
 
        return set((p for p in paths if not pred(p)))
783
 
 
784
 
    @needs_read_lock
785
 
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
786
 
        """Walk the tree in 'by_dir' order.
787
 
 
788
 
        This will yield each entry in the tree as a (path, entry) tuple.
789
 
        The order that they are yielded is:
790
 
 
791
 
        See Tree.iter_entries_by_dir for details.
792
 
 
793
 
        :param yield_parents: If True, yield the parents from the root leading
794
 
            down to specific_file_ids that have been requested. This has no
795
 
            impact if specific_file_ids is None.
796
 
        """
797
 
        return self.inventory.iter_entries_by_dir(
798
 
            specific_file_ids=specific_file_ids, yield_parents=yield_parents)
799
 
 
800
 
    def get_file_by_path(self, path):
801
 
        return self.get_file(self._inventory.path2id(path), path)
 
724
    old_inv = old_tree.inventory
 
725
    new_inv = new_tree.inventory
 
726
    new_id = new_inv.path2id(filename)
 
727
    old_id = old_inv.path2id(filename)
 
728
 
 
729
    if not new_id and not old_id:
 
730
        # easy: doesn't exist in either; not versioned at all
 
731
        if new_tree.is_ignored(filename):
 
732
            return 'I', None, None
 
733
        else:
 
734
            return '?', None, None
 
735
    elif new_id:
 
736
        # There is now a file of this name, great.
 
737
        pass
 
738
    else:
 
739
        # There is no longer a file of this name, but we can describe
 
740
        # what happened to the file that used to have
 
741
        # this name.  There are two possibilities: either it was
 
742
        # deleted entirely, or renamed.
 
743
        if new_inv.has_id(old_id):
 
744
            return 'X', old_inv.id2path(old_id), new_inv.id2path(old_id)
 
745
        else:
 
746
            return 'D', old_inv.id2path(old_id), None
 
747
 
 
748
    # if the file_id is new in this revision, it is added
 
749
    if new_id and not old_inv.has_id(new_id):
 
750
        return 'A'
 
751
 
 
752
    # if there used to be a file of this name, but that ID has now
 
753
    # disappeared, it is deleted
 
754
    if old_id and not new_inv.has_id(old_id):
 
755
        return 'D'
 
756
 
 
757
    return 'wtf?'
 
758
 
 
759
 
 
760
@deprecated_function(deprecated_in((1, 9, 0)))
 
761
def find_renames(old_inv, new_inv):
 
762
    for file_id in old_inv:
 
763
        if file_id not in new_inv:
 
764
            continue
 
765
        old_name = old_inv.id2path(file_id)
 
766
        new_name = new_inv.id2path(file_id)
 
767
        if old_name != new_name:
 
768
            yield (old_name, new_name)
802
769
 
803
770
 
804
771
def find_ids_across_trees(filenames, trees, require_versioned=True):
811
778
        None)
812
779
    :param trees: The trees to find file_ids within
813
780
    :param require_versioned: if true, all specified filenames must occur in
814
 
        at least one tree.
 
781
    at least one tree.
815
782
    :return: a set of file ids for the specified filenames and their children.
816
783
    """
817
784
    if not filenames:
885
852
    will pass through to InterTree as appropriate.
886
853
    """
887
854
 
888
 
    # Formats that will be used to test this InterTree. If both are
889
 
    # None, this InterTree will not be tested (e.g. because a complex
890
 
    # setup is required)
891
 
    _matching_from_tree_format = None
892
 
    _matching_to_tree_format = None
893
 
 
894
855
    _optimisers = []
895
856
 
896
 
    @classmethod
897
 
    def is_compatible(kls, source, target):
898
 
        # The default implementation is naive and uses the public API, so
899
 
        # it works for all trees.
900
 
        return True
901
 
 
902
857
    def _changes_from_entries(self, source_entry, target_entry,
903
858
        source_path=None, target_path=None):
904
859
        """Generate a iter_changes tuple between source_entry and target_entry.
999
954
            a PathsNotVersionedError will be thrown.
1000
955
        :param want_unversioned: Scan for unversioned paths.
1001
956
        """
 
957
        # NB: show_status depends on being able to pass in non-versioned files
 
958
        # and report them as unknown
1002
959
        trees = (self.source,)
1003
960
        if extra_trees is not None:
1004
961
            trees = trees + tuple(extra_trees)
1009
966
            # All files are unversioned, so just return an empty delta
1010
967
            # _compare_trees would think we want a complete delta
1011
968
            result = delta.TreeDelta()
1012
 
            fake_entry = inventory.InventoryFile('unused', 'unused', 'unused')
 
969
            fake_entry = InventoryFile('unused', 'unused', 'unused')
1013
970
            result.unversioned = [(path, None,
1014
971
                self.target._comparison_data(fake_entry, path)[0]) for path in
1015
972
                specific_files]
1080
1037
                                     self.target.extras()
1081
1038
                if specific_files is None or
1082
1039
                    osutils.is_inside_any(specific_files, p)])
1083
 
            all_unversioned = collections.deque(all_unversioned)
 
1040
            all_unversioned = deque(all_unversioned)
1084
1041
        else:
1085
 
            all_unversioned = collections.deque()
 
1042
            all_unversioned = deque()
1086
1043
        to_paths = {}
1087
1044
        from_entries_by_dir = list(self.source.iter_entries_by_dir(
1088
1045
            specific_file_ids=specific_file_ids))
1094
1051
        # the unversioned path lookup only occurs on real trees - where there
1095
1052
        # can be extras. So the fake_entry is solely used to look up
1096
1053
        # executable it values when execute is not supported.
1097
 
        fake_entry = inventory.InventoryFile('unused', 'unused', 'unused')
 
1054
        fake_entry = InventoryFile('unused', 'unused', 'unused')
1098
1055
        for target_path, target_entry in to_entries_by_dir:
1099
1056
            while (all_unversioned and
1100
1057
                all_unversioned[0][0] < target_path.split('/')):
1148
1105
            if file_id in to_paths:
1149
1106
                # already returned
1150
1107
                continue
1151
 
            if not self.target.has_id(file_id):
 
1108
            if file_id not in self.target.all_file_ids():
1152
1109
                # common case - paths we have not emitted are not present in
1153
1110
                # target.
1154
1111
                to_path = None
1273
1230
                    yield result
1274
1231
 
1275
1232
 
1276
 
InterTree.register_optimiser(InterTree)
1277
 
 
1278
 
 
1279
1233
class MultiWalker(object):
1280
1234
    """Walk multiple trees simultaneously, getting combined results."""
1281
1235