← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

(jameinel) Allow 'bzr serve' to interpret SIGHUP as a graceful shutdown.
 (bug #795025) (John A Meinel)

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
20
import os
21
 
from collections import deque
22
 
from cStringIO import StringIO
23
 
 
24
 
import bzrlib
 
21
 
 
22
from bzrlib.lazy_import import lazy_import
 
23
lazy_import(globals(), """
 
24
import collections
 
25
 
25
26
from bzrlib import (
26
27
    conflicts as _mod_conflicts,
 
28
    debug,
27
29
    delta,
 
30
    errors,
 
31
    filters,
 
32
    inventory,
28
33
    osutils,
29
34
    revision as _mod_revision,
30
35
    rules,
31
 
    symbol_versioning,
 
36
    trace,
32
37
    )
 
38
from bzrlib.i18n import gettext
 
39
""")
 
40
 
33
41
from bzrlib.decorators import needs_read_lock
34
 
from bzrlib.errors import BzrError, BzrCheckError, NoSuchId
35
 
from bzrlib import errors
36
 
from bzrlib.inventory import Inventory, InventoryFile
37
42
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
 
43
from bzrlib.symbol_versioning import (
 
44
    deprecated_in,
 
45
    deprecated_method,
 
46
    )
42
47
 
43
48
 
44
49
class Tree(object):
45
50
    """Abstract file tree.
46
51
 
47
52
    There are several subclasses:
48
 
    
 
53
 
49
54
    * `WorkingTree` exists as files on disk editable by the user.
50
55
 
51
56
    * `RevisionTree` is a tree as recorded at some point in the past.
52
57
 
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
58
    Trees can be compared, etc, regardless of whether they are working
61
59
    trees or versioned trees.
62
60
    """
63
 
    
 
61
 
 
62
    def has_versioned_directories(self):
 
63
        """Whether this tree can contain explicitly versioned directories.
 
64
 
 
65
        This defaults to True, but some implementations may want to override
 
66
        it.
 
67
        """
 
68
        return True
 
69
 
64
70
    def changes_from(self, other, want_unchanged=False, specific_files=None,
65
71
        extra_trees=None, require_versioned=False, include_root=False,
66
72
        want_unversioned=False):
80
86
            a PathsNotVersionedError will be thrown.
81
87
        :param want_unversioned: Scan for unversioned paths.
82
88
 
83
 
        The comparison will be performed by an InterTree object looked up on 
 
89
        The comparison will be performed by an InterTree object looked up on
84
90
        self and other.
85
91
        """
86
92
        # Martin observes that Tree.changes_from returns a TreeDelta and this
95
101
            want_unversioned=want_unversioned,
96
102
            )
97
103
 
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
104
    def iter_changes(self, from_tree, include_unchanged=False,
103
105
                     specific_files=None, pb=None, extra_trees=None,
104
106
                     require_versioned=True, want_unversioned=False):
 
107
        """See InterTree.iter_changes"""
105
108
        intertree = InterTree.get(from_tree, self)
106
109
        return intertree.iter_changes(include_unchanged, specific_files, pb,
107
110
            extra_trees, require_versioned, want_unversioned=want_unversioned)
108
 
    
 
111
 
109
112
    def conflicts(self):
110
113
        """Get a list of the conflicts in the tree.
111
114
 
118
121
        return []
119
122
 
120
123
    def get_parent_ids(self):
121
 
        """Get the parent ids for this tree. 
 
124
        """Get the parent ids for this tree.
122
125
 
123
126
        :return: a list of parent ids. [] is returned to indicate
124
127
        a tree with no parents.
125
128
        :raises: BzrError if the parents are not known.
126
129
        """
127
130
        raise NotImplementedError(self.get_parent_ids)
128
 
    
 
131
 
129
132
    def has_filename(self, filename):
130
133
        """True if the tree has given filename."""
131
134
        raise NotImplementedError(self.has_filename)
132
135
 
133
136
    def has_id(self, file_id):
134
 
        return self.inventory.has_id(file_id)
 
137
        raise NotImplementedError(self.has_id)
135
138
 
 
139
    @deprecated_method(deprecated_in((2, 4, 0)))
136
140
    def __contains__(self, file_id):
137
141
        return self.has_id(file_id)
138
142
 
139
143
    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)
 
144
        raise NotImplementedError(self.has_or_had_id)
143
145
 
144
146
    def is_ignored(self, filename):
145
147
        """Check whether the filename is ignored by this tree.
149
151
        """
150
152
        return False
151
153
 
152
 
    def __iter__(self):
153
 
        return iter(self.inventory)
154
 
 
155
154
    def all_file_ids(self):
156
155
        """Iterate through all file ids, including ids for missing files."""
157
 
        return set(self.inventory)
 
156
        raise NotImplementedError(self.all_file_ids)
158
157
 
159
158
    def id2path(self, file_id):
160
159
        """Return the path for a file id.
161
160
 
162
161
        :raises NoSuchId:
163
162
        """
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):
 
163
        raise NotImplementedError(self.id2path)
 
164
 
 
165
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
180
166
        """Walk the tree in 'by_dir' order.
181
167
 
182
168
        This will yield each entry in the tree as a (path, entry) tuple.
198
184
             g
199
185
 
200
186
        The yield order (ignoring root) would be::
 
187
 
201
188
          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)
 
189
 
 
190
        :param yield_parents: If True, yield the parents from the root leading
 
191
            down to specific_file_ids that have been requested. This has no
 
192
            impact if specific_file_ids is None.
 
193
        """
 
194
        raise NotImplementedError(self.iter_entries_by_dir)
 
195
 
 
196
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
197
        """List all files in this tree.
 
198
 
 
199
        :param include_root: Whether to include the entry for the tree root
 
200
        :param from_dir: Directory under which to list files
 
201
        :param recursive: Whether to list files recursively
 
202
        :return: iterator over tuples of (path, versioned, kind, file_id,
 
203
            inventory entry)
 
204
        """
 
205
        raise NotImplementedError(self.list_files)
205
206
 
206
207
    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
 
208
        if self.supports_tree_reference():
 
209
            for path, entry in self.iter_entries_by_dir():
 
210
                if entry.kind == 'tree-reference':
 
211
                    yield path, entry.file_id
210
212
 
211
213
    def kind(self, file_id):
212
214
        raise NotImplementedError("Tree subclass %s must implement kind"
222
224
 
223
225
    def path_content_summary(self, path):
224
226
        """Get a summary of the information about path.
225
 
        
 
227
 
 
228
        All the attributes returned are for the canonical form, not the
 
229
        convenient form (if content filters are in use.)
 
230
 
226
231
        :param path: A relative path within the tree.
227
232
        :return: A tuple containing kind, size, exec, sha1-or-link.
228
233
            Kind is always present (see tree.kind()).
229
 
            size is present if kind is file, None otherwise.
 
234
            size is present if kind is file and the size of the 
 
235
                canonical form can be cheaply determined, None otherwise.
230
236
            exec is None unless kind is file and the platform supports the 'x'
231
237
                bit.
232
238
            sha1-or-link is the link target if kind is symlink, or the sha1 if
253
259
    def _file_size(self, entry, stat_value):
254
260
        raise NotImplementedError(self._file_size)
