← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

  • Committer: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tree.py
1
 
# Copyright (C) 2005 Canonical Ltd
 
1
# Copyright (C) 2005-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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tree classes, representing directory at point in time.
18
18
"""
19
19
 
 
20
from __future__ import absolute_import
 
21
 
20
22
import os
21
 
from collections import deque
22
 
from cStringIO import StringIO
23
 
 
24
 
import bzrlib
 
23
 
 
24
from bzrlib.lazy_import import lazy_import
 
25
lazy_import(globals(), """
 
26
import collections
 
27
 
25
28
from bzrlib import (
26
29
    conflicts as _mod_conflicts,
 
30
    debug,
27
31
    delta,
 
32
    errors,
 
33
    filters,
 
34
    inventory,
28
35
    osutils,
29
36
    revision as _mod_revision,
30
37
    rules,
31
 
    symbol_versioning,
 
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, BzrCheckError
35
 
from bzrlib import errors
36
 
from bzrlib.inventory import Inventory, 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 mutter, note
 
45
from bzrlib.symbol_versioning import (
 
46
    deprecated_in,
 
47
    deprecated_method,
 
48
    )
42
49
 
43
50
 
44
51
class Tree(object):
45
52
    """Abstract file tree.
46
53
 
47
54
    There are several subclasses:
48
 
    
 
55
 
49
56
    * `WorkingTree` exists as files on disk editable by the user.
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):
80
88
            a PathsNotVersionedError will be thrown.
81
89
        :param want_unversioned: Scan for unversioned paths.
82
90
 
83
 
        The comparison will be performed by an InterTree object looked up on 
 
91
        The comparison will be performed by an InterTree object looked up on
84
92
        self and other.
85
93
        """
86
94
        # Martin observes that Tree.changes_from returns a TreeDelta and this
95
103
            want_unversioned=want_unversioned,
96
104
            )
97
105
 
98
 
    @symbol_versioning.deprecated_method(symbol_versioning.one_three)
99
 
    def _iter_changes(self, *args, **kwargs):
100
 
        return self.iter_changes(*args, **kwargs)
101
 
 
102
106
    def iter_changes(self, from_tree, include_unchanged=False,
103
107
                     specific_files=None, pb=None, extra_trees=None,
104
108
                     require_versioned=True, want_unversioned=False):
 
109
        """See InterTree.iter_changes"""
105
110
        intertree = InterTree.get(from_tree, self)
106
111
        return intertree.iter_changes(include_unchanged, specific_files, pb,
107
112
            extra_trees, require_versioned, want_unversioned=want_unversioned)
108
 
    
 
113
 
109
114
    def conflicts(self):
110
115
        """Get a list of the conflicts in the tree.
111
116
 
118
123
        return []
119
124
 
120
125
    def get_parent_ids(self):
121
 
        """Get the parent ids for this tree. 
 
126
        """Get the parent ids for this tree.
122
127
 
123
128
        :return: a list of parent ids. [] is returned to indicate
124
129
        a tree with no parents.
125
130
        :raises: BzrError if the parents are not known.
126
131
        """
127
132
        raise NotImplementedError(self.get_parent_ids)
128
 
    
 
133
 
129
134
    def has_filename(self, filename):
130
135
        """True if the tree has given filename."""
131
136
        raise NotImplementedError(self.has_filename)
132
137
 
133
138
    def has_id(self, file_id):
134
 
        return self.inventory.has_id(file_id)
 
139
        raise NotImplementedError(self.has_id)
135
140
 
 
141
    @deprecated_method(deprecated_in((2, 4, 0)))
136
142
    def __contains__(self, file_id):
137
143
        return self.has_id(file_id)
138
144
 
139
145
    def has_or_had_id(self, file_id):
140
 
        if file_id == self.inventory.root.file_id:
141
 
            return True
142
 
        return self.inventory.has_id(file_id)
 
146
        raise NotImplementedError(self.has_or_had_id)
143
147
 
144
148
    def is_ignored(self, filename):
145
149
        """Check whether the filename is ignored by this tree.
149
153
        """
150
154
        return False
151
155
 
152
 
    def __iter__(self):
153
 
        return iter(self.inventory)
154
 
 
155
156
    def all_file_ids(self):
156
157
        """Iterate through all file ids, including ids for missing files."""
157
 
        return set(self.inventory)
 
158
        raise NotImplementedError(self.all_file_ids)
158
159
 
159
160
    def id2path(self, file_id):
160
161
        """Return the path for a file id.
161
162
 
162
163
        :raises NoSuchId:
163
164
        """
164
 
        return self.inventory.id2path(file_id)
165
 
 
166
 
    def is_control_filename(self, filename):
167
 
        """True if filename is the name of a control file in this tree.
168
 
        
169
 
        :param filename: A filename within the tree. This is a relative path
170
 
        from the root of this tree.
171
 
 
172
 
        This is true IF and ONLY IF the filename is part of the meta data
173
 
        that bzr controls in this tree. I.E. a random .bzr directory placed
174
 
        on disk will not be a control file for this tree.
175
 
        """
176
 
        return self.bzrdir.is_control_filename(filename)
177
 
 
178
 
    @needs_read_lock
179
 
    def iter_entries_by_dir(self, specific_file_ids=None):
 
165
        raise NotImplementedError(self.id2path)
 
166
 
 
167
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
180
168
        """Walk the tree in 'by_dir' order.
181
169
 
182
170
        This will yield each entry in the tree as a (path, entry) tuple.
198
186
             g
199
187
 
200
188
        The yield order (ignoring root) would be::
 
189
 
201
190
          a, f, a/b, a/d, a/b/c, a/d/e, f/g
202
 
        """
