~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

  • Committer: Patch Queue Manager
  • Date: 2016-02-01 19:56:05 UTC
  • mfrom: (6615.1.1 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20160201195605-o7rl92wf6uyum3fk
(vila) Open trunk again as 2.8b1 (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2009 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
17
17
"""Tree classes, representing directory at point in time.
18
18
"""
19
19
 
 
20
from __future__ import absolute_import
 
21
 
20
22
import os
21
 
from collections import deque
22
 
 
23
 
import bzrlib
 
23
 
 
24
from bzrlib.lazy_import import lazy_import
 
25
lazy_import(globals(), """
 
26
import collections
 
27
 
24
28
from bzrlib import (
25
29
    conflicts as _mod_conflicts,
26
30
    debug,
27
31
    delta,
 
32
    errors,
28
33
    filters,
 
34
    inventory,
29
35
    osutils,
30
36
    revision as _mod_revision,
31
37
    rules,
 
38
    trace,
32
39
    )
 
40
from bzrlib.i18n import gettext
 
41
""")
 
42
 
33
43
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
37
44
from bzrlib.inter import InterObject
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
 
45
from bzrlib.symbol_versioning import (
 
46
    deprecated_in,
 
47
    deprecated_method,
 
48
    )
42
49
 
43
50
 
44
51
class Tree(object):
50
57
 
51
58
    * `RevisionTree` is a tree as recorded at some point in the past.
52
59
 
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
 
 
60
60
    Trees can be compared, etc, regardless of whether they are working
61
61
    trees or versioned trees.
62
62
    """
63
63
 
 
64
    def has_versioned_directories(self):
 
65
        """Whether this tree can contain explicitly versioned directories.
 
66
 
 
67
        This defaults to True, but some implementations may want to override
 
68
        it.
 
69
        """
 
70
        return True
 
71
 
64
72
    def changes_from(self, other, want_unchanged=False, specific_files=None,
65
73
        extra_trees=None, require_versioned=False, include_root=False,
66
74
        want_unversioned=False):
98
106
    def iter_changes(self, from_tree, include_unchanged=False,
99
107
                     specific_files=None, pb=None, extra_trees=None,
100
108
                     require_versioned=True, want_unversioned=False):
 
109
        """See InterTree.iter_changes"""
101
110
        intertree = InterTree.get(from_tree, self)
102
111
        return intertree.iter_changes(include_unchanged, specific_files, pb,
103
112
            extra_trees, require_versioned, want_unversioned=want_unversioned)
127
136
        raise NotImplementedError(self.has_filename)
128
137
 
129
138
    def has_id(self, file_id):
130
 
        return self.inventory.has_id(file_id)
 
139
        raise NotImplementedError(self.has_id)
131
140
 
 
141
    @deprecated_method(deprecated_in((2, 4, 0)))
132
142
    def __contains__(self, file_id):
133
143
        return self.has_id(file_id)
134
144
 
135
145
    def has_or_had_id(self, file_id):
136
 
        return self.inventory.has_id(file_id)
 
146
        raise NotImplementedError(self.has_or_had_id)
137
147
 
138
148
    def is_ignored(self, filename):
139
149
        """Check whether the filename is ignored by this tree.
143
153
        """
144
154
        return False
145
155
 
146
 
    def __iter__(self):
147
 
        return iter(self.inventory)
148
 
 
149
156
    def all_file_ids(self):
150
157
        """Iterate through all file ids, including ids for missing files."""
151
 
        return set(self.inventory)
 
158
        raise NotImplementedError(self.all_file_ids)
152
159
 
153
160
    def id2path(self, file_id):
154
161
        """Return the path for a file id.
155
162
 
156
163
        :raises NoSuchId:
157
164
        """
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
 
165
        raise NotImplementedError(self.id2path)
 
166
 
173
167
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
174
168
        """Walk the tree in 'by_dir' order.
175
169
 
192
186
             g
193
187
 
194
188
        The yield order (ignoring root) would be::
 
189
 
195
190
          a, f, a/b, a/d, a/b/c, a/d/e, f/g
196
191
 
197
192
        :param yield_parents: If True, yield the parents from the root leading
198
193
            down to specific_file_ids that have been requested. This has no
199
194
            impact if specific_file_ids is None.
200
195
        """
201
 
        return self.inventory.iter_entries_by_dir(
202
 
            specific_file_ids=specific_file_ids, yield_parents=yield_parents)
 
196
        raise NotImplementedError(self.iter_entries_by_dir)
 
197
 
 
198
    def iter_child_entries(self, file_id, path=None):
 
199
        """Iterate over the children of a directory or tree reference.
 
200
 
 
201
        :param file_id: File id of the directory/tree-reference
 
202
        :param path: Optional path of the directory
 
203
        :raise NoSuchId: When the file_id does not exist
 
204
        :return: Iterator over entries in the directory
 
205
        """
 
206
        raise NotImplementedError(self.iter_child_entries)
 
207
 
 
208
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
209
        """List all files in this tree.
 
210
 
 
211
        :param include_root: Whether to include the entry for the tree root
 
212
        :param from_dir: Directory under which to list files
 
213
        :param recursive: Whether to list files recursively
 
214
        :return: iterator over tuples of (path, versioned, kind, file_id,
 
215
            inventory entry)
 
216
        """
 
217
        raise NotImplementedError(self.list_files)
203
218
 
204
219
    def iter_references(self):
205
220
        if self.supports_tree_reference():
256
271
    def _file_size(self, entry, stat_value):
257
272
        raise NotImplementedError(self._file_size)
258
273
 
259
 
    def _get_inventory(self):
260
 
        return self._inventory
261
 
 
262
274
    def get_file(self, file_id, path=None):
263
275
        """Return a file object for the file file_id in the tree.
264
276
 
286
298
 
287
299
        :param file_id: The file_id of the file.
288
300
        :param path: The path of the file.
 
301
 
289
302
        If both file_id and path are supplied, an implementation may use
290
303
        either one.
 
304
 
 
305
        :returns: A single byte string for the whole file.
291
306
        """
292
307
        my_file = self.get_file(file_id, path)
293
308
        try:
300
315
 
301
316
        :param file_id: The file_id of the file.
302
317
        :param path: The path of the file.
 
318
 
303
319
        If both file_id and path are supplied, an implementation may use
304
320
        either one.
305
321
        """
306
322
        return osutils.split_lines(self.get_file_text(file_id, path))
307
323
 
 
324
    def get_file_verifier(self, file_id, path=None, stat_value=None):
 
325
        """Return a verifier for a file.
 
326
 
 
327
        The default implementation returns a sha1.
 
328
 
 
329
        :param file_id: The handle for this file.
 
330
        :param path: The path that this file can be found at.
 
331
            These must point to the same object.
 
332
        :param stat_value: Optional stat value for the object
 
333
        :return: Tuple with verifier name and verifier data
 
334
        """
 
335
        return ("SHA1", self.get_file_sha1(file_id, path=path,
 
336
            stat_value=stat_value))
 
337
 
 
338
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
339
        """Return the SHA1 file for a file.
 
340
 
 
341
        :note: callers should use get_file_verifier instead
 
342
            where possible, as the underlying repository implementation may
 
343
            have quicker access to a non-sha1 verifier.
 
344
 
 
345
        :param file_id: The handle for this file.
 
346
        :param path: The path that this file can be found at.
 
347
            These must point to the same object.
 
348
        :param stat_value: Optional stat value for the object
 
349
        """
 
350
        raise NotImplementedError(self.get_file_sha1)
 
351
 
308
352
    def get_file_mtime(self, file_id, path=None):
309
353
        """Return the modification time for a file.
310
354
 
323
367
        """
324
368
        raise NotImplementedError(self.get_file_size)
325
369
 
326
 
    def get_file_by_path(self, path):
327
 
        return self.get_file(self._inventory.path2id(path), path)
 
370
    def is_executable(self, file_id, path=None):
 
371
        """Check if a file is executable.
 
372
 
 
373
        :param file_id: The handle for this file.
 
374
        :param path: The path that this file can be found at.
 
375
            These must point to the same object.
 
376
        """
 
377
        raise NotImplementedError(self.is_executable)
328
378
 
329
379
    def iter_files_bytes(self, desired_files):
330
380
        """Iterate through file contents.
352
402
            cur_file = (self.get_file_text(file_id),)
353
403
            yield identifier, cur_file
354
404
 
355
 
    def get_symlink_target(self, file_id):
 
405
    def get_symlink_target(self, file_id, path=None):
356
406
        """Get the target for a given file_id.
357
407
 
358
408
        It is assumed that the caller already knows that file_id is referencing
359
409
        a symlink.
360
410
        :param file_id: Handle for the symlink entry.
 
411
        :param path: The path of the file.
 
412
        If both file_id and path are supplied, an implementation may use
 
413
        either one.
361
414
        :return: The path the symlink points to.
362
415
        """
363
416
        raise NotImplementedError(self.get_symlink_target)
364
417
 
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
 
 
425
418
    def get_root_id(self):
426
419
        """Return the file_id for the root of this tree."""
427
420
        raise NotImplementedError(self.get_root_id)
485
478
            except errors.NoSuchRevisionInTree:
486
479
                yield self.repository.revision_tree(revision_id)
487
480
 
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
 
 
497
481
    def _get_file_revision(self, file_id, vf, tree_revision):
498
482
        """Ensure that file_id, tree_revision is in vf to plan the merge."""
499
483
 
500
484
        if getattr(self, '_repository', None) is None:
501
485
            last_revision = tree_revision
502
 
            parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
 
486
            parent_keys = [(file_id, t.get_file_revision(file_id)) for t in
503
487
                self._iter_parent_trees()]
504
488
            vf.add_lines((file_id, last_revision), parent_keys,
505
 
                         self.get_file(file_id).readlines())
 
489
                         self.get_file_lines(file_id))
506
490
            repo = self.branch.repository
507
491
            base_vf = repo.texts
508
492
        else:
509
 
            last_revision = self._file_revision(self, file_id)
 
493
            last_revision = self.get_file_revision(file_id)
510
494
            base_vf = self._repository.texts
511
495
        if base_vf not in vf.fallback_versionedfiles:
512
496
            vf.fallback_versionedfiles.append(base_vf)
513
497
        return last_revision
514
498
 
515
 
    inventory = property(_get_inventory,
516
 
                         doc="Inventory of this Tree")
517
 
 
518
499
    def _check_retrieved(self, ie, f):
519
500
        if not __debug__:
520
501
            return
521
 
        fp = fingerprint_file(f)
 
502
        fp = osutils.fingerprint_file(f)
522
503
        f.seek(0)
523
504
 
524
505
        if ie.text_size is not None:
525
506
            if ie.text_size != fp['size']:
526
 
                raise BzrError("mismatched size for file %r in %r" % (ie.file_id, self._store),
 
507
                raise errors.BzrError(
 
508
                        "mismatched size for file %r in %r" %
 
509
                        (ie.file_id, self._store),
527
510
                        ["inventory expects %d bytes" % ie.text_size,
528
511
                         "file is actually %d bytes" % fp['size'],
529
512
                         "store is probably damaged/corrupt"])
530
513
 
531
514
        if ie.text_sha1 != fp['sha1']:
532
 
            raise BzrError("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
 
515
            raise errors.BzrError("wrong SHA-1 for file %r in %r" %
 
516
                    (ie.file_id, self._store),
533
517
                    ["inventory expects %s" % ie.text_sha1,
534
518
                     "file is actually %s" % fp['sha1'],
535
519
                     "store is probably damaged/corrupt"])
536
520
 
537
 
    @needs_read_lock
538
521
    def path2id(self, path):
539
522
        """Return the id for path in this tree."""
540
 
        return self._inventory.path2id(path)
 
523
        raise NotImplementedError(self.path2id)
541
524
 
542
525
    def paths2ids(self, paths, trees=[], require_versioned=True):
543
526
        """Return all the ids that can be reached by walking from paths.
559
542
        return find_ids_across_trees(paths, [self] + list(trees), require_versioned)
560
543
 
561
544
    def iter_children(self, file_id):
562
 
        entry = self.iter_entries_by_dir([file_id]).next()[1]
563
 
        for child in getattr(entry, 'children', {}).itervalues():
564
 
            yield child.file_id
 
545
        """Iterate over the file ids of the children of an entry.
 
546
 
 
547
        :param file_id: File id of the entry
 
548
        :return: Iterator over child file ids.
 
549
        """
 
550
        raise NotImplementedError(self.iter_children)
565
551
 
566
552
    def lock_read(self):
 
553
        """Lock this tree for multiple read only operations.
 
554
 
 
555
        :return: A bzrlib.lock.LogicalLockResult.
 
556
        """
567
557
        pass
568
558
 
569
559
    def revision_tree(self, revision_id):
596
586
 
597
587
        :return: set of paths.
598
588
        """
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)))
 
589
        raise NotImplementedError(self.filter_unversioned_files)
604
590
 
605
591
    def walkdirs(self, prefix=""):
606
592
        """Walk the contents of this tree from path down.
658
644
        prefs = self.iter_search_rules([path], filter_pref_names).next()
659
645
        stk = filters._get_filter_stack_for(prefs)
660
646
        if 'filters' in debug.debug_flags:
661
 
            note("*** %s content-filter: %s => %r" % (path,prefs,stk))
 
647
            trace.note(gettext("*** {0} content-filter: {1} => {2!r}").format(path,prefs,stk))
662
648
        return stk
663
649
 
664
650
    def _content_filter_stack_provider(self):
703
689
        return searcher
704
690
 
705
691
 
706
 
######################################################################
707
 
# diff
708
 
 
709
 
# TODO: Merge these two functions into a single one that can operate
710
 
# on either a whole tree or a set of files.
711
 
 
712
 
# TODO: Return the diff in order by filename, not by category or in
713
 
# random order.  Can probably be done by lock-stepping through the
714
 
# filenames from both trees.
715
 
 
716
 
 
717
 
def file_status(filename, old_tree, new_tree):
718
 
    """Return single-letter status, old and new names for a file.
719
 
 
720
 
    The complexity here is in deciding how to represent renames;
721
 
    many complex cases are possible.
 
692
class InventoryTree(Tree):
 
693
    """A tree that relies on an inventory for its metadata.
 
694
 
 
695
    Trees contain an `Inventory` object, and also know how to retrieve
 
696
    file texts mentioned in the inventory, either from a working
 
697
    directory or from a store.
 
698
 
 
699
    It is possible for trees to contain files that are not described
 
700
    in their inventory or vice versa; for this use `filenames()`.
 
701
 
 
702
    Subclasses should set the _inventory attribute, which is considered
 
703
    private to external API users.
722
704
    """
723
 
    old_inv = old_tree.inventory
724
 
    new_inv = new_tree.inventory
725
 
    new_id = new_inv.path2id(filename)
726
 
    old_id = old_inv.path2id(filename)
727
 
 
728
 
    if not new_id and not old_id:
729
 
        # easy: doesn't exist in either; not versioned at all
730
 
        if new_tree.is_ignored(filename):
731
 
            return 'I', None, None
732
 
        else:
733
 
            return '?', None, None
734
 
    elif new_id:
735
 
        # There is now a file of this name, great.
736
 
        pass
737
 
    else:
738
 
        # There is no longer a file of this name, but we can describe
739
 
        # what happened to the file that used to have
740
 
        # this name.  There are two possibilities: either it was
741
 
        # deleted entirely, or renamed.
742
 
        if new_inv.has_id(old_id):
743
 
            return 'X', old_inv.id2path(old_id), new_inv.id2path(old_id)
744
 
        else:
745
 
            return 'D', old_inv.id2path(old_id), None
746
 
 
747
 
    # if the file_id is new in this revision, it is added
748
 
    if new_id and not old_inv.has_id(new_id):
749
 
        return 'A'
750
 
 
751
 
    # if there used to be a file of this name, but that ID has now
752
 
    # disappeared, it is deleted
753
 
    if old_id and not new_inv.has_id(old_id):
754
 
        return 'D'
755
 
 
756
 
    return 'wtf?'
757
 
 
758
 
 
759
 
@deprecated_function(deprecated_in((1, 9, 0)))
760
 
def find_renames(old_inv, new_inv):
761
 
    for file_id in old_inv:
762
 
        if file_id not in new_inv:
763
 
            continue
764
 
        old_name = old_inv.id2path(file_id)
765
 
        new_name = new_inv.id2path(file_id)
766
 
        if old_name != new_name:
767
 
            yield (old_name, new_name)
 
705
 
 
706
    def get_canonical_inventory_paths(self, paths):
 
707
        """Like get_canonical_inventory_path() but works on multiple items.
 
708
 
 
709
        :param paths: A sequence of paths relative to the root of the tree.
 
710
        :return: A list of paths, with each item the corresponding input path
 
711
        adjusted to account for existing elements that match case
 
712
        insensitively.
 
713
        """
 
714
        return list(self._yield_canonical_inventory_paths(paths))
 
715
 
 
716
    def get_canonical_inventory_path(self, path):
 
717
        """Returns the first inventory item that case-insensitively matches path.
 
718
 
 
719
        If a path matches exactly, it is returned. If no path matches exactly
 
720
        but more than one path matches case-insensitively, it is implementation
 
721
        defined which is returned.
 
722
 
 
723
        If no path matches case-insensitively, the input path is returned, but
 
724
        with as many path entries that do exist changed to their canonical
 
725
        form.
 
726
 
 
727
        If you need to resolve many names from the same tree, you should
 
728
        use get_canonical_inventory_paths() to avoid O(N) behaviour.
 
729
 
 
730
        :param path: A paths relative to the root of the tree.
 
731
        :return: The input path adjusted to account for existing elements
 
732
        that match case insensitively.
 
733
        """
 
734
        return self._yield_canonical_inventory_paths([path]).next()
 
735
 
 
736
    def _yield_canonical_inventory_paths(self, paths):
 
737
        for path in paths:
 
738
            # First, if the path as specified exists exactly, just use it.
 
739
            if self.path2id(path) is not None:
 
740
                yield path
 
741
                continue
 
742
            # go walkin...
 
743
            cur_id = self.get_root_id()
 
744
            cur_path = ''
 
745
            bit_iter = iter(path.split("/"))
 
746
            for elt in bit_iter:
 
747
                lelt = elt.lower()
 
748
                new_path = None
 
749
                for child in self.iter_children(cur_id):
 
750
                    try:
 
751
                        # XXX: it seem like if the child is known to be in the
 
752
                        # tree, we shouldn't need to go from its id back to
 
753
                        # its path -- mbp 2010-02-11
 
754
                        #
 
755
                        # XXX: it seems like we could be more efficient
 
756
                        # by just directly looking up the original name and
 
757
                        # only then searching all children; also by not
 
758
                        # chopping paths so much. -- mbp 2010-02-11
 
759
                        child_base = os.path.basename(self.id2path(child))
 
760
                        if (child_base == elt):
 
761
                            # if we found an exact match, we can stop now; if
 
762
                            # we found an approximate match we need to keep
 
763
                            # searching because there might be an exact match
 
764
                            # later.  
 
765
                            cur_id = child
 
766
                            new_path = osutils.pathjoin(cur_path, child_base)
 
767
                            break
 
768
                        elif child_base.lower() == lelt:
 
769
                            cur_id = child
 
770
                            new_path = osutils.pathjoin(cur_path, child_base)
 
771
                    except errors.NoSuchId:
 
772
                        # before a change is committed we can see this error...
 
773
                        continue
 
774
                if new_path:
 
775
                    cur_path = new_path
 
776
                else:
 
777
                    # got to the end of this directory and no entries matched.
 
778
                    # Return what matched so far, plus the rest as specified.
 
779
                    cur_path = osutils.pathjoin(cur_path, elt, *list(bit_iter))
 
780
                    break
 
781
            yield cur_path
 
782
        # all done.
 
783
 
 
784
    @deprecated_method(deprecated_in((2, 5, 0)))
 
785
    def _get_inventory(self):
 
786
        return self._inventory
 
787
 
 
788
    inventory = property(_get_inventory,
 
789
                         doc="Inventory of this Tree")
 
790
 
 
791
    def _get_root_inventory(self):
 
792
        return self._inventory
 
793
 
 
794
    root_inventory = property(_get_root_inventory,
 
795
        doc="Root inventory of this tree")
 
796
 
 
797
    def _unpack_file_id(self, file_id):
 
798
        """Find the inventory and inventory file id for a tree file id.
 
799
 
 
800
        :param file_id: The tree file id, as bytestring or tuple
 
801
        :return: Inventory and inventory file id
 
802
        """
 
803
        if isinstance(file_id, tuple):
 
804
            if len(file_id) != 1:
 
805
                raise ValueError("nested trees not yet supported: %r" % file_id)
 
806
            file_id = file_id[0]
 
807
        return self.root_inventory, file_id
 
808
 
 
809
    @needs_read_lock
 
810
    def path2id(self, path):
 
811
        """Return the id for path in this tree."""
 
812
        return self._path2inv_file_id(path)[1]
 
813
 
 
814
    def _path2inv_file_id(self, path):
 
815
        """Lookup a inventory and inventory file id by path.
 
816
 
 
817
        :param path: Path to look up
 
818
        :return: tuple with inventory and inventory file id
 
819
        """
 
820
        # FIXME: Support nested trees
 
821
        return self.root_inventory, self.root_inventory.path2id(path)
 
822
 
 
823
    def id2path(self, file_id):
 
824
        """Return the path for a file id.
 
825
 
 
826
        :raises NoSuchId:
 
827
        """
 
828
        inventory, file_id = self._unpack_file_id(file_id)
 
829
        return inventory.id2path(file_id)
 
830
 
 
831
    def has_id(self, file_id):
 
832
        inventory, file_id = self._unpack_file_id(file_id)
 
833
        return inventory.has_id(file_id)
 
834
 
 
835
    def has_or_had_id(self, file_id):
 
836
        inventory, file_id = self._unpack_file_id(file_id)
 
837
        return inventory.has_id(file_id)
 
838
 
 
839
    def all_file_ids(self):
 
840
        return set(
 
841
            [entry.file_id for path, entry in self.iter_entries_by_dir()])
 
842
 
 
843
    @deprecated_method(deprecated_in((2, 4, 0)))
 
844
    def __iter__(self):
 
845
        return iter(self.all_file_ids())
 
846
 
 
847
    def filter_unversioned_files(self, paths):
 
848
        """Filter out paths that are versioned.
 
849
 
 
850
        :return: set of paths.
 
851
        """
 
852
        # NB: we specifically *don't* call self.has_filename, because for
 
853
        # WorkingTrees that can indicate files that exist on disk but that
 
854
        # are not versioned.
 
855
        return set((p for p in paths if self.path2id(p) is None))
 
856
 
 
857
    @needs_read_lock
 
858
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
 
859
        """Walk the tree in 'by_dir' order.
 
860
 
 
861
        This will yield each entry in the tree as a (path, entry) tuple.
 
862
        The order that they are yielded is:
 
863
 
 
864
        See Tree.iter_entries_by_dir for details.
 
865
 
 
866
        :param yield_parents: If True, yield the parents from the root leading
 
867
            down to specific_file_ids that have been requested. This has no
 
868
            impact if specific_file_ids is None.
 
869
        """
 
870
        if specific_file_ids is None:
 
871
            inventory_file_ids = None
 
872
        else:
 
873
            inventory_file_ids = []
 
874
            for tree_file_id in specific_file_ids:
 
875
                inventory, inv_file_id = self._unpack_file_id(tree_file_id)
 
876
                if not inventory is self.root_inventory: # for now
 
877
                    raise AssertionError("%r != %r" % (
 
878
                        inventory, self.root_inventory))
 
879
                inventory_file_ids.append(inv_file_id)
 
880
        # FIXME: Handle nested trees
 
881
        return self.root_inventory.iter_entries_by_dir(
 
882
            specific_file_ids=inventory_file_ids, yield_parents=yield_parents)
 
883
 
 
884
    @needs_read_lock
 
885
    def iter_child_entries(self, file_id, path=None):
 
886
        inv, inv_file_id = self._unpack_file_id(file_id)
 
887
        return inv[inv_file_id].children.itervalues()
 
888
 
 
889
    @deprecated_method(deprecated_in((2, 5, 0)))
 
890
    def get_file_by_path(self, path):
 
891
        return self.get_file(self.path2id(path), path)
 
892
 
 
893
    def iter_children(self, file_id, path=None):
 
894
        """See Tree.iter_children."""
 
895
        entry = self.iter_entries_by_dir([file_id]).next()[1]
 
896
        for child in getattr(entry, 'children', {}).itervalues():
 
897
            yield child.file_id
768
898
 
769
899
 
770
900
def find_ids_across_trees(filenames, trees, require_versioned=True):
777
907
        None)
778
908
    :param trees: The trees to find file_ids within
779
909
    :param require_versioned: if true, all specified filenames must occur in
780
 
    at least one tree.
 
910
        at least one tree.
781
911
    :return: a set of file ids for the specified filenames and their children.
782
912
    """
783
913
    if not filenames:
859
989
 
860
990
    _optimisers = []
861
991
 
 
992
    @classmethod
 
993
    def is_compatible(kls, source, target):
 
994
        # The default implementation is naive and uses the public API, so
 
995
        # it works for all trees.
 
996
        return True
 
997
 
862
998
    def _changes_from_entries(self, source_entry, target_entry,
863
999
        source_path=None, target_path=None):
864
1000
        """Generate a iter_changes tuple between source_entry and target_entry.
912
1048
        if source_kind != target_kind:
913
1049
            changed_content = True
914
1050
        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)):
 
1051
            if not self.file_content_matches(file_id, file_id, source_path,
 
1052
                    target_path, source_stat, target_stat):
917
1053
                changed_content = True
918
1054
        elif source_kind == 'symlink':
919
1055
            if (self.source.get_symlink_target(file_id) !=
920
1056
                self.target.get_symlink_target(file_id)):
921
1057
                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)):
 
1058
        elif source_kind == 'tree-reference':
 
1059
            if (self.source.get_reference_revision(file_id, source_path)
 
1060
                != self.target.get_reference_revision(file_id, target_path)):
929
1061
                    changed_content = True
930
1062
        parent = (source_parent, target_parent)
931
1063
        name = (source_name, target_name)
969
1101
            # All files are unversioned, so just return an empty delta
970
1102
            # _compare_trees would think we want a complete delta
971
1103
            result = delta.TreeDelta()
972
 
            fake_entry = InventoryFile('unused', 'unused', 'unused')
 
1104
            fake_entry = inventory.InventoryFile('unused', 'unused', 'unused')
973
1105
            result.unversioned = [(path, None,
974
1106
                self.target._comparison_data(fake_entry, path)[0]) for path in
975
1107
                specific_files]
1040
1172
                                     self.target.extras()
1041
1173
                if specific_files is None or
1042
1174
                    osutils.is_inside_any(specific_files, p)])
1043
 
            all_unversioned = deque(all_unversioned)
 
1175
            all_unversioned = collections.deque(all_unversioned)
1044
1176
        else:
1045
 
            all_unversioned = deque()
 
1177
            all_unversioned = collections.deque()
1046
1178
        to_paths = {}
1047
1179
        from_entries_by_dir = list(self.source.iter_entries_by_dir(
1048
1180
            specific_file_ids=specific_file_ids))
1054
1186
        # the unversioned path lookup only occurs on real trees - where there
1055
1187
        # can be extras. So the fake_entry is solely used to look up
1056
1188
        # executable it values when execute is not supported.
1057
 
        fake_entry = InventoryFile('unused', 'unused', 'unused')
 
1189
        fake_entry = inventory.InventoryFile('unused', 'unused', 'unused')
1058
1190
        for target_path, target_entry in to_entries_by_dir:
1059
1191
            while (all_unversioned and
1060
1192
                all_unversioned[0][0] < target_path.split('/')):
1108
1240
            if file_id in to_paths:
1109
1241
                # already returned
1110
1242
                continue
1111
 
            if file_id not in self.target.all_file_ids():
 
1243
            if not self.target.has_id(file_id):
1112
1244
                # common case - paths we have not emitted are not present in
1113
1245
                # target.
1114
1246
                to_path = None
1146
1278
        :param file_id: The file_id to lookup.
1147
1279
        """
1148
1280
        try:
1149
 
            inventory = tree.inventory
 
1281
            inventory = tree.root_inventory
1150
1282
        except NotImplementedError:
1151
1283
            # No inventory available.
1152
1284
            try:
1227
1359
                        if old_entry is None:
1228
1360
                            # Reusing a discarded change.
1229
1361
                            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)
 
1362
                        precise_file_ids.update(
 
1363
                                self.source.iter_children(file_id))
1232
1364
                    changed_file_ids.add(result[0])
1233
1365
                    yield result
1234
1366
 
 
1367
    @needs_read_lock
 
1368
    def file_content_matches(self, source_file_id, target_file_id,
 
1369
            source_path=None, target_path=None, source_stat=None, target_stat=None):
 
1370
        """Check if two files are the same in the source and target trees.
 
1371
 
 
1372
        This only checks that the contents of the files are the same,
 
1373
        it does not touch anything else.
 
1374
 
 
1375
        :param source_file_id: File id of the file in the source tree
 
1376
        :param target_file_id: File id of the file in the target tree
 
1377
        :param source_path: Path of the file in the source tree
 
1378
        :param target_path: Path of the file in the target tree
 
1379
        :param source_stat: Optional stat value of the file in the source tree
 
1380
        :param target_stat: Optional stat value of the file in the target tree
 
1381
        :return: Boolean indicating whether the files have the same contents
 
1382
        """
 
1383
        source_verifier_kind, source_verifier_data = self.source.get_file_verifier(
 
1384
            source_file_id, source_path, source_stat)
 
1385
        target_verifier_kind, target_verifier_data = self.target.get_file_verifier(
 
1386
            target_file_id, target_path, target_stat)
 
1387
        if source_verifier_kind == target_verifier_kind:
 
1388
            return (source_verifier_data == target_verifier_data)
 
1389
        # Fall back to SHA1 for now
 
1390
        if source_verifier_kind != "SHA1":
 
1391
            source_sha1 = self.source.get_file_sha1(source_file_id,
 
1392
                    source_path, source_stat)
 
1393
        else:
 
1394
            source_sha1 = source_verifier_data
 
1395
        if target_verifier_kind != "SHA1":
 
1396
            target_sha1 = self.target.get_file_sha1(target_file_id,
 
1397
                    target_path, target_stat)
 
1398
        else:
 
1399
            target_sha1 = target_verifier_data
 
1400
        return (source_sha1 == target_sha1)
 
1401
 
 
1402
InterTree.register_optimiser(InterTree)
 
1403
 
1235
1404
 
1236
1405
class MultiWalker(object):
1237
1406
    """Walk multiple trees simultaneously, getting combined results."""
1340
1509
            return (None, None)
1341
1510
        else:
1342
1511
            self._out_of_order_processed.add(file_id)
1343
 
            cur_ie = other_tree.inventory[file_id]
 
1512
            cur_ie = other_tree.root_inventory[file_id]
1344
1513
            return (cur_path, cur_ie)
1345
1514
 
1346
1515
    def iter_all(self):