255
261
 
256
 
    def _get_inventory(self):
257
 
        return self._inventory
258
 
    
259
262
    def get_file(self, file_id, path=None):
260
263
        """Return a file object for the file file_id in the tree.
261
 
        
 
264
 
262
265
        If both file_id and path are defined, it is implementation defined as
263
266
        to which one is used.
264
267
        """
265
268
        raise NotImplementedError(self.get_file)
266
269
 
 
270
    def get_file_with_stat(self, file_id, path=None):
 
271
        """Get a file handle and stat object for file_id.
 
272
 
 
273
        The default implementation returns (self.get_file, None) for backwards
 
274
        compatibility.
 
275
 
 
276
        :param file_id: The file id to read.
 
277
        :param path: The path of the file, if it is known.
 
278
        :return: A tuple (file_handle, stat_value_or_None). If the tree has
 
279
            no stat facility, or need for a stat cache feedback during commit,
 
280
            it may return None for the second element of the tuple.
 
281
        """
 
282
        return (self.get_file(file_id, path), None)
 
283
 
267
284
    def get_file_text(self, file_id, path=None):
268
285
        """Return the byte content of a file.
269
286
 
270
287
        :param file_id: The file_id of the file.
271
288
        :param path: The path of the file.
 
289
 
272
290
        If both file_id and path are supplied, an implementation may use
273
291
        either one.
 
292
 
 
293
        :returns: A single byte string for the whole file.
274
294
        """
275
295
        my_file = self.get_file(file_id, path)
276
296
        try:
283
303
 
284
304
        :param file_id: The file_id of the file.
285
305
        :param path: The path of the file.
 
306
 
286
307
        If both file_id and path are supplied, an implementation may use
287
308
        either one.
288
309
        """
289
310
        return osutils.split_lines(self.get_file_text(file_id, path))
290
311
 
 
312
    def get_file_verifier(self, file_id, path=None, stat_value=None):
 
313
        """Return a verifier for a file.
 
314
 
 
315
        The default implementation returns a sha1.
 
316
 
 
317
        :param file_id: The handle for this file.
 
318
        :param path: The path that this file can be found at.
 
319
            These must point to the same object.
 
320
        :param stat_value: Optional stat value for the object
 
321
        :return: Tuple with verifier name and verifier data
 
322
        """
 
323
        return ("SHA1", self.get_file_sha1(file_id, path=path,
 
324
            stat_value=stat_value))
 
325
 
 
326
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
327
        """Return the SHA1 file for a file.
 
328
 
 
329
        :note: callers should use get_file_verifier instead
 
330
            where possible, as the underlying repository implementation may
 
331
            have quicker access to a non-sha1 verifier.
 
332
 
 
333
        :param file_id: The handle for this file.
 
334
        :param path: The path that this file can be found at.
 
335
            These must point to the same object.
 
336
        :param stat_value: Optional stat value for the object
 
337
        """
 
338
        raise NotImplementedError(self.get_file_sha1)
 
339
 
291
340
    def get_file_mtime(self, file_id, path=None):
292
341
        """Return the modification time for a file.
293
342
 
307
356
        raise NotImplementedError(self.get_file_size)
308
357
 
309
358
    def get_file_by_path(self, path):
310
 
        return self.get_file(self._inventory.path2id(path), path)
 
359
        raise NotImplementedError(self.get_file_by_path)
 
360
 
 
361
    def is_executable(self, file_id, path=None):
 
362
        """Check if a file is executable.
 
363
 
 
364
        :param file_id: The handle for this file.
 
365
        :param path: The path that this file can be found at.
 
366
            These must point to the same object.
 
367
        """
 
368
        raise NotImplementedError(self.is_executable)
311
369
 
312
370
    def iter_files_bytes(self, desired_files):
313
371
        """Iterate through file contents.
335
393
            cur_file = (self.get_file_text(file_id),)
336
394
            yield identifier, cur_file
337
395
 
338
 
    def get_symlink_target(self, file_id):
 
396
    def get_symlink_target(self, file_id, path=None):
339
397
        """Get the target for a given file_id.
340
398
 
341
399
        It is assumed that the caller already knows that file_id is referencing
342
400
        a symlink.
343
401
        :param file_id: Handle for the symlink entry.
 
402
        :param path: The path of the file.
 
403
        If both file_id and path are supplied, an implementation may use
 
404
        either one.
344
405
        :return: The path the symlink points to.
345
406
        """
346
407
        raise NotImplementedError(self.get_symlink_target)
347
408
 
348
 
    def get_canonical_inventory_paths(self, paths):
349
 
        """Like get_canonical_inventory_path() but works on multiple items.
350
 
 
351
 
        :param paths: A sequence of paths relative to the root of the tree.
352
 
        :return: A list of paths, with each item the corresponding input path
353
 
        adjusted to account for existing elements that match case
354
 
        insensitively.
355
 
        """
356
 
        return list(self._yield_canonical_inventory_paths(paths))
357
 
 
358
 
    def get_canonical_inventory_path(self, path):
359
 
        """Returns the first inventory item that case-insensitively matches path.
360
 
 
361
 
        If a path matches exactly, it is returned. If no path matches exactly
362
 
        but more than one path matches case-insensitively, it is implementation
363
 
        defined which is returned.
364
 
 
365
 
        If no path matches case-insensitively, the input path is returned, but
366
 
        with as many path entries that do exist changed to their canonical
367
 
        form.
368
 
 
369
 
        If you need to resolve many names from the same tree, you should
370
 
        use get_canonical_inventory_paths() to avoid O(N) behaviour.
371
 
 
372
 
        :param path: A paths relative to the root of the tree.
373
 
        :return: The input path adjusted to account for existing elements
374
 
        that match case insensitively.