203
 
        return self.inventory.iter_entries_by_dir(
204
 
            specific_file_ids=specific_file_ids)
 
191
 
 
192
        :param yield_parents: If True, yield the parents from the root leading
 
193
            down to specific_file_ids that have been requested. This has no
 
194
            impact if specific_file_ids is None.
 
195
        """
 
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)
205
218
 
206
219
    def iter_references(self):
207
 
        for path, entry in self.iter_entries_by_dir():
208
 
            if entry.kind == 'tree-reference':
209
 
                yield path, entry.file_id
 
220
        if self.supports_tree_reference():
 
221
            for path, entry in self.iter_entries_by_dir():
 
222
                if entry.kind == 'tree-reference':
 
223
                    yield path, entry.file_id
210
224
 
211
225
    def kind(self, file_id):
212
226
        raise NotImplementedError("Tree subclass %s must implement kind"
222
236
 
223
237
    def path_content_summary(self, path):
224
238
        """Get a summary of the information about path.
225
 
        
 
239
 
 
240
        All the attributes returned are for the canonical form, not the
 
241
        convenient form (if content filters are in use.)
 
242
 
226
243
        :param path: A relative path within the tree.
227
244
        :return: A tuple containing kind, size, exec, sha1-or-link.
228
245
            Kind is always present (see tree.kind()).
229
 
            size is present if kind is file, None otherwise.
 
246
            size is present if kind is file and the size of the 
 
247
                canonical form can be cheaply determined, None otherwise.
230
248
            exec is None unless kind is file and the platform supports the 'x'
231
249
                bit.
232
250
            sha1-or-link is the link target if kind is symlink, or the sha1 if
253
271
    def _file_size(self, entry, stat_value):
254
272
        raise NotImplementedError(self._file_size)
255
273
 
256
 
    def _get_inventory(self):
257
 
        return self._inventory
258
 
    
259
274
    def get_file(self, file_id, path=None):
260
275
        """Return a file object for the file file_id in the tree.
261
 
        
 
276
 
262
277
        If both file_id and path are defined, it is implementation defined as
263
278
        to which one is used.
264
279
        """
265
280
        raise NotImplementedError(self.get_file)
266
281
 
 
282
    def get_file_with_stat(self, file_id, path=None):
 
283
        """Get a file handle and stat object for file_id.
 
284
 
 
285
        The default implementation returns (self.get_file, None) for backwards
 
286
        compatibility.
 
287
 
 
288
        :param file_id: The file id to read.
 
289
        :param path: The path of the file, if it is known.
 
290
        :return: A tuple (file_handle, stat_value_or_None). If the tree has
 
291
            no stat facility, or need for a stat cache feedback during commit,
 
292
            it may return None for the second element of the tuple.
 
293
        """
 
294
        return (self.get_file(file_id, path), None)
 
295
 
267
296
    def get_file_text(self, file_id, path=None):
268
297
        """Return the byte content of a file.
269
298
 
270
299
        :param file_id: The file_id of the file.
271
300
        :param path: The path of the file.
 
301
 
272
302
        If both file_id and path are supplied, an implementation may use
273
303
        either one.
 
304
 
 
305
        :returns: A single byte string for the whole file.
274
306
        """
275
307
        my_file = self.get_file(file_id, path)
276
308
        try:
283
315
 
284
316
        :param file_id: The file_id of the file.
285
317
        :param path: The path of the file.
 
318
 
286
319
        If both file_id and path are supplied, an implementation may use
287
320
        either one.
288
321
        """
289
322
        return osutils.split_lines(self.get_file_text(file_id, path))
290
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
 
291
352
    def get_file_mtime(self, file_id, path=None):
292
353
        """Return the modification time for a file.
293
354
 
306
367
        """
307
368
        raise NotImplementedError(self.get_file_size)
308
369
 
309
 
    def get_file_by_path(self, path):
310
 
        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)
311
378
 
312
379
    def iter_files_bytes(self, desired_files):
313
380
        """Iterate through file contents.
335
402
            cur_file = (self.get_file_text(file_id),)
336
403
            yield identifier, cur_file
337
404
 
338
 
    def get_symlink_target(self, file_id):
 
405
    def get_symlink_target(self, file_id, path=None):
339
406
        """Get the target for a given file_id.
340
407
 
341
408
        It is assumed that the caller already knows that file_id is referencing
342
409
        a symlink.
343
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.
344
414
        :return: The path the symlink points to.
345
415
        """
346
416
        raise NotImplementedError(self.get_symlink_target)
364
434
        raise NotImplementedError(self.annotate_iter)
365
435
 
366
436
    def _get_plan_merge_data(self, file_id, other, base):
367
 
        from bzrlib import merge, versionedfile
 
437
        from bzrlib import versionedfile
368
438
        vf = versionedfile._PlanMergeVersionedFile(file_id)
369
439
        last_revision_a = self._get_file_revision(file_id, vf, 'this:')
370
440
        last_revision_b = other._get_file_revision(file_id, vf, 'other:')
408
478
            except errors.NoSuchRevisionInTree:
409
479
                yield self.repository.revision_tree(revision_id)
410
480
 
411
 
    @staticmethod
412
 
    def _file_revision(revision_tree, file_id):
413
 
        """Determine the revision associated with a file in a given tree."""
414
 
        revision_tree.lock_read()
415
 
        try:
416
 
            return revision_tree.inventory[file_id].revision
417
 
        finally:
418
 
            revision_tree.unlock()
419
 
 
420
481
    def _get_file_revision(self, file_id, vf, tree_revision):
421
482
        """Ensure that file_id, tree_revision is in vf to plan the merge."""