375
 
        """
376
 
        return self._yield_canonical_inventory_paths([path]).next()
377
 
 
378
 
    def _yield_canonical_inventory_paths(self, paths):
379
 
        for path in paths:
380
 
            # First, if the path as specified exists exactly, just use it.
381
 
            if self.path2id(path) is not None:
382
 
                yield path
383
 
                continue
384
 
            # go walkin...
385
 
            cur_id = self.get_root_id()
386
 
            cur_path = ''
387
 
            bit_iter = iter(path.split("/"))
388
 
            for elt in bit_iter:
389
 
                lelt = elt.lower()
390
 
                for child in self.iter_children(cur_id):
391
 
                    try:
392
 
                        child_base = os.path.basename(self.id2path(child))
393
 
                        if child_base.lower() == lelt:
394
 
                            cur_id = child
395
 
                            cur_path = osutils.pathjoin(cur_path, child_base)
396
 
                            break
397
 
                    except NoSuchId:
398
 
                        # before a change is committed we can see this error...
399
 
                        continue
400
 
                else:
401
 
                    # got to the end of this directory and no entries matched.
402
 
                    # Return what matched so far, plus the rest as specified.
403
 
                    cur_path = osutils.pathjoin(cur_path, elt, *list(bit_iter))
404
 
                    break
405
 
            yield cur_path
406
 
        # all done.
407
 
 
408
409
    def get_root_id(self):
409
410
        """Return the file_id for the root of this tree."""
410
411
        raise NotImplementedError(self.get_root_id)
424
425
        raise NotImplementedError(self.annotate_iter)
425
426
 
426
427
    def _get_plan_merge_data(self, file_id, other, base):
427
 
        from bzrlib import merge, versionedfile
 
428
        from bzrlib import versionedfile
428
429
        vf = versionedfile._PlanMergeVersionedFile(file_id)
429
430
        last_revision_a = self._get_file_revision(file_id, vf, 'this:')
430
431
        last_revision_b = other._get_file_revision(file_id, vf, 'other:')
468
469
            except errors.NoSuchRevisionInTree:
469
470
                yield self.repository.revision_tree(revision_id)
470
471
 
471
 
    @staticmethod
472
 
    def _file_revision(revision_tree, file_id):
473
 
        """Determine the revision associated with a file in a given tree."""
474
 
        revision_tree.lock_read()
475
 
        try:
476
 
            return revision_tree.inventory[file_id].revision
477
 
        finally:
478
 
            revision_tree.unlock()
479
 
 
480
472
    def _get_file_revision(self, file_id, vf, tree_revision):
481
473
        """Ensure that file_id, tree_revision is in vf to plan the merge."""
482
474
 
483
475
        if getattr(self, '_repository', None) is None:
484
476
            last_revision = tree_revision
485
 
            parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
 
477
            parent_keys = [(file_id, t.get_file_revision(file_id)) for t in
486
478
                self._iter_parent_trees()]
487
479
            vf.add_lines((file_id, last_revision), parent_keys,
488
 
                         self.get_file(file_id).readlines())
 
480
                         self.get_file_lines(file_id))
489
481
            repo = self.branch.repository
490
482
            base_vf = repo.texts
491
483
        else:
492
 
            last_revision = self._file_revision(self, file_id)
 
484
            last_revision = self.get_file_revision(file_id)
493
485
            base_vf = self._repository.texts
494
486
        if base_vf not in vf.fallback_versionedfiles:
495
487
            vf.fallback_versionedfiles.append(base_vf)
496
488
        return last_revision
497
489
 
498
 
    inventory = property(_get_inventory,
499
 
                         doc="Inventory of this Tree")
500
 
 
501
490
    def _check_retrieved(self, ie, f):
502
491
        if not __debug__:
503
 
            return  
504
 
        fp = fingerprint_file(f)
 
492
            return
 
493
        fp = osutils.fingerprint_file(f)
505
494
        f.seek(0)
506
 
        
 
495
 
507
496
        if ie.text_size is not None:
508
497
            if ie.text_size != fp['size']:
509
 
                raise BzrError("mismatched size for file %r in %r" % (ie.file_id, self._store),
 
498
                raise errors.BzrError(
 
499
                        "mismatched size for file %r in %r" %
 
500
                        (ie.file_id, self._store),
510
501
                        ["inventory expects %d bytes" % ie.text_size,
511
502
                         "file is actually %d bytes" % fp['size'],
512
503
                         "store is probably damaged/corrupt"])
513
504
 
514
505
        if ie.text_sha1 != fp['sha1']:
515
 
            raise BzrError("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
 
506
            raise errors.BzrError("wrong SHA-1 for file %r in %r" %
 
507
                    (ie.file_id, self._store),
516
508
                    ["inventory expects %s" % ie.text_sha1,
517
509
                     "file is actually %s" % fp['sha1'],
518
510
                     "store is probably damaged/corrupt"])
519
511
 
520
 
    @needs_read_lock
521
512
    def path2id(self, path):
522
513
        """Return the id for path in this tree."""
523
 
        return self._inventory.path2id(path)
 
514
        raise NotImplementedError(self.path2id)
524
515
 
525
516
    def paths2ids(self, paths, trees=[], require_versioned=True):
526
517
        """Return all the ids that can be reached by walking from paths.
527
 
        
 
518
 
528
519
        Each path is looked up in this tree and any extras provided in
529
520
        trees, and this is repeated recursively: the children in an extra tree
530
521
        of a directory that has been renamed under a provided path in this tree
546
537
        for child in getattr(entry, 'children', {}).itervalues():
547
538
            yield child.file_id
548
539
 
549
 
    @symbol_versioning.deprecated_method(symbol_versioning.one_six)
550
 
    def print_file(self, file_id):
551
 
        """Print file with id `file_id` to stdout."""
552
 
        import sys
553
 
        sys.stdout.write(self.get_file_text(file_id))
554
 
 
555
540
    def lock_read(self):
 
541
        """Lock this tree for multiple read only operations.
 
542
        
 
543
        :return: A bzrlib.lock.LogicalLockResult.
 
544
        """
556
545
        pass
557
546
 
558
547
    def revision_tree(self, revision_id):
560
549
 
561
550
        The intention of this method is to allow access to possibly cached
562
551
        tree data. Implementors of this method should raise NoSuchRevision if
563
 
        the tree is not locally available, even if they could obtain the 
564
 
        tree via a repository or some other means. Callers are responsible 
 
552
        the tree is not locally available, even if they could obtain the
 
553
        tree via a repository or some other means. Callers are responsible
565
554
        for finding the ultimate source for a revision tree.
566
555
 
567
556
        :param revision_id: The revision_id of the requested tree.
572
561
 
573
562
    def unknowns(self):
574
563
        """What files are present in this tree and unknown.
575
 
        
 
564
 
576
565
        :return: an iterator over the unknown files.
577
566
        """
578
567
        return iter([])
585
574
 
586
575
        :return: set of paths.
587
576
        """
588
 
        # NB: we specifically *don't* call self.has_filename, because for
589
 
        # WorkingTrees that can indicate files that exist on disk but that 
590
 
        # are not versioned.
591
 
        pred = self.inventory.has_filename
592
 
        return set((p for p in paths if not pred(p)))
 
577
        raise NotImplementedError(self.filter_unversioned_files)
593
578
 
594
579
    def walkdirs(self, prefix=""):
595
580
        """Walk the contents of this tree from path down.
597
582
        This yields all the data about the contents of a directory at a time.
598
583
        After each directory has been yielded, if the caller has mutated the
599
584
        list to exclude some directories, they are then not descended into.
600
 
        
 
585
 
601
586
        The data yielded is of the form:
602
587
        ((directory-relpath, directory-path-from-root, directory-fileid),
603
 
        [(relpath, basename, kind, lstat, path_from_tree_root, file_id, 
 
588
        [(relpath, basename, kind, lstat, path_from_tree_root, file_id,
604
589
          versioned_kind), ...]),
605
590
         - directory-relpath is the containing dirs relpath from prefix
606
591
         - directory-path-from-root is the containing dirs path from /
613
598
         - lstat is the stat data *if* the file was statted.
614
599
         - path_from_tree_root is the path from the root of the tree.
615
600
         - file_id is the file_id if the entry is versioned.
616
 
         - versioned_kind is the kind of the file as last recorded in the 
 
601
         - versioned_kind is the kind of the file as last recorded in the
617
602
           versioning system. If 'unknown' the file is not versioned.
618
603
        One of 'kind' and 'versioned_kind' must not be 'unknown'.
619
604
 
627
612
    def supports_content_filtering(self):
628
613
        return False
629
614
 
 
615
    def _content_filter_stack(self, path=None, file_id=None):
 
616
        """The stack of content filters for a path if filtering is supported.
 
617
 
 
618
        Readers will be applied in first-to-last order.
 
619
        Writers will be applied in last-to-first order.
 
620
        Either the path or the file-id needs to be provided.
 
621
 
 
622
        :param path: path relative to the root of the tree
 
623
            or None if unknown
 
624
        :param file_id: file_id or None if unknown
 
625
        :return: the list of filters - [] if there are none
 
626
        """
 
627
        filter_pref_names = filters._get_registered_names()
 
628
        if len(filter_pref_names) == 0:
 
629
            return []
 
630
        if path is None:
 
631
            path = self.id2path(file_id)
 
632
        prefs = self.iter_search_rules([path], filter_pref_names).next()
 
633
        stk = filters._get_filter_stack_for(prefs)
 
634
        if 'filters' in debug.debug_flags:
 
635
            trace.note(gettext("*** {0} content-filter: {1} => {2!r}").format(path,prefs,stk))
 
636
        return stk
 
637
 
 
638
    def _content_filter_stack_provider(self):
 
639
        """A function that returns a stack of ContentFilters.
 
640
 
 
641
        The function takes a path (relative to the top of the tree) and a
 
642
        file-id as parameters.
 
643
 
 
644
        :return: None if content filtering is not supported by this tree.
 
645
        """
 
646
        if self.supports_content_filtering():
 
647
            return lambda path, file_id: \
 
648
                    self._content_filter_stack(path, file_id)
 
649
        else:
 
650
            return None
 
651
 
630
652
    def iter_search_rules(self, path_names, pref_names=None,
631
 
        _default_searcher=rules._per_user_searcher):
 
653
        _default_searcher=None):
632
654
        """Find the preferences for filenames in a tree.
633
655
 
634
656
        :param path_names: an iterable of paths to find attributes for.
638
660
        :return: an iterator of tuple sequences, one per path-name.
639
661
          See _RulesSearcher.get_items for details on the tuple sequence.
640
662
        """
 
663
        if _default_searcher is None:
 
664
            _default_searcher = rules._per_user_searcher
641
665
        searcher = self._get_rules_searcher(_default_searcher)
642
666
        if searcher is not None:
643
667
            if pref_names is not None:
647
671
                for path in path_names:
648
672
                    yield searcher.get_items(path)
649
673
 
650
 
    @needs_read_lock
651
674
    def _get_rules_searcher(self, default_searcher):
652
675
        """Get the RulesSearcher for this tree given the default one."""
653
676
        searcher = default_searcher
654
677
        return searcher
655
678
 
656
679
 
657
 
class EmptyTree(Tree):
658
 
 
659
 
    def __init__(self):
660
 
        self._inventory = Inventory(root_id=None)
661
 
        symbol_versioning.warn('EmptyTree is deprecated as of bzr 0.9 please'
662
 
                               ' use repository.revision_tree instead.',
663
 
                               DeprecationWarning, stacklevel=2)
664
 
 
665
 
    def get_parent_ids(self):
666
 
        return []
667
 
 
668
 
    def get_symlink_target(self, file_id):
669
 
        return None
670
 
 
671
 
    def has_filename(self, filename):
672
 
        return False
673
 
 
674
 
    def kind(self, file_id):
675
 
        return "directory"
676
 
 
677
 
    def list_files(self, include_root=False):
678
 
        return iter([])
679
 
    
680
 
    def __contains__(self, file_id):
681
 
        return (file_id in self._inventory)
682
 
 
683
 
    def get_file_sha1(self, file_id, path=None, stat_value=None):
684
 
        return None
685
 
 
686
 
 
687
 
######################################################################
688
 
# diff
689
 
 
690
 
# TODO: Merge these two functions into a single one that can operate
691
 
# on either a whole tree or a set of files.
692
 
 
693
 
# TODO: Return the diff in order by filename, not by category or in
694
 
# random order.  Can probably be done by lock-stepping through the
695
 
# filenames from both trees.
696
 
 
697
 
 
698
 
def file_status(filename, old_tree, new_tree):
699
 
    """Return single-letter status, old and new names for a file.
700
 
 
701
 
    The complexity here is in deciding how to represent renames;
702
 
    many complex cases are possible.
 
680
class InventoryTree(Tree):
 
681
    """A tree that relies on an inventory for its metadata.
 
682
 
 
683
    Trees contain an `Inventory` object, and also know how to retrieve
 
684
    file texts mentioned in the inventory, either from a working
 
685
    directory or from a store.
 
686
 
 
687
    It is possible for trees to contain files that are not described
 
688
    in their inventory or vice versa; for this use `filenames()`.
 
689
 
 
690
    Subclasses should set the _inventory attribute, which is considered
 
691
    private to external API users.
703
692
    """
704
 
    old_inv = old_tree.inventory
705
 
    new_inv = new_tree.inventory
706
 
    new_id = new_inv.path2id(filename)
707
 
    old_id = old_inv.path2id(filename)
708
 
 
709
 
    if not new_id and not old_id:
710
 
        # easy: doesn't exist in either; not versioned at all
711
 
        if new_tree.is_ignored(filename):
712
 
            return 'I', None, None
713
 
        else:
714
 
            return '?', None, None
715
 
    elif new_id:
716
 
        # There is now a file of this name, great.
717
 
        pass
718
 
    else:
719
 
        # There is no longer a file of this name, but we can describe
720
 
        # what happened to the file that used to have
721
 
        # this name.  There are two possibilities: either it was
722
 
        # deleted entirely, or renamed.
723
 
        if new_inv.has_id(old_id):
724
 
            return 'X', old_inv.id2path(old_id), new_inv.id2path(old_id)
725
 
        else:
726
 
            return 'D', old_inv.id2path(old_id), None
727
 
 
728
 
    # if the file_id is new in this revision, it is added
729
 
    if new_id and not old_inv.has_id(new_id):
730
 
        return 'A'
731
 
 
732
 
    # if there used to be a file of this name, but that ID has now
733
 
    # disappeared, it is deleted
734
 
    if old_id and not new_inv.has_id(old_id):
735
 
        return 'D'
736
 
 
737
 
    return 'wtf?'
738
 
 
739
 
    
740
 
@deprecated_function(deprecated_in((1, 9, 0)))
741
 
def find_renames(old_inv, new_inv):
742
 
    for file_id in old_inv:
743
 
        if file_id not in new_inv:
744
 
            continue
745
 
        old_name = old_inv.id2path(file_id)
746
 
        new_name = new_inv.id2path(file_id)
747
 
        if old_name != new_name:
748
 
            yield (old_name, new_name)
 
693
 
 
694
    def get_canonical_inventory_paths(self, paths):
 
695
        """Like get_canonical_inventory_path() but works on multiple items.
 
696
 
 
697
        :param paths: A sequence of paths relative to the root of the tree.
 
698
        :return: A list of paths, with each item the corresponding input path
 
699
        adjusted to account for existing elements that match case
 
700
        insensitively.
 
701
        """
 
702
        return list(self._yield_canonical_inventory_paths(paths))
 
703
 
 
704
    def get_canonical_inventory_path(self, path):
 
705
        """Returns the first inventory item that case-insensitively matches path.
 
706
 
 
707
        If a path matches exactly, it is returned. If no path matches exactly
 
708
        but more than one path matches case-insensitively, it is implementation
 
709
        defined which is returned.
 
710
 
 
711
        If no path matches case-insensitively, the input path is returned, but
 
712
        with as many path entries that do exist changed to their canonical
 
713
        form.
 
714
 
 
715
        If you need to resolve many names from the same tree, you should
 
716
        use get_canonical_inventory_paths() to avoid O(N) behaviour.
 
717
 
 
718
        :param path: A paths relative to the root of the tree.
 
719
        :return: The input path adjusted to account for existing elements
 
720
        that match case insensitively.
 
721
        """
 
722
        return self._yield_canonical_inventory_paths([path]).next()
 
723
 
 
724
    def _yield_canonical_inventory_paths(self, paths):
 
725
        for path in paths:
 
726
            # First, if the path as specified exists exactly, just use it.
 
727
            if self.path2id(path) is not None:
 
728
                yield path
 
729
                continue
 
730
            # go walkin...
 
731
            cur_id = self.get_root_id()
 
732
            cur_path = ''
 
733
            bit_iter = iter(path.split("/"))
 
734
            for elt in bit_iter:
 
735
                lelt = elt.lower()
 
736
                new_path = None
 
737
                for child in self.iter_children(cur_id):
 
738
                    try:
 
739
                        # XXX: it seem like if the child is known to be in the
 
740
                        # tree, we shouldn't need to go from its id back to
 
741
                        # its path -- mbp 2010-02-11
 
742
                        #
 
743
                        # XXX: it seems like we could be more efficient
 
744
                        # by just directly looking up the original name and
 
745
                        # only then searching all children; also by not
 
746
                        # chopping paths so much. -- mbp 2010-02-11
 
747
                        child_base = os.path.basename(self.id2path(child))
 
748
                        if (child_base == elt):
 
749
                            # if we found an exact match, we can stop now; if
 
750
                            # we found an approximate match we need to keep
 
751
                            # searching because there might be an exact match
 
752
                            # later.  
 
753
                            cur_id = child
 
754
                            new_path = osutils.pathjoin(cur_path, child_base)
 
755
                            break
 
756
                        elif child_base.lower() == lelt:
 
757
                            cur_id = child
 
758
                            new_path = osutils.pathjoin(cur_path, child_base)
 
759
                    except errors.NoSuchId:
 
760
                        # before a change is committed we can see this error...
 
761
                        continue
 
762
                if new_path:
 
763
                    cur_path = new_path
 
764
                else:
 
765
                    # got to the end of this directory and no entries matched.
 
766
                    # Return what matched so far, plus the rest as specified.
 
767
                    cur_path = osutils.pathjoin(cur_path, elt, *list(bit_iter))
 
768
                    break
 
769
            yield cur_path
 
770
        # all done.
 
771
 
 
772
    def _get_inventory(self):
 
773
        return self._inventory
 
774
 
 
775
    inventory = property(_get_inventory,
 
776
                         doc="Inventory of this Tree")
 
777
 
 
778
    @needs_read_lock
 
779
    def path2id(self, path):
 
780
        """Return the id for path in this tree."""
 
781
        return self._inventory.path2id(path)
 
782
 
 
783
    def id2path(self, file_id):
 
784
        """Return the path for a file id.
 
785
 
 
786
        :raises NoSuchId:
 
787
        """
 
788
        return self.inventory.id2path(file_id)
 
789
 
 
790
    def has_id(self, file_id):
 
791
        return self.inventory.has_id(file_id)
 
792
 
 
793
    def has_or_had_id(self, file_id):
 
794
        return self.inventory.has_id(file_id)
 
795
 
 
796
    def all_file_ids(self):
 
797
        return set(self.inventory)
 
798
 
 
799
    @deprecated_method(deprecated_in((2, 4, 0)))
 
800
    def __iter__(self):
 
801
        return iter(self.inventory)
 
802
 
 
803
    def filter_unversioned_files(self, paths):
 
804
        """Filter out paths that are versioned.
 
805
 
 
806
        :return: set of paths.
 
807
        """
 
808
        # NB: we specifically *don't* call self.has_filename, because for
 
809
        # WorkingTrees that can indicate files that exist on disk but that
 
810
        # are not versioned.
 
811
        pred = self.inventory.has_filename
 
812
        return set((p for p in paths if not pred(p)))
 
813
 
 
814
    @needs_read_lock
 
815
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
 
816
        """Walk the tree in 'by_dir' order.
 
817
 
 
818
        This will yield each entry in the tree as a (path, entry) tuple.
 
819
        The order that they are yielded is:
 
820
 
 
821
        See Tree.iter_entries_by_dir for details.
 
822
 
 
823
        :param yield_parents: If True, yield the parents from the root leading
 
824
            down to specific_file_ids that have been requested. This has no
 
825
            impact if specific_file_ids is None.
 
826
        """
 
827
        return self.inventory.iter_entries_by_dir(
 
828
            specific_file_ids=specific_file_ids, yield_parents=yield_parents)
 
829
 
 
830
    def get_file_by_path(self, path):
 
831
        return self.get_file(self._inventory.path2id(path), path)
749
832
 
750
833
 
751
834
def find_ids_across_trees(filenames, trees, require_versioned=True):
752
835
    """Find the ids corresponding to specified filenames.
753
 
    
 
836
 
754
837
    All matches in all trees will be used, and all children of matched
755
838
    directories will be used.
756
839
 
758
841
        None)