422
483
 
423
484
        if getattr(self, '_repository', None) is None:
424
485
            last_revision = tree_revision
425
 
            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
426
487
                self._iter_parent_trees()]
427
488
            vf.add_lines((file_id, last_revision), parent_keys,
428
 
                         self.get_file(file_id).readlines())
 
489
                         self.get_file_lines(file_id))
429
490
            repo = self.branch.repository
430
491
            base_vf = repo.texts
431
492
        else:
432
 
            last_revision = self._file_revision(self, file_id)
 
493
            last_revision = self.get_file_revision(file_id)
433
494
            base_vf = self._repository.texts
434
495
        if base_vf not in vf.fallback_versionedfiles:
435
496
            vf.fallback_versionedfiles.append(base_vf)
436
497
        return last_revision
437
498
 
438
 
    inventory = property(_get_inventory,
439
 
                         doc="Inventory of this Tree")
440
 
 
441
499
    def _check_retrieved(self, ie, f):
442
500
        if not __debug__:
443
 
            return  
444
 
        fp = fingerprint_file(f)
 
501
            return
 
502
        fp = osutils.fingerprint_file(f)
445
503
        f.seek(0)
446
 
        
 
504
 
447
505
        if ie.text_size is not None:
448
506
            if ie.text_size != fp['size']:
449
 
                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),
450
510
                        ["inventory expects %d bytes" % ie.text_size,
451
511
                         "file is actually %d bytes" % fp['size'],
452
512
                         "store is probably damaged/corrupt"])
453
513
 
454
514
        if ie.text_sha1 != fp['sha1']:
455
 
            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),
456
517
                    ["inventory expects %s" % ie.text_sha1,
457
518
                     "file is actually %s" % fp['sha1'],
458
519
                     "store is probably damaged/corrupt"])
459
520
 
460
 
    @needs_read_lock
461
521
    def path2id(self, path):
462
522
        """Return the id for path in this tree."""
463
 
        return self._inventory.path2id(path)
 
523
        raise NotImplementedError(self.path2id)
464
524
 
465
525
    def paths2ids(self, paths, trees=[], require_versioned=True):
466
526
        """Return all the ids that can be reached by walking from paths.
467
 
        
 
527
 
468
528
        Each path is looked up in this tree and any extras provided in
469
529
        trees, and this is repeated recursively: the children in an extra tree
470
530
        of a directory that has been renamed under a provided path in this tree
482
542
        return find_ids_across_trees(paths, [self] + list(trees), require_versioned)
483
543
 
484
544
    def iter_children(self, file_id):
485
 
        entry = self.iter_entries_by_dir([file_id]).next()[1]
486
 
        for child in getattr(entry, 'children', {}).itervalues():
487
 
            yield child.file_id
 
545
        """Iterate over the file ids of the children of an entry.
488
546
 
489
 
    @symbol_versioning.deprecated_method(symbol_versioning.one_six)
490
 
    def print_file(self, file_id):
491
 
        """Print file with id `file_id` to stdout."""
492
 
        import sys
493
 
        sys.stdout.write(self.get_file_text(file_id))
 
547
        :param file_id: File id of the entry
 
548
        :return: Iterator over child file ids.
 
549
        """
 
550
        raise NotImplementedError(self.iter_children)
494
551
 
495
552
    def lock_read(self):
 
553
        """Lock this tree for multiple read only operations.
 
554
 
 
555
        :return: A bzrlib.lock.LogicalLockResult.
 
556
        """
496
557
        pass
497
558
 
498
559
    def revision_tree(self, revision_id):
500
561
 
501
562
        The intention of this method is to allow access to possibly cached
502
563
        tree data. Implementors of this method should raise NoSuchRevision if
503
 
        the tree is not locally available, even if they could obtain the 
504
 
        tree via a repository or some other means. Callers are responsible 
 
564
        the tree is not locally available, even if they could obtain the
 
565
        tree via a repository or some other means. Callers are responsible
505
566
        for finding the ultimate source for a revision tree.
506
567
 
507
568
        :param revision_id: The revision_id of the requested tree.
512
573
 
513
574
    def unknowns(self):
514
575
        """What files are present in this tree and unknown.
515
 
        
 
576
 
516
577
        :return: an iterator over the unknown files.
517
578
        """
518
579
        return iter([])
525
586
 
526
587
        :return: set of paths.
527
588
        """
528
 
        # NB: we specifically *don't* call self.has_filename, because for
529
 
        # WorkingTrees that can indicate files that exist on disk but that 
530
 
        # are not versioned.
531
 
        pred = self.inventory.has_filename
532
 
        return set((p for p in paths if not pred(p)))
 
589
        raise NotImplementedError(self.filter_unversioned_files)
533
590
 
534
591
    def walkdirs(self, prefix=""):
535
592
        """Walk the contents of this tree from path down.
537
594
        This yields all the data about the contents of a directory at a time.
538
595
        After each directory has been yielded, if the caller has mutated the
539
596
        list to exclude some directories, they are then not descended into.
540
 
        
 
597
 
541
598
        The data yielded is of the form:
542
599
        ((directory-relpath, directory-path-from-root, directory-fileid),
543
 
        [(relpath, basename, kind, lstat, path_from_tree_root, file_id, 
 
600
        [(relpath, basename, kind, lstat, path_from_tree_root, file_id,
544
601
          versioned_kind), ...]),
545
602
         - directory-relpath is the containing dirs relpath from prefix
546
603
         - directory-path-from-root is the containing dirs path from /
553
610
         - lstat is the stat data *if* the file was statted.
554
611
         - path_from_tree_root is the path from the root of the tree.
555
612
         - file_id is the file_id if the entry is versioned.
556
 
         - versioned_kind is the kind of the file as last recorded in the 
 
613
         - versioned_kind is the kind of the file as last recorded in the
557
614
           versioning system. If 'unknown' the file is not versioned.
558
615
        One of 'kind' and 'versioned_kind' must not be 'unknown'.
559
616
 
564
621
        """