759
842
    :param trees: The trees to find file_ids within
760
843
    :param require_versioned: if true, all specified filenames must occur in
761
 
    at least one tree.
 
844
        at least one tree.
762
845
    :return: a set of file ids for the specified filenames and their children.
763
846
    """
764
847
    if not filenames:
770
853
 
771
854
def _find_ids_across_trees(filenames, trees, require_versioned):
772
855
    """Find the ids corresponding to specified filenames.
773
 
    
 
856
 
774
857
    All matches in all trees will be used, but subdirectories are not scanned.
775
858
 
776
859
    :param filenames: The filenames to find file_ids for
797
880
 
798
881
def _find_children_across_trees(specified_ids, trees):
799
882
    """Return a set including specified ids and their children.
800
 
    
 
883
 
801
884
    All matches in all trees will be used.
802
885
 
803
886
    :param trees: The trees to find file_ids within
804
 
    :return: a set containing all specified ids and their children 
 
887
    :return: a set containing all specified ids and their children
805
888
    """
806
889
    interesting_ids = set(specified_ids)
807
890
    pending = interesting_ids
811
894
        new_pending = set()
812
895
        for file_id in pending:
813
896
            for tree in trees:
814
 
                if not tree.has_id(file_id):
 
897
                if not tree.has_or_had_id(file_id):
815
898
                    continue
816
899
                for child_id in tree.iter_children(file_id):
817
900
                    if child_id not in interesting_ids:
832
915
    will pass through to InterTree as appropriate.
833
916
    """
834
917
 
 
918
    # Formats that will be used to test this InterTree. If both are
 
919
    # None, this InterTree will not be tested (e.g. because a complex
 
920
    # setup is required)
 
921
    _matching_from_tree_format = None
 
922
    _matching_to_tree_format = None
 
923
 
835
924
    _optimisers = []
836
925
 
 
926
    @classmethod
 
927
    def is_compatible(kls, source, target):
 
928
        # The default implementation is naive and uses the public API, so
 
929
        # it works for all trees.
 
930
        return True
 
931
 
 
932
    def _changes_from_entries(self, source_entry, target_entry,
 
933
        source_path=None, target_path=None):
 
934
        """Generate a iter_changes tuple between source_entry and target_entry.
 
935
 
 
936
        :param source_entry: An inventory entry from self.source, or None.
 
937
        :param target_entry: An inventory entry from self.target, or None.
 
938
        :param source_path: The path of source_entry, if known. If not known
 
939
            it will be looked up.
 
940
        :param target_path: The path of target_entry, if known. If not known
 
941
            it will be looked up.
 
942
        :return: A tuple, item 0 of which is an iter_changes result tuple, and
 
943
            item 1 is True if there are any changes in the result tuple.
 
944
        """
 
945
        if source_entry is None:
 
946
            if target_entry is None:
 
947
                return None
 
948
            file_id = target_entry.file_id
 
949
        else:
 
950
            file_id = source_entry.file_id
 
951
        if source_entry is not None:
 
952
            source_versioned = True
 
953
            source_name = source_entry.name
 
954
            source_parent = source_entry.parent_id
 
955
            if source_path is None:
 
956
                source_path = self.source.id2path(file_id)
 
957
            source_kind, source_executable, source_stat = \
 
958
                self.source._comparison_data(source_entry, source_path)
 
959
        else:
 
960
            source_versioned = False
 
961
            source_name = None
 
962
            source_parent = None
 
963
            source_kind = None
 
964
            source_executable = None
 
965
        if target_entry is not None:
 
966
            target_versioned = True
 
967
            target_name = target_entry.name
 
968
            target_parent = target_entry.parent_id
 
969
            if target_path is None:
 
970
                target_path = self.target.id2path(file_id)
 
971
            target_kind, target_executable, target_stat = \
 
972
                self.target._comparison_data(target_entry, target_path)
 
973
        else:
 
974
            target_versioned = False
 
975
            target_name = None
 
976
            target_parent = None
 
977
            target_kind = None
 
978
            target_executable = None
 
979
        versioned = (source_versioned, target_versioned)
 
980
        kind = (source_kind, target_kind)
 
981
        changed_content = False
 
982
        if source_kind != target_kind:
 
983
            changed_content = True
 
984
        elif source_kind == 'file':
 
985
            if not self.file_content_matches(file_id, file_id, source_path,
 
986
                    target_path, source_stat, target_stat):
 
987
                changed_content = True
 
988
        elif source_kind == 'symlink':
 
989
            if (self.source.get_symlink_target(file_id) !=
 
990
                self.target.get_symlink_target(file_id)):
 
991
                changed_content = True
 
992
            # XXX: Yes, the indentation below is wrong. But fixing it broke
 
993
            # test_merge.TestMergerEntriesLCAOnDisk.
 
994
            # test_nested_tree_subtree_renamed_and_modified. We'll wait for
 
995
            # the fix from bzr.dev -- vila 2009026
 
996
            elif source_kind == 'tree-reference':
 
997
                if (self.source.get_reference_revision(file_id, source_path)
 
998
                    != self.target.get_reference_revision(file_id, target_path)):
 
999
                    changed_content = True
 
1000
        parent = (source_parent, target_parent)
 
1001
        name = (source_name, target_name)
 
1002
        executable = (source_executable, target_executable)
 
1003
        if (changed_content is not False or versioned[0] != versioned[1]
 
1004
            or parent[0] != parent[1] or name[0] != name[1] or
 
1005
            executable[0] != executable[1]):
 
1006
            changes = True
 
1007
        else:
 
1008
            changes = False
 
1009
        return (file_id, (source_path, target_path), changed_content,
 
1010
                versioned, parent, name, kind, executable), changes
 
1011
 
837
1012
    @needs_read_lock
838
1013
    def compare(self, want_unchanged=False, specific_files=None,
839
1014
        extra_trees=None, require_versioned=False, include_root=False,
854
1029
            a PathsNotVersionedError will be thrown.
855
1030
        :param want_unversioned: Scan for unversioned paths.
856
1031
        """
857
 
        # NB: show_status depends on being able to pass in non-versioned files
858
 
        # and report them as unknown
859
1032
        trees = (self.source,)
860
1033
        if extra_trees is not None:
861
1034
            trees = trees + tuple(extra_trees)
866
1039
            # All files are unversioned, so just return an empty delta
867
1040
            # _compare_trees would think we want a complete delta
868
1041
            result = delta.TreeDelta()
869
 
            fake_entry = InventoryFile('unused', 'unused', 'unused')
 
1042
            fake_entry = inventory.InventoryFile('unused', 'unused', 'unused')
870
1043
            result.unversioned = [(path, None,
871
1044
                self.target._comparison_data(fake_entry, path)[0]) for path in
872
1045
                specific_files]
902
1075
        :param require_versioned: Raise errors.PathsNotVersionedError if a
903
1076
            path in the specific_files list is not versioned in one of
904
1077
            source, target or extra_trees.
 
1078
        :param specific_files: An optional list of file paths to restrict the
 
1079
            comparison to. When mapping filenames to ids, all matches in all
 
1080
            trees (including optional extra_trees) are used, and all children
 
1081
            of matched directories are included. The parents in the target tree
 
1082
            of the specific files up to and including the root of the tree are
 
1083
            always evaluated for changes too.
905
1084
        :param want_unversioned: Should unversioned files be returned in the
906
1085
            output. An unversioned file is defined as one with (False, False)
907
1086
            for the versioned pair.