565
622
        raise NotImplementedError(self.walkdirs)
566
623
 
 
624
    def supports_content_filtering(self):
 
625
        return False
 
626
 
 
627
    def _content_filter_stack(self, path=None, file_id=None):
 
628
        """The stack of content filters for a path if filtering is supported.
 
629
 
 
630
        Readers will be applied in first-to-last order.
 
631
        Writers will be applied in last-to-first order.
 
632
        Either the path or the file-id needs to be provided.
 
633
 
 
634
        :param path: path relative to the root of the tree
 
635
            or None if unknown
 
636
        :param file_id: file_id or None if unknown
 
637
        :return: the list of filters - [] if there are none
 
638
        """
 
639
        filter_pref_names = filters._get_registered_names()
 
640
        if len(filter_pref_names) == 0:
 
641
            return []
 
642
        if path is None:
 
643
            path = self.id2path(file_id)
 
644
        prefs = self.iter_search_rules([path], filter_pref_names).next()
 
645
        stk = filters._get_filter_stack_for(prefs)
 
646
        if 'filters' in debug.debug_flags:
 
647
            trace.note(gettext("*** {0} content-filter: {1} => {2!r}").format(path,prefs,stk))
 
648
        return stk
 
649
 
 
650
    def _content_filter_stack_provider(self):
 
651
        """A function that returns a stack of ContentFilters.
 
652
 
 
653
        The function takes a path (relative to the top of the tree) and a
 
654
        file-id as parameters.
 
655
 
 
656
        :return: None if content filtering is not supported by this tree.
 
657
        """
 
658
        if self.supports_content_filtering():
 
659
            return lambda path, file_id: \
 
660
                    self._content_filter_stack(path, file_id)
 
661
        else:
 
662
            return None
 
663
 
567
664
    def iter_search_rules(self, path_names, pref_names=None,
568
 
        _default_searcher=rules._per_user_searcher):
 
665
        _default_searcher=None):
569
666
        """Find the preferences for filenames in a tree.
570
667
 
571
668
        :param path_names: an iterable of paths to find attributes for.
575
672
        :return: an iterator of tuple sequences, one per path-name.
576
673
          See _RulesSearcher.get_items for details on the tuple sequence.
577
674
        """
 
675
        if _default_searcher is None:
 
676
            _default_searcher = rules._per_user_searcher
578
677
        searcher = self._get_rules_searcher(_default_searcher)
579
678
        if searcher is not None:
580
679
            if pref_names is not None:
584
683
                for path in path_names:
585
684
                    yield searcher.get_items(path)
586
685
 
587
 
    @needs_read_lock
588
686
    def _get_rules_searcher(self, default_searcher):
589
687
        """Get the RulesSearcher for this tree given the default one."""
590
688
        searcher = default_searcher
591
689
        return searcher
592
690
 
593
691
 
594
 
class EmptyTree(Tree):
595
 
 
596
 
    def __init__(self):
597
 
        self._inventory = Inventory(root_id=None)
598
 
        symbol_versioning.warn('EmptyTree is deprecated as of bzr 0.9 please'
599
 
                               ' use repository.revision_tree instead.',
600
 
                               DeprecationWarning, stacklevel=2)
601
 
 
602
 
    def get_parent_ids(self):
603
 
        return []
604
 
 
605
 
    def get_symlink_target(self, file_id):
606
 
        return None
607
 
 
608
 
    def has_filename(self, filename):
609
 
        return False
610
 
 
611
 
    def kind(self, file_id):
612
 
        return "directory"
613
 
 
614
 
    def list_files(self, include_root=False):
615
 
        return iter([])
616
 
    
617
 
    def __contains__(self, file_id):
618
 
        return (file_id in self._inventory)
619
 
 
620
 
    def get_file_sha1(self, file_id, path=None, stat_value=None):
621
 
        return None
622
 
 
623
 
 
624
 
######################################################################
625
 
# diff
626
 
 
627
 
# TODO: Merge these two functions into a single one that can operate
628
 
# on either a whole tree or a set of files.
629
 
 
630
 
# TODO: Return the diff in order by filename, not by category or in
631
 
# random order.  Can probably be done by lock-stepping through the
632
 
# filenames from both trees.
633
 
 
634
 
 
635
 
def file_status(filename, old_tree, new_tree):
636
 
    """Return single-letter status, old and new names for a file.
637
 
 
638
 
    The complexity here is in deciding how to represent renames;
639
 
    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.
640
704
    """
641
 
    old_inv = old_tree.inventory
642
 
    new_inv = new_tree.inventory
643
 
    new_id = new_inv.path2id(filename)
644
 
    old_id = old_inv.path2id(filename)
645
 
 
646
 
    if not new_id and not old_id:
647
 
        # easy: doesn't exist in either; not versioned at all
648
 
        if new_tree.is_ignored(filename):
649
 
            return 'I', None, None
650
 
        else:
651
 
            return '?', None, None
652
 
    elif new_id:
653
 
        # There is now a file of this name, great.
654
 
        pass
655
 
    else:
656
 
        # There is no longer a file of this name, but we can describe
657
 
        # what happened to the file that used to have
658
 
        # this name.  There are two possibilities: either it was
659
 
        # deleted entirely, or renamed.
660
 
        if new_inv.has_id(old_id):