908
1087
        """
909
 
        result = []
910
1088
        lookup_trees = [self.source]
911
1089
        if extra_trees:
912
1090
             lookup_trees.extend(extra_trees)
 
1091
        # The ids of items we need to examine to insure delta consistency.
 
1092
        precise_file_ids = set()
 
1093
        changed_file_ids = []
913
1094
        if specific_files == []:
914
1095
            specific_file_ids = []
915
1096
        else:
916
1097
            specific_file_ids = self.target.paths2ids(specific_files,
917
1098
                lookup_trees, require_versioned=require_versioned)
 
1099
        if specific_files is not None:
 
1100
            # reparented or added entries must have their parents included
 
1101
            # so that valid deltas can be created. The seen_parents set
 
1102
            # tracks the parents that we need to have.
 
1103
            # The seen_dirs set tracks directory entries we've yielded.
 
1104
            # After outputting version object in to_entries we set difference
 
1105
            # the two seen sets and start checking parents.
 
1106
            seen_parents = set()
 
1107
            seen_dirs = set()
918
1108
        if want_unversioned:
919
1109
            all_unversioned = sorted([(p.split('/'), p) for p in
920
1110
                                     self.target.extras()
921
1111
                if specific_files is None or
922
1112
                    osutils.is_inside_any(specific_files, p)])
923
 
            all_unversioned = deque(all_unversioned)
 
1113
            all_unversioned = collections.deque(all_unversioned)
924
1114
        else:
925
 
            all_unversioned = deque()
 
1115
            all_unversioned = collections.deque()
926
1116
        to_paths = {}
927
1117
        from_entries_by_dir = list(self.source.iter_entries_by_dir(
928
1118
            specific_file_ids=specific_file_ids))
931
1121
            specific_file_ids=specific_file_ids))
932
1122
        num_entries = len(from_entries_by_dir) + len(to_entries_by_dir)
933
1123
        entry_count = 0
934
 
        # the unversioned path lookup only occurs on real trees - where there 
 
1124
        # the unversioned path lookup only occurs on real trees - where there
935
1125
        # can be extras. So the fake_entry is solely used to look up
936
1126
        # executable it values when execute is not supported.
937
 
        fake_entry = InventoryFile('unused', 'unused', 'unused')
938
 
        for to_path, to_entry in to_entries_by_dir:
939
 
            while all_unversioned and all_unversioned[0][0] < to_path.split('/'):
 
1127
        fake_entry = inventory.InventoryFile('unused', 'unused', 'unused')
 
1128
        for target_path, target_entry in to_entries_by_dir:
 
1129
            while (all_unversioned and
 
1130
                all_unversioned[0][0] < target_path.split('/')):
940
1131
                unversioned_path = all_unversioned.popleft()
941
 
                to_kind, to_executable, to_stat = \
 
1132
                target_kind, target_executable, target_stat = \
942
1133
                    self.target._comparison_data(fake_entry, unversioned_path[1])
943
1134
                yield (None, (None, unversioned_path[1]), True, (False, False),
944
1135
                    (None, None),
945
1136
                    (None, unversioned_path[0][-1]),
946
 
                    (None, to_kind),
947
 
                    (None, to_executable))
948
 
            file_id = to_entry.file_id
949
 
            to_paths[file_id] = to_path
 
1137
                    (None, target_kind),
 
1138
                    (None, target_executable))
 
1139
            source_path, source_entry = from_data.get(target_entry.file_id,
 
1140
                (None, None))
 
1141
            result, changes = self._changes_from_entries(source_entry,
 
1142
                target_entry, source_path=source_path, target_path=target_path)
 
1143
            to_paths[result[0]] = result[1][1]
950
1144
            entry_count += 1
951
 
            changed_content = False
952
 
            from_path, from_entry = from_data.get(file_id, (None, None))
953
 
            from_versioned = (from_entry is not None)
954
 
            if from_entry is not None:
955
 
                from_versioned = True
956
 
                from_name = from_entry.name
957
 
                from_parent = from_entry.parent_id
958
 
                from_kind, from_executable, from_stat = \
959
 
                    self.source._comparison_data(from_entry, from_path)
 
1145
            if result[3][0]:
960
1146
                entry_count += 1
961
 
            else:
962
 
                from_versioned = False
963
 
                from_kind = None
964
 
                from_parent = None
965
 
                from_name = None
966
 
                from_executable = None
967
 
            versioned = (from_versioned, True)
968
 
            to_kind, to_executable, to_stat = \
969
 
                self.target._comparison_data(to_entry, to_path)
970
 
            kind = (from_kind, to_kind)
971
 
            if kind[0] != kind[1]:
972
 
                changed_content = True
973
 
            elif from_kind == 'file':
974
 
                from_size = self.source._file_size(from_entry, from_stat)
975
 
                to_size = self.target._file_size(to_entry, to_stat)
976
 
                if from_size != to_size:
977
 
                    changed_content = True
978
 
                elif (self.source.get_file_sha1(file_id, from_path, from_stat) !=
979
 
                    self.target.get_file_sha1(file_id, to_path, to_stat)):
980
 
                    changed_content = True
981
 
            elif from_kind == 'symlink':
982
 
                if (self.source.get_symlink_target(file_id) !=
983
 
                    self.target.get_symlink_target(file_id)):
984
 
                    changed_content = True
985
 
                elif from_kind == 'tree-reference':
986
 
                    if (self.source.get_reference_revision(file_id, from_path)
987
 
                        != self.target.get_reference_revision(file_id, to_path)):
988
 
                        changed_content = True 
989
 
            parent = (from_parent, to_entry.parent_id)
990
 
            name = (from_name, to_entry.name)
991
 
            executable = (from_executable, to_executable)
992
1147
            if pb is not None:
993
1148
                pb.update('comparing files', entry_count, num_entries)
994
 
            if (changed_content is not False or versioned[0] != versioned[1]
995
 
                or parent[0] != parent[1] or name[0] != name[1] or 
996
 
                executable[0] != executable[1] or include_unchanged):
997
 
                yield (file_id, (from_path, to_path), changed_content,
998
 
                    versioned, parent, name, kind, executable)
999
 
 
 
1149
            if changes or include_unchanged:
 
1150
                if specific_file_ids is not None:
 
1151
                    new_parent_id = result[4][1]
 
1152
                    precise_file_ids.add(new_parent_id)
 
1153
                    changed_file_ids.append(result[0])
 
1154
                yield result
 
1155
            # Ensure correct behaviour for reparented/added specific files.
 
1156
            if specific_files is not None:
 
1157
                # Record output dirs
 
1158
                if result[6][1] == 'directory':
 
1159
                    seen_dirs.add(result[0])
 
1160
                # Record parents of reparented/added entries.
 
1161
                versioned = result[3]
 
1162
                parents = result[4]
 
1163
                if not versioned[0] or parents[0] != parents[1]:
 
1164
                    seen_parents.add(parents[1])
1000
1165
        while all_unversioned:
1001
1166
            # yield any trailing unversioned paths
1002
1167
            unversioned_path = all_unversioned.popleft()
1007
1172
                (None, unversioned_path[0][-1]),
1008
1173
                (None, to_kind),
1009
1174
                (None, to_executable))
1010
 
 
1011
 
        def get_to_path(to_entry):
1012
 
            if to_entry.parent_id is None:
1013
 
                to_path = '' # the root
1014
 
            else:
1015
 
                if to_entry.parent_id not in to_paths:
1016
 
                    # recurse up
1017
 
                    return get_to_path(self.target.inventory[to_entry.parent_id])
1018
 
                to_path = osutils.pathjoin(to_paths[to_entry.parent_id],
1019
 
                                           to_entry.name)
1020
 
            to_paths[to_entry.file_id] = to_path
1021
 
            return to_path
1022
 
 
 
1175
        # Yield all remaining source paths
1023
1176
        for path, from_entry in from_entries_by_dir:
1024
1177
            file_id = from_entry.file_id
1025
1178
            if file_id in to_paths:
1026
1179
                # already returned
1027
1180
                continue
1028
 
            if not file_id in self.target.all_file_ids():
 
1181
            if not self.target.has_id(file_id):
1029
1182
                # common case - paths we have not emitted are not present in
1030
1183
                # target.
1031
1184
                to_path = None
1032
1185
            else:
1033
 
                to_path = get_to_path(self.target.inventory[file_id])
 
1186
                to_path = self.target.id2path(file_id)
1034
1187
            entry_count += 1
1035
1188
            if pb is not None:
1036
1189
                pb.update('comparing files', entry_count, num_entries)
1043
1196
            executable = (from_executable, None)
1044
1197
            changed_content = from_kind is not None
1045
1198
            # the parent's path is necessarily known at this point.
 
1199
            changed_file_ids.append(file_id)
1046
1200
            yield(file_id, (path, to_path), changed_content, versioned, parent,
1047
1201
                  name, kind, executable)
 
1202
        changed_file_ids = set(changed_file_ids)
 
1203
        if specific_file_ids is not None:
 
1204
            for result in self._handle_precise_ids(precise_file_ids,
 
1205
                changed_file_ids):
 
1206
                yield result
 
1207
 
 
1208
    def _get_entry(self, tree, file_id):
 
1209
        """Get an inventory entry from a tree, with missing entries as None.
 