661
 
            return 'X', old_inv.id2path(old_id), new_inv.id2path(old_id)
662
 
        else:
663
 
            return 'D', old_inv.id2path(old_id), None
664
 
 
665
 
    # if the file_id is new in this revision, it is added
666
 
    if new_id and not old_inv.has_id(new_id):
667
 
        return 'A'
668
 
 
669
 
    # if there used to be a file of this name, but that ID has now
670
 
    # disappeared, it is deleted
671
 
    if old_id and not new_inv.has_id(old_id):
672
 
        return 'D'
673
 
 
674
 
    return 'wtf?'
675
 
 
676
 
    
677
 
@deprecated_function(deprecated_in((1, 9, 0)))
678
 
def find_renames(old_inv, new_inv):
679
 
    for file_id in old_inv:
680
 
        if file_id not in new_inv:
681
 
            continue
682
 
        old_name = old_inv.id2path(file_id)
683
 
        new_name = new_inv.id2path(file_id)
684
 
        if old_name != new_name:
685
 
            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
686
898
 
687
899
 
688
900
def find_ids_across_trees(filenames, trees, require_versioned=True):
689
901
    """Find the ids corresponding to specified filenames.
690
 
    
 
902
 
691
903
    All matches in all trees will be used, and all children of matched
692
904
    directories will be used.
693
905
 
695
907
        None)
696
908
    :param trees: The trees to find file_ids within
697
909
    :param require_versioned: if true, all specified filenames must occur in
698
 
    at least one tree.
 
910
        at least one tree.
699
911
    :return: a set of file ids for the specified filenames and their children.
700
912
    """
701
913
    if not filenames:
707
919
 
708
920
def _find_ids_across_trees(filenames, trees, require_versioned):
709
921
    """Find the ids corresponding to specified filenames.
710
 
    
 
922
 
711
923
    All matches in all trees will be used, but subdirectories are not scanned.
712
924
 
713
925
    :param filenames: The filenames to find file_ids for
734
946
 
735
947
def _find_children_across_trees(specified_ids, trees):
736
948
    """Return a set including specified ids and their children.
737
 
    
 
949
 
738
950
    All matches in all trees will be used.
739
951
 
740
952
    :param trees: The trees to find file_ids within
741
 
    :return: a set containing all specified ids and their children 
 
953
    :return: a set containing all specified ids and their children
742
954
    """
743
955
    interesting_ids = set(specified_ids)
744
956
    pending = interesting_ids
748
960
        new_pending = set()
749
961
        for file_id in pending:
750
962
            for tree in trees:
751
 
                if not tree.has_id(file_id):
 
963
                if not tree.has_or_had_id(file_id):
752
964
                    continue
753
965
                for child_id in tree.iter_children(file_id):
754
966
                    if child_id not in interesting_ids:
769
981
    will pass through to InterTree as appropriate.
770
982
    """
771
983
 
 
984
    # Formats that will be used to test this InterTree. If both are
 
985
    # None, this InterTree will not be tested (e.g. because a complex
 
986
    # setup is required)
 
987
    _matching_from_tree_format = None
 
988
    _matching_to_tree_format = None
 
989
 
772
990
    _optimisers = []
773
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
 
 
998
    def _changes_from_entries(self, source_entry, target_entry,
 
999
        source_path=None, target_path=None):
 
1000
        """Generate a iter_changes tuple between source_entry and target_entry.
 
1001
 
 
1002
        :param source_entry: An inventory entry from self.source, or None.
 
1003
        :param target_entry: An inventory entry from self.target, or None.
 
1004
        :param source_path: The path of source_entry, if known. If not known
 
1005
            it will be looked up.
 
1006
        :param target_path: The path of target_entry, if known. If not known
 
1007
            it will be looked up.
 
1008
        :return: A tuple, item 0 of which is an iter_changes result tuple, and
 
1009
            item 1 is True if there are any changes in the result tuple.
 
1010
        """
 
1011
        if source_entry is None:
 
1012
            if target_entry is None:
 
1013
                return None
 
1014
            file_id = target_entry.file_id
 
1015
        else:
 
1016
            file_id = source_entry.file_id
 
1017
        if source_entry is not None:
 
1018
            source_versioned = True
 
1019
            source_name = source_entry.name
 
1020
            source_parent = source_entry.parent_id
 
1021
            if source_path is None:
 
1022
                source_path = self.source.id2path(file_id)
 
1023
            source_kind, source_executable, source_stat = \
 
1024
                self.source._comparison_data(source_entry, source_path)
 
1025
        else:
 
1026
            source_versioned = False
 
1027
            source_name = None
 
1028
            source_parent = None
 
1029
            source_kind = None
 
1030
            source_executable = None
 
1031
        if target_entry is not None:
 
1032
            target_versioned = True
 
1033
            target_name = target_entry.name
 
1034
            target_parent = target_entry.parent_id
 
1035
            if target_path is None:
 
1036
                target_path = self.target.id2path(file_id)
 
1037
            target_kind, target_executable, target_stat = \
 
1038
                self.target._comparison_data(target_entry, target_path)
 
1039
        else:
 
1040
            target_versioned = False
 
1041
            target_name = None
 
1042
            target_parent = None
 
1043
            target_kind = None
 
1044
            target_executable = None
 
1045
        versioned = (source_versioned, target_versioned)
 
1046
        kind = (source_kind, target_kind)
 
1047
        changed_content = False
 
1048
        if source_kind != target_kind:
 
1049
            changed_content = True
 
1050
        elif source_kind == 'file':
 
1051
            if not self.file_content_matches(file_id, file_id, source_path,
 
1052
                    target_path, source_stat, target_stat):
 
1053
                changed_content = True
 
1054
        elif source_kind == 'symlink':
 
1055
            if (self.source.get_symlink_target(file_id) !=
 
1056
                self.target.get_symlink_target(file_id)):
 
1057
                changed_content = True
 
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)):
 
1061
                    changed_content = True
 
1062
        parent = (source_parent, target_parent)
 
1063
        name = (source_name, target_name)
 
1064
        executable = (source_executable, target_executable)
 
1065
        if (changed_content is not False or versioned[0] != versioned[1]
 
1066
            or parent[0] != parent[1] or name[0] != name[1] or
 
1067
            executable[0] != executable[1]):
 
1068
            changes = True
 
1069
        else:
 
1070
            changes = False
 
1071
        return (file_id, (source_path, target_path), changed_content,
 
1072
                versioned, parent, name, kind, executable), changes
 
1073
 
774
1074
    @needs_read_lock
775
1075
    def compare(self, want_unchanged=False, specific_files=None,
776
1076
        extra_trees=None, require_versioned=False, include_root=False,
791
1091
            a PathsNotVersionedError will be thrown.
792
1092
        :param want_unversioned: Scan for unversioned paths.
793
1093
        """
794
 
        # NB: show_status depends on being able to pass in non-versioned files
795
 
        # and report them as unknown
796
1094
        trees = (self.source,)
797
1095
        if extra_trees is not None:
798
1096
            trees = trees + tuple(extra_trees)
803
1101
            # All files are unversioned, so just return an empty delta
804
1102
            # _compare_trees would think we want a complete delta
805
1103
            result = delta.TreeDelta()
806
 
            fake_entry = InventoryFile('unused', 'unused', 'unused')
 
1104
            fake_entry = inventory.InventoryFile('unused', 'unused', 'unused')
807
1105
            result.unversioned = [(path, None,
808
1106
                self.target._comparison_data(fake_entry, path)[0]) for path in
809
1107
                specific_files]
839
1137
        :param require_versioned: Raise errors.PathsNotVersionedError if a
840
1138
            path in the specific_files list is not versioned in one of
841
1139
            source, target or extra_trees.
 
1140
        :param specific_files: An optional list of file paths to restrict the
 
1141
            comparison to. When mapping filenames to ids, all matches in all
 
1142
            trees (including optional extra_trees) are used, and all children
 
1143
            of matched directories are included. The parents in the target tree
 
1144
            of the specific files up to and including the root of the tree are
 
1145
            always evaluated for changes too.
842
1146
        :param want_unversioned: Should unversioned files be returned in the
843
1147
            output. An unversioned file is defined as one with (False, False)
844
1148
            for the versioned pair.
845
1149
        """
846
 
        result = []
847
1150
        lookup_trees = [self.source]
848
1151
        if extra_trees:
849
1152
             lookup_trees.extend(extra_trees)
 
1153
        # The ids of items we need to examine to insure delta consistency.
 
1154
        precise_file_ids = set()
 
1155
        changed_file_ids = []
850
1156
        if specific_files == []:
851
1157
            specific_file_ids = []
852
1158
        else:
853
1159
            specific_file_ids = self.target.paths2ids(specific_files,
854
1160
                lookup_trees, require_versioned=require_versioned)
 
1161
        if specific_files is not None:
 
1162
            # reparented or added entries must have their parents included
 
1163
            # so that valid deltas can be created. The seen_parents set
 
1164
            # tracks the parents that we need to have.
 
1165
            # The seen_dirs set tracks directory entries we've yielded.
 
1166
            # After outputting version object in to_entries we set difference
 
1167
            # the two seen sets and start checking parents.
 
1168
            seen_parents = set()
 
1169
            seen_dirs = set()
855
1170
        if want_unversioned:
856
1171
            all_unversioned = sorted([(p.split('/'), p) for p in
857
1172
                                     self.target.extras()
858
1173
                if specific_files is None or
859
1174
                    osutils.is_inside_any(specific_files, p)])
860
 
            all_unversioned = deque(all_unversioned)
 
1175
            all_unversioned = collections.deque(all_unversioned)
861
1176
        else:
862
 
            all_unversioned = deque()
 
1177
            all_unversioned = collections.deque()
863
1178
        to_paths = {}
864
1179
        from_entries_by_dir = list(self.source.iter_entries_by_dir(
865
1180
            specific_file_ids=specific_file_ids))
868
1183
            specific_file_ids=specific_file_ids))
869
1184
        num_entries = len(from_entries_by_dir) + len(to_entries_by_dir)
870
1185
        entry_count = 0
871
 
        # the unversioned path lookup only occurs on real trees - where there 
 
1186
        # the unversioned path lookup only occurs on real trees - where there
872
1187
        # can be extras. So the fake_entry is solely used to look up
873
1188
        # executable it values when execute is not supported.
874
 
        fake_entry = InventoryFile('unused', 'unused', 'unused')
875
 
        for to_path, to_entry in to_entries_by_dir:
876
 
            while all_unversioned and all_unversioned[0][0] < to_path.split('/'):
 
1189
        fake_entry = inventory.InventoryFile('unused', 'unused', 'unused')
 
1190
        for target_path, target_entry in to_entries_by_dir:
 
1191
            while (all_unversioned and
 
1192
                all_unversioned[0][0] < target_path.split('/')):
877
1193
                unversioned_path = all_unversioned.popleft()
878
 
                to_kind, to_executable, to_stat = \
 
1194
                target_kind, target_executable, target_stat = \
879
1195
                    self.target._comparison_data(fake_entry, unversioned_path[1])