1210
 
 
1211
        If the tree raises NotImplementedError on accessing .inventory, then
 
1212
        this is worked around using iter_entries_by_dir on just the file id
 
1213
        desired.
 
1214
 
 
1215
        :param tree: The tree to lookup the entry in.
 
1216
        :param file_id: The file_id to lookup.
 
1217
        """
 
1218
        try:
 
1219
            inventory = tree.inventory
 
1220
        except NotImplementedError:
 
1221
            # No inventory available.
 
1222
            try:
 
1223
                iterator = tree.iter_entries_by_dir(specific_file_ids=[file_id])
 
1224
                return iterator.next()[1]
 
1225
            except StopIteration:
 
1226
                return None
 
1227
        else:
 
1228
            try:
 
1229
                return inventory[file_id]
 
1230
            except errors.NoSuchId:
 
1231
                return None
 
1232
 
 
1233
    def _handle_precise_ids(self, precise_file_ids, changed_file_ids,
 
1234
        discarded_changes=None):
 
1235
        """Fill out a partial iter_changes to be consistent.
 
1236
 
 
1237
        :param precise_file_ids: The file ids of parents that were seen during
 
1238
            the iter_changes.
 
1239
        :param changed_file_ids: The file ids of already emitted items.
 
1240
        :param discarded_changes: An optional dict of precalculated
 
1241
            iter_changes items which the partial iter_changes had not output
 
1242
            but had calculated.
 
1243
        :return: A generator of iter_changes items to output.
 
1244
        """
 
1245
        # process parents of things that had changed under the users
 
1246
        # requested paths to prevent incorrect paths or parent ids which
 
1247
        # aren't in the tree.
 
1248
        while precise_file_ids:
 
1249
            precise_file_ids.discard(None)
 
1250
            # Don't emit file_ids twice
 
1251
            precise_file_ids.difference_update(changed_file_ids)
 
1252
            if not precise_file_ids:
 
1253
                break
 
1254
            # If the there was something at a given output path in source, we
 
1255
            # have to include the entry from source in the delta, or we would
 
1256
            # be putting this entry into a used path.
 
1257
            paths = []
 
1258
            for parent_id in precise_file_ids:
 
1259
                try:
 
1260
                    paths.append(self.target.id2path(parent_id))
 
1261
                except errors.NoSuchId:
 
1262
                    # This id has been dragged in from the source by delta
 
1263
                    # expansion and isn't present in target at all: we don't
 
1264
                    # need to check for path collisions on it.
 
1265
                    pass
 
1266
            for path in paths:
 
1267
                old_id = self.source.path2id(path)
 
1268
                precise_file_ids.add(old_id)
 
1269
            precise_file_ids.discard(None)
 
1270
            current_ids = precise_file_ids
 
1271
            precise_file_ids = set()
 
1272
            # We have to emit all of precise_file_ids that have been altered.
 
1273
            # We may have to output the children of some of those ids if any
 
1274
            # directories have stopped being directories.
 
1275
            for file_id in current_ids:
 
1276
                # Examine file_id
 
1277
                if discarded_changes:
 
1278
                    result = discarded_changes.get(file_id)
 
1279
                    old_entry = None
 
1280
                else:
 
1281
                    result = None
 
1282
                if result is None:
 
1283
                    old_entry = self._get_entry(self.source, file_id)
 
1284
                    new_entry = self._get_entry(self.target, file_id)
 
1285
                    result, changes = self._changes_from_entries(
 
1286
                        old_entry, new_entry)
 
1287
                else:
 
1288
                    changes = True
 
1289
                # Get this parents parent to examine.
 
1290
                new_parent_id = result[4][1]
 
1291
                precise_file_ids.add(new_parent_id)
 
1292
                if changes:
 
1293
                    if (result[6][0] == 'directory' and
 
1294
                        result[6][1] != 'directory'):
 
1295
                        # This stopped being a directory, the old children have
 
1296
                        # to be included.
 
1297
                        if old_entry is None:
 
1298
                            # Reusing a discarded change.
 
1299
                            old_entry = self._get_entry(self.source, file_id)
 
1300
                        for child in old_entry.children.values():
 
1301
                            precise_file_ids.add(child.file_id)
 
1302
                    changed_file_ids.add(result[0])
 
1303
                    yield result
 
1304
 
 
1305
    @needs_read_lock
 
1306
    def file_content_matches(self, source_file_id, target_file_id,
 
1307
            source_path=None, target_path=None, source_stat=None, target_stat=None):
 
1308
        """Check if two files are the same in the source and target trees.
 
1309
 
 
1310
        This only checks that the contents of the files are the same,
 
1311
        it does not touch anything else.
 
1312
 
 
1313
        :param source_file_id: File id of the file in the source tree
 
1314
        :param target_file_id: File id of the file in the target tree
 
1315
        :param source_path: Path of the file in the source tree
 
1316
        :param target_path: Path of the file in the target tree
 
1317
        :param source_stat: Optional stat value of the file in the source tree
 
1318
        :param target_stat: Optional stat value of the file in the target tree
 
1319
        :return: Boolean indicating whether the files have the same contents
 
1320
        """
 
1321
        source_verifier_kind, source_verifier_data = self.source.get_file_verifier(
 
1322
            source_file_id, source_path, source_stat)
 
1323
        target_verifier_kind, target_verifier_data = self.target.get_file_verifier(
 
1324
            target_file_id, target_path, target_stat)
 
1325
        if source_verifier_kind == target_verifier_kind:
 
1326
            return (source_verifier_data == target_verifier_data)
 
1327
        # Fall back to SHA1 for now
 
1328
        if source_verifier_kind != "SHA1":
 
1329
            source_sha1 = self.source.get_file_sha1(source_file_id,
 
1330
                    source_path, source_stat)
 
1331
        else:
 
1332
            source_sha1 = source_verifier_data
 
1333
        if target_verifier_kind != "SHA1":
 
1334
            target_sha1 = self.target.get_file_sha1(target_file_id,
 
1335
                    target_path, target_stat)
 
1336
        else:
 
1337
            target_sha1 = target_verifier_data
 
1338
        return (source_sha1 == target_sha1)
 
1339
 
 
1340
InterTree.register_optimiser(InterTree)
1048
1341
 
1049
1342
 
1050
1343
class MultiWalker(object):
1167
1460
 
1168
1461
    def _walk_master_tree(self):
1169
1462
        """First pass, walk all trees in lock-step.
1170
 
        
 
1463
 
1171
1464
        When we are done, all nodes in the master_tree will have been
1172
1465
        processed. _other_walkers, _other_entries, and _others_extra will be
1173
1466
        set on 'self' for future processing.