880
1196
                yield (None, (None, unversioned_path[1]), True, (False, False),
881
1197
                    (None, None),
882
1198
                    (None, unversioned_path[0][-1]),
883
 
                    (None, to_kind),
884
 
                    (None, to_executable))
885
 
            file_id = to_entry.file_id
886
 
            to_paths[file_id] = to_path
 
1199
                    (None, target_kind),
 
1200
                    (None, target_executable))
 
1201
            source_path, source_entry = from_data.get(target_entry.file_id,
 
1202
                (None, None))
 
1203
            result, changes = self._changes_from_entries(source_entry,
 
1204
                target_entry, source_path=source_path, target_path=target_path)
 
1205
            to_paths[result[0]] = result[1][1]
887
1206
            entry_count += 1
888
 
            changed_content = False
889
 
            from_path, from_entry = from_data.get(file_id, (None, None))
890
 
            from_versioned = (from_entry is not None)
891
 
            if from_entry is not None:
892
 
                from_versioned = True
893
 
                from_name = from_entry.name
894
 
                from_parent = from_entry.parent_id
895
 
                from_kind, from_executable, from_stat = \
896
 
                    self.source._comparison_data(from_entry, from_path)
 
1207
            if result[3][0]:
897
1208
                entry_count += 1
898
 
            else:
899
 
                from_versioned = False
900
 
                from_kind = None
901
 
                from_parent = None
902
 
                from_name = None
903
 
                from_executable = None
904
 
            versioned = (from_versioned, True)
905
 
            to_kind, to_executable, to_stat = \
906
 
                self.target._comparison_data(to_entry, to_path)
907
 
            kind = (from_kind, to_kind)
908
 
            if kind[0] != kind[1]:
909
 
                changed_content = True
910
 
            elif from_kind == 'file':
911
 
                from_size = self.source._file_size(from_entry, from_stat)
912
 
                to_size = self.target._file_size(to_entry, to_stat)
913
 
                if from_size != to_size:
914
 
                    changed_content = True
915
 
                elif (self.source.get_file_sha1(file_id, from_path, from_stat) !=
916
 
                    self.target.get_file_sha1(file_id, to_path, to_stat)):
917
 
                    changed_content = True
918
 
            elif from_kind == 'symlink':
919
 
                if (self.source.get_symlink_target(file_id) !=
920
 
                    self.target.get_symlink_target(file_id)):
921
 
                    changed_content = True
922
 
                elif from_kind == 'tree-reference':
923
 
                    if (self.source.get_reference_revision(file_id, from_path)
924
 
                        != self.target.get_reference_revision(file_id, to_path)):
925
 
                        changed_content = True 
926
 
            parent = (from_parent, to_entry.parent_id)
927
 
            name = (from_name, to_entry.name)
928
 
            executable = (from_executable, to_executable)
929
1209
            if pb is not None:
930
1210
                pb.update('comparing files', entry_count, num_entries)
931
 
            if (changed_content is not False or versioned[0] != versioned[1]
932
 
                or parent[0] != parent[1] or name[0] != name[1] or 
933
 
                executable[0] != executable[1] or include_unchanged):
934
 
                yield (file_id, (from_path, to_path), changed_content,
935
 
                    versioned, parent, name, kind, executable)
936
 
 
 
1211
            if changes or include_unchanged:
 
1212
                if specific_file_ids is not None:
 
1213
                    new_parent_id = result[4][1]
 
1214
                    precise_file_ids.add(new_parent_id)
 
1215
                    changed_file_ids.append(result[0])
 
1216
                yield result
 
1217
            # Ensure correct behaviour for reparented/added specific files.
 
1218
            if specific_files is not None:
 
1219
                # Record output dirs
 
1220
                if result[6][1] == 'directory':
 
1221
                    seen_dirs.add(result[0])
 
1222
                # Record parents of reparented/added entries.
 
1223
                versioned = result[3]
 
1224
                parents = result[4]
 
1225
                if not versioned[0] or parents[0] != parents[1]:
 
1226
                    seen_parents.add(parents[1])
937
1227
        while all_unversioned:
938
1228
            # yield any trailing unversioned paths
939
1229
            unversioned_path = all_unversioned.popleft()
944
1234
                (None, unversioned_path[0][-1]),
945
1235
                (None, to_kind),
946
1236
                (None, to_executable))
947
 
 
948
 
        def get_to_path(to_entry):
949
 
            if to_entry.parent_id is None:
950
 
                to_path = '' # the root
951
 
            else:
952
 
                if to_entry.parent_id not in to_paths:
953
 
                    # recurse up
954
 
                    return get_to_path(self.target.inventory[to_entry.parent_id])
955
 
                to_path = osutils.pathjoin(to_paths[to_entry.parent_id],
956
 
                                           to_entry.name)
957
 
            to_paths[to_entry.file_id] = to_path
958
 
            return to_path
959
 
 
 
1237
        # Yield all remaining source paths
960
1238
        for path, from_entry in from_entries_by_dir:
961
1239
            file_id = from_entry.file_id
962
1240
            if file_id in to_paths:
963
1241
                # already returned
964
1242
                continue
965
 
            if not file_id in self.target.all_file_ids():
 
1243
            if not self.target.has_id(file_id):
966
1244
                # common case - paths we have not emitted are not present in
967
1245
                # target.
968
1246
                to_path = None
969
1247
            else:
970
 
                to_path = get_to_path(self.target.inventory[file_id])
 
1248
                to_path = self.target.id2path(file_id)
971
1249
            entry_count += 1
972
1250
            if pb is not None:
973
1251
                pb.update('comparing files', entry_count, num_entries)
980
1258
            executable = (from_executable, None)
981
1259
            changed_content = from_kind is not None
982
1260
            # the parent's path is necessarily known at this point.
 
1261
            changed_file_ids.append(file_id)
983
1262
            yield(file_id, (path, to_path), changed_content, versioned, parent,
984
1263
                  name, kind, executable)
 
1264
        changed_file_ids = set(changed_file_ids)
 
1265
        if specific_file_ids is not None:
 
1266
            for result in self._handle_precise_ids(precise_file_ids,
 
1267
                changed_file_ids):
 
1268
                yield result
 
1269
 
 
1270
    def _get_entry(self, tree, file_id):
 
1271
        """Get an inventory entry from a tree, with missing entries as None.
 
1272
 
 
1273
        If the tree raises NotImplementedError on accessing .inventory, then
 
1274
        this is worked around using iter_entries_by_dir on just the file id
 
1275
        desired.
 
1276
 
 
1277
        :param tree: The tree to lookup the entry in.
 
1278
        :param file_id: The file_id to lookup.
 
1279
        """
 
1280
        try:
 
1281
            inventory = tree.root_inventory
 
1282
        except NotImplementedError:
 
1283
            # No inventory available.
 
1284
            try:
 
1285
                iterator = tree.iter_entries_by_dir(specific_file_ids=[file_id])
 
1286
                return iterator.next()[1]
 
1287
            except StopIteration:
 
1288
                return None
 
1289
        else:
 
1290
            try:
 
1291
                return inventory[file_id]
 
1292
            except errors.NoSuchId:
 
1293
                return None
 
1294
 
 
1295
    def _handle_precise_ids(self, precise_file_ids, changed_file_ids,
 
1296
        discarded_changes=None):
 
1297
        """Fill out a partial iter_changes to be consistent.
 
1298
 
 
1299
        :param precise_file_ids: The file ids of parents that were seen during
 
1300
            the iter_changes.
 
1301
        :param changed_file_ids: The file ids of already emitted items.
 
1302
        :param discarded_changes: An optional dict of precalculated
 
1303
            iter_changes items which the partial iter_changes had not output
 
1304
            but had calculated.
 
1305
        :return: A generator of iter_changes items to output.
 
1306
        """
 
1307
        # process parents of things that had changed under the users
 
1308
        # requested paths to prevent incorrect paths or parent ids which
 
1309
        # aren't in the tree.
 
1310
        while precise_file_ids:
 
1311
            precise_file_ids.discard(None)
 
1312
            # Don't emit file_ids twice
 
1313
            precise_file_ids.difference_update(changed_file_ids)
 
1314
            if not precise_file_ids:
 
1315
                break
 
1316
            # If the there was something at a given output path in source, we
 
1317
            # have to include the entry from source in the delta, or we would
 
1318
            # be putting this entry into a used path.
 
1319
            paths = []
 
1320
            for parent_id in precise_file_ids:
 
1321
                try:
 
1322
                    paths.append(self.target.id2path(parent_id))
 
1323
                except errors.NoSuchId:
 
1324
                    # This id has been dragged in from the source by delta
 
1325
                    # expansion and isn't present in target at all: we don't
 
1326
                    # need to check for path collisions on it.
 
1327
                    pass
 
1328
            for path in paths:
 
1329
                old_id = self.source.path2id(path)
 
1330
                precise_file_ids.add(old_id)
 
1331
            precise_file_ids.discard(None)
 
1332
            current_ids = precise_file_ids
 
1333
            precise_file_ids = set()
 
1334
            # We have to emit all of precise_file_ids that have been altered.
 
1335
            # We may have to output the children of some of those ids if any
 
1336
            # directories have stopped being directories.
 
1337
            for file_id in current_ids:
 
1338
                # Examine file_id
 
1339
                if discarded_changes:
 
1340
                    result = discarded_changes.get(file_id)
 
1341
                    old_entry = None
 
1342
                else:
 
1343
                    result = None
 
1344
                if result is None:
 
1345
                    old_entry = self._get_entry(self.source, file_id)
 
1346
                    new_entry = self._get_entry(self.target, file_id)
 
1347
                    result, changes = self._changes_from_entries(
 
1348
                        old_entry, new_entry)
 
1349
                else:
 
1350
                    changes = True
 
1351
                # Get this parents parent to examine.
 
1352
                new_parent_id = result[4][1]
 
1353
                precise_file_ids.add(new_parent_id)
 
1354
                if changes:
 
1355
                    if (result[6][0] == 'directory' and
 
1356
                        result[6][1] != 'directory'):
 
1357
                        # This stopped being a directory, the old children have
 
1358
                        # to be included.
 
1359
                        if old_entry is None:
 
1360
                            # Reusing a discarded change.
 
1361
                            old_entry = self._get_entry(self.source, file_id)
 
1362
                        precise_file_ids.update(
 
1363
                                self.source.iter_children(file_id))
 
1364
                    changed_file_ids.add(result[0])
 
1365
                    yield result
 
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)
985
1403
 
986
1404
 
987
1405
class MultiWalker(object):
1091
1509
            return (None, None)
1092
1510
        else:
1093
1511
            self._out_of_order_processed.add(file_id)
1094
 
            cur_ie = other_tree.inventory[file_id]
 
1512
            cur_ie = other_tree.root_inventory[file_id]
1095
1513
            return (cur_path, cur_ie)
1096
1514
 
1097
1515
    def iter_all(self):
1104
1522
 
1105
1523
    def _walk_master_tree(self):
1106
1524
        """First pass, walk all trees in lock-step.
1107
 
        
 
1525
 
1108
1526
        When we are done, all nodes in the master_tree will have been
1109
1527
        processed. _other_walkers, _other_entries, and _others_extra will be
1110
1528
        set on 'self' for future processing.