/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to breezy/tree.py

  • Committer: Jelmer Vernooij
  • Date: 2017-12-04 23:01:39 UTC
  • mto: This revision was merged to the branch mainline in revision 6839.
  • Revision ID: jelmer@jelmer.uk-20171204230139-1sc3c18ikwewdejm
Remove bytes_to_gzip; work with chunks instead.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
17
17
"""Tree classes, representing directory at point in time.
18
18
"""
19
19
 
 
20
from __future__ import absolute_import
 
21
 
20
22
import os
21
 
from collections import deque
22
 
 
23
 
import bzrlib
24
 
from bzrlib import (
 
23
 
 
24
from .lazy_import import lazy_import
 
25
lazy_import(globals(), """
 
26
import collections
 
27
 
 
28
from breezy import (
25
29
    conflicts as _mod_conflicts,
26
30
    debug,
27
31
    delta,
28
32
    filters,
29
 
    osutils,
30
33
    revision as _mod_revision,
31
34
    rules,
32
 
    )
33
 
from bzrlib.decorators import needs_read_lock
34
 
from bzrlib.errors import BzrError, NoSuchId
35
 
from bzrlib import errors
36
 
from bzrlib.inventory import InventoryFile
37
 
from bzrlib.inter import InterObject
38
 
from bzrlib.osutils import fingerprint_file
39
 
from bzrlib.symbol_versioning import deprecated_function, deprecated_in
40
 
from bzrlib.trace import note
 
35
    trace,
 
36
    )
 
37
from breezy.bzr import (
 
38
    inventory,
 
39
    )
 
40
from breezy.i18n import gettext
 
41
""")
 
42
 
 
43
from . import (
 
44
    errors,
 
45
    lock,
 
46
    osutils,
 
47
    )
 
48
from .inter import InterObject
 
49
from .sixish import (
 
50
    viewvalues,
 
51
    )
 
52
 
 
53
 
 
54
class FileTimestampUnavailable(errors.BzrError):
 
55
 
 
56
    _fmt = "The filestamp for %(path)s is not available."
 
57
 
 
58
    internal_error = True
 
59
 
 
60
    def __init__(self, path):
 
61
        self.path = path
41
62
 
42
63
 
43
64
class Tree(object):
49
70
 
50
71
    * `RevisionTree` is a tree as recorded at some point in the past.
51
72
 
52
 
    Trees contain an `Inventory` object, and also know how to retrieve
53
 
    file texts mentioned in the inventory, either from a working
54
 
    directory or from a store.
55
 
 
56
 
    It is possible for trees to contain files that are not described
57
 
    in their inventory or vice versa; for this use `filenames()`.
58
 
 
59
73
    Trees can be compared, etc, regardless of whether they are working
60
74
    trees or versioned trees.
61
75
    """
62
76
 
 
77
    def has_versioned_directories(self):
 
78
        """Whether this tree can contain explicitly versioned directories.
 
79
 
 
80
        This defaults to True, but some implementations may want to override
 
81
        it.
 
82
        """
 
83
        return True
 
84
 
63
85
    def changes_from(self, other, want_unchanged=False, specific_files=None,
64
86
        extra_trees=None, require_versioned=False, include_root=False,
65
87
        want_unversioned=False):
105
127
    def conflicts(self):
106
128
        """Get a list of the conflicts in the tree.
107
129
 
108
 
        Each conflict is an instance of bzrlib.conflicts.Conflict.
 
130
        Each conflict is an instance of breezy.conflicts.Conflict.
109
131
        """
110
132
        return _mod_conflicts.ConflictList()
111
133
 
127
149
        raise NotImplementedError(self.has_filename)
128
150
 
129
151
    def has_id(self, file_id):
130
 
        return self.inventory.has_id(file_id)
131
 
 
132
 
    def __contains__(self, file_id):
133
 
        return self.has_id(file_id)
 
152
        raise NotImplementedError(self.has_id)
134
153
 
135
154
    def has_or_had_id(self, file_id):
136
 
        return self.inventory.has_id(file_id)
 
155
        raise NotImplementedError(self.has_or_had_id)
137
156
 
138
157
    def is_ignored(self, filename):
139
158
        """Check whether the filename is ignored by this tree.
143
162
        """
144
163
        return False
145
164
 
146
 
    def __iter__(self):
147
 
        return iter(self.inventory)
148
 
 
149
165
    def all_file_ids(self):
150
166
        """Iterate through all file ids, including ids for missing files."""
151
 
        return set(self.inventory)
 
167
        raise NotImplementedError(self.all_file_ids)
 
168
 
 
169
    def all_versioned_paths(self):
 
170
        """Iterate through all paths, including paths for missing files."""
 
171
        raise NotImplementedError(self.all_versioned_paths)
152
172
 
153
173
    def id2path(self, file_id):
154
174
        """Return the path for a file id.
155
175
 
156
176
        :raises NoSuchId:
157
177
        """
158
 
        return self.inventory.id2path(file_id)
159
 
 
160
 
    def is_control_filename(self, filename):
161
 
        """True if filename is the name of a control file in this tree.
162
 
 
163
 
        :param filename: A filename within the tree. This is a relative path
164
 
        from the root of this tree.
165
 
 
166
 
        This is true IF and ONLY IF the filename is part of the meta data
167
 
        that bzr controls in this tree. I.E. a random .bzr directory placed
168
 
        on disk will not be a control file for this tree.
169
 
        """
170
 
        return self.bzrdir.is_control_filename(filename)
171
 
 
172
 
    @needs_read_lock
 
178
        raise NotImplementedError(self.id2path)
 
179
 
173
180
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
174
181
        """Walk the tree in 'by_dir' order.
175
182
 
192
199
             g
193
200
 
194
201
        The yield order (ignoring root) would be::
 
202
 
195
203
          a, f, a/b, a/d, a/b/c, a/d/e, f/g
196
204
 
197
205
        :param yield_parents: If True, yield the parents from the root leading
198
206
            down to specific_file_ids that have been requested. This has no
199
207
            impact if specific_file_ids is None.
200
208
        """
201
 
        return self.inventory.iter_entries_by_dir(
202
 
            specific_file_ids=specific_file_ids, yield_parents=yield_parents)
 
209
        raise NotImplementedError(self.iter_entries_by_dir)
 
210
 
 
211
    def iter_child_entries(self, file_id, path=None):
 
212
        """Iterate over the children of a directory or tree reference.
 
213
 
 
214
        :param file_id: File id of the directory/tree-reference
 
215
        :param path: Optional path of the directory
 
216
        :raise NoSuchId: When the file_id does not exist
 
217
        :return: Iterator over entries in the directory
 
218
        """
 
219
        raise NotImplementedError(self.iter_child_entries)
 
220
 
 
221
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
222
        """List all files in this tree.
 
223
 
 
224
        :param include_root: Whether to include the entry for the tree root
 
225
        :param from_dir: Directory under which to list files
 
226
        :param recursive: Whether to list files recursively
 
227
        :return: iterator over tuples of (path, versioned, kind, file_id,
 
228
            inventory entry)
 
229
        """
 
230
        raise NotImplementedError(self.list_files)
203
231
 
204
232
    def iter_references(self):
205
233
        if self.supports_tree_reference():
207
235
                if entry.kind == 'tree-reference':
208
236
                    yield path, entry.file_id
209
237
 
210
 
    def kind(self, file_id):
 
238
    def kind(self, path, file_id=None):
211
239
        raise NotImplementedError("Tree subclass %s must implement kind"
212
240
            % self.__class__.__name__)
213
241
 
214
 
    def stored_kind(self, file_id):
 
242
    def stored_kind(self, path, file_id=None):
215
243
        """File kind stored for this file_id.
216
244
 
217
245
        May not match kind on disk for working trees.  Always available
218
246
        for versioned files, even when the file itself is missing.
219
247
        """
220
 
        return self.kind(file_id)
 
248
        return self.kind(path, file_id)
221
249
 
222
250
    def path_content_summary(self, path):
223
251
        """Get a summary of the information about path.
237
265
        """
238
266
        raise NotImplementedError(self.path_content_summary)
239
267
 
240
 
    def get_reference_revision(self, file_id, path=None):
 
268
    def get_reference_revision(self, path, file_id=None):
241
269
        raise NotImplementedError("Tree subclass %s must implement "
242
270
                                  "get_reference_revision"
243
271
            % self.__class__.__name__)
256
284
    def _file_size(self, entry, stat_value):
257
285
        raise NotImplementedError(self._file_size)
258
286
 
259
 
    def _get_inventory(self):
260
 
        return self._inventory
261
 
 
262
 
    def get_file(self, file_id, path=None):
 
287
    def get_file(self, path, file_id=None):
263
288
        """Return a file object for the file file_id in the tree.
264
289
 
265
290
        If both file_id and path are defined, it is implementation defined as
267
292
        """
268
293
        raise NotImplementedError(self.get_file)
269
294
 
270
 
    def get_file_with_stat(self, file_id, path=None):
 
295
    def get_file_with_stat(self, path, file_id=None):
271
296
        """Get a file handle and stat object for file_id.
272
297
 
273
298
        The default implementation returns (self.get_file, None) for backwards
274
299
        compatibility.
275
300
 
276
 
        :param file_id: The file id to read.
277
 
        :param path: The path of the file, if it is known.
 
301
        :param path: The path of the file.
 
302
        :param file_id: The file id to read, if it is known.
278
303
        :return: A tuple (file_handle, stat_value_or_None). If the tree has
279
304
            no stat facility, or need for a stat cache feedback during commit,
280
305
            it may return None for the second element of the tuple.
281
306
        """
282
 
        return (self.get_file(file_id, path), None)
 
307
        return (self.get_file(path, file_id), None)
283
308
 
284
 
    def get_file_text(self, file_id, path=None):
 
309
    def get_file_text(self, path, file_id=None):
285
310
        """Return the byte content of a file.
286
311
 
 
312
        :param path: The path of the file.
287
313
        :param file_id: The file_id of the file.
288
 
        :param path: The path of the file.
 
314
 
289
315
        If both file_id and path are supplied, an implementation may use
290
316
        either one.
 
317
 
 
318
        :returns: A single byte string for the whole file.
291
319
        """
292
 
        my_file = self.get_file(file_id, path)
 
320
        my_file = self.get_file(path, file_id)
293
321
        try:
294
322
            return my_file.read()
295
323
        finally:
296
324
            my_file.close()
297
325
 
298
 
    def get_file_lines(self, file_id, path=None):
 
326
    def get_file_lines(self, path, file_id=None):
299
327
        """Return the content of a file, as lines.
300
328
 
 
329
        :param path: The path of the file.
301
330
        :param file_id: The file_id of the file.
302
 
        :param path: The path of the file.
 
331
 
303
332
        If both file_id and path are supplied, an implementation may use
304
333
        either one.
305
334
        """
306
 
        return osutils.split_lines(self.get_file_text(file_id, path))
307
 
 
308
 
    def get_file_mtime(self, file_id, path=None):
 
335
        return osutils.split_lines(self.get_file_text(path, file_id))
 
336
 
 
337
    def get_file_verifier(self, path, file_id=None, stat_value=None):
 
338
        """Return a verifier for a file.
 
339
 
 
340
        The default implementation returns a sha1.
 
341
 
 
342
        :param file_id: The handle for this file.
 
343
        :param path: The path that this file can be found at.
 
344
            These must point to the same object.
 
345
        :param stat_value: Optional stat value for the object
 
346
        :return: Tuple with verifier name and verifier data
 
347
        """
 
348
        return ("SHA1", self.get_file_sha1(path, file_id,
 
349
            stat_value=stat_value))
 
350
 
 
351
    def get_file_sha1(self, path, file_id=None, stat_value=None):
 
352
        """Return the SHA1 file for a file.
 
353
 
 
354
        :note: callers should use get_file_verifier instead
 
355
            where possible, as the underlying repository implementation may
 
356
            have quicker access to a non-sha1 verifier.
 
357
 
 
358
        :param path: The path that this file can be found at.
 
359
        :param file_id: The handle for this file.
 
360
            These must point to the same object.
 
361
        :param stat_value: Optional stat value for the object
 
362
        """
 
363
        raise NotImplementedError(self.get_file_sha1)
 
364
 
 
365
    def get_file_mtime(self, path, file_id=None):
309
366
        """Return the modification time for a file.
310
367
 
 
368
        :param path: The path that this file can be found at.
311
369
        :param file_id: The handle for this file.
312
 
        :param path: The path that this file can be found at.
313
370
            These must point to the same object.
314
371
        """
315
372
        raise NotImplementedError(self.get_file_mtime)
316
373
 
317
 
    def get_file_size(self, file_id):
 
374
    def get_file_size(self, path, file_id=None):
318
375
        """Return the size of a file in bytes.
319
376
 
320
377
        This applies only to regular files.  If invoked on directories or
323
380
        """
324
381
        raise NotImplementedError(self.get_file_size)
325
382
 
326
 
    def get_file_by_path(self, path):
327
 
        return self.get_file(self._inventory.path2id(path), path)
 
383
    def is_executable(self, path, file_id=None):
 
384
        """Check if a file is executable.
 
385
 
 
386
        :param path: The path that this file can be found at.
 
387
        :param file_id: The handle for this file.
 
388
            These must point to the same object.
 
389
        """
 
390
        raise NotImplementedError(self.is_executable)
328
391
 
329
392
    def iter_files_bytes(self, desired_files):
330
393
        """Iterate through file contents.
349
412
            # of bytestrings.  (Technically, a bytestring is also an iterable
350
413
            # of bytestrings, but iterating through each character is not
351
414
            # performant.)
352
 
            cur_file = (self.get_file_text(file_id),)
 
415
            # TODO(jelmer): Pass paths into iter_files_bytes
 
416
            path = self.id2path(file_id)
 
417
            cur_file = (self.get_file_text(path, file_id),)
353
418
            yield identifier, cur_file
354
419
 
355
 
    def get_symlink_target(self, file_id):
 
420
    def get_symlink_target(self, path, file_id=None):
356
421
        """Get the target for a given file_id.
357
422
 
358
423
        It is assumed that the caller already knows that file_id is referencing
359
424
        a symlink.
360
425
        :param file_id: Handle for the symlink entry.
 
426
        :param path: The path of the file.
 
427
        If both file_id and path are supplied, an implementation may use
 
428
        either one.
361
429
        :return: The path the symlink points to.
362
430
        """
363
431
        raise NotImplementedError(self.get_symlink_target)
364
432
 
365
 
    def get_canonical_inventory_paths(self, paths):
366
 
        """Like get_canonical_inventory_path() but works on multiple items.
367
 
 
368
 
        :param paths: A sequence of paths relative to the root of the tree.
369
 
        :return: A list of paths, with each item the corresponding input path
370
 
        adjusted to account for existing elements that match case
371
 
        insensitively.
372
 
        """
373
 
        return list(self._yield_canonical_inventory_paths(paths))
374
 
 
375
 
    def get_canonical_inventory_path(self, path):
376
 
        """Returns the first inventory item that case-insensitively matches path.
377
 
 
378
 
        If a path matches exactly, it is returned. If no path matches exactly
379
 
        but more than one path matches case-insensitively, it is implementation
380
 
        defined which is returned.
381
 
 
382
 
        If no path matches case-insensitively, the input path is returned, but
383
 
        with as many path entries that do exist changed to their canonical
384
 
        form.
385
 
 
386
 
        If you need to resolve many names from the same tree, you should
387
 
        use get_canonical_inventory_paths() to avoid O(N) behaviour.
388
 
 
389
 
        :param path: A paths relative to the root of the tree.
390
 
        :return: The input path adjusted to account for existing elements
391
 
        that match case insensitively.
392
 
        """
393
 
        return self._yield_canonical_inventory_paths([path]).next()
394
 
 
395
 
    def _yield_canonical_inventory_paths(self, paths):
396
 
        for path in paths:
397
 
            # First, if the path as specified exists exactly, just use it.
398
 
            if self.path2id(path) is not None:
399
 
                yield path
400
 
                continue
401
 
            # go walkin...
402
 
            cur_id = self.get_root_id()
403
 
            cur_path = ''
404
 
            bit_iter = iter(path.split("/"))
405
 
            for elt in bit_iter:
406
 
                lelt = elt.lower()
407
 
                new_path = None
408
 
                for child in self.iter_children(cur_id):
409
 
                    try:
410
 
                        # XXX: it seem like if the child is known to be in the
411
 
                        # tree, we shouldn't need to go from its id back to
412
 
                        # its path -- mbp 2010-02-11
413
 
                        #
414
 
                        # XXX: it seems like we could be more efficient
415
 
                        # by just directly looking up the original name and
416
 
                        # only then searching all children; also by not
417
 
                        # chopping paths so much. -- mbp 2010-02-11
418
 
                        child_base = os.path.basename(self.id2path(child))
419
 
                        if (child_base == elt):
420
 
                            # if we found an exact match, we can stop now; if
421
 
                            # we found an approximate match we need to keep
422
 
                            # searching because there might be an exact match
423
 
                            # later.  
424
 
                            cur_id = child
425
 
                            new_path = osutils.pathjoin(cur_path, child_base)
426
 
                            break
427
 
                        elif child_base.lower() == lelt:
428
 
                            cur_id = child
429
 
                            new_path = osutils.pathjoin(cur_path, child_base)
430
 
                    except NoSuchId:
431
 
                        # before a change is committed we can see this error...
432
 
                        continue
433
 
                if new_path:
434
 
                    cur_path = new_path
435
 
                else:
436
 
                    # got to the end of this directory and no entries matched.
437
 
                    # Return what matched so far, plus the rest as specified.
438
 
                    cur_path = osutils.pathjoin(cur_path, elt, *list(bit_iter))
439
 
                    break
440
 
            yield cur_path
441
 
        # all done.
442
 
 
443
433
    def get_root_id(self):
444
434
        """Return the file_id for the root of this tree."""
445
435
        raise NotImplementedError(self.get_root_id)
446
436
 
447
 
    def annotate_iter(self, file_id,
 
437
    def annotate_iter(self, path, file_id=None,
448
438
                      default_revision=_mod_revision.CURRENT_REVISION):
449
439
        """Return an iterator of revision_id, line tuples.
450
440
 
459
449
        raise NotImplementedError(self.annotate_iter)
460
450
 
461
451
    def _get_plan_merge_data(self, file_id, other, base):
462
 
        from bzrlib import versionedfile
 
452
        from .bzr import versionedfile
463
453
        vf = versionedfile._PlanMergeVersionedFile(file_id)
464
 
        last_revision_a = self._get_file_revision(file_id, vf, 'this:')
465
 
        last_revision_b = other._get_file_revision(file_id, vf, 'other:')
 
454
        last_revision_a = self._get_file_revision(
 
455
                self.id2path(file_id), file_id, vf, 'this:')
 
456
        last_revision_b = other._get_file_revision(
 
457
                other.id2path(file_id), file_id, vf, 'other:')
466
458
        if base is None:
467
459
            last_revision_base = None
468
460
        else:
469
 
            last_revision_base = base._get_file_revision(file_id, vf, 'base:')
 
461
            last_revision_base = base._get_file_revision(
 
462
                    base.id2path(file_id), file_id, vf, 'base:')
470
463
        return vf, last_revision_a, last_revision_b, last_revision_base
471
464
 
472
465
    def plan_file_merge(self, file_id, other, base=None):
503
496
            except errors.NoSuchRevisionInTree:
504
497
                yield self.repository.revision_tree(revision_id)
505
498
 
506
 
    @staticmethod
507
 
    def _file_revision(revision_tree, file_id):
508
 
        """Determine the revision associated with a file in a given tree."""
509
 
        revision_tree.lock_read()
510
 
        try:
511
 
            return revision_tree.inventory[file_id].revision
512
 
        finally:
513
 
            revision_tree.unlock()
514
 
 
515
 
    def _get_file_revision(self, file_id, vf, tree_revision):
 
499
    def _get_file_revision(self, path, file_id, vf, tree_revision):
516
500
        """Ensure that file_id, tree_revision is in vf to plan the merge."""
517
 
 
518
501
        if getattr(self, '_repository', None) is None:
519
502
            last_revision = tree_revision
520
 
            parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
 
503
            parent_keys = [(file_id, t.get_file_revision(path, file_id)) for t in
521
504
                self._iter_parent_trees()]
522
505
            vf.add_lines((file_id, last_revision), parent_keys,
523
 
                         self.get_file(file_id).readlines())
 
506
                         self.get_file_lines(path, file_id))
524
507
            repo = self.branch.repository
525
508
            base_vf = repo.texts
526
509
        else:
527
 
            last_revision = self._file_revision(self, file_id)
 
510
            last_revision = self.get_file_revision(path, file_id)
528
511
            base_vf = self._repository.texts
529
512
        if base_vf not in vf.fallback_versionedfiles:
530
513
            vf.fallback_versionedfiles.append(base_vf)
531
514
        return last_revision
532
515
 
533
 
    inventory = property(_get_inventory,
534
 
                         doc="Inventory of this Tree")
535
 
 
536
516
    def _check_retrieved(self, ie, f):
537
517
        if not __debug__:
538
518
            return
539
 
        fp = fingerprint_file(f)
 
519
        fp = osutils.fingerprint_file(f)
540
520
        f.seek(0)
541
521
 
542
522
        if ie.text_size is not None:
543
523
            if ie.text_size != fp['size']:
544
 
                raise BzrError("mismatched size for file %r in %r" % (ie.file_id, self._store),
 
524
                raise errors.BzrError(
 
525
                        "mismatched size for file %r in %r" %
 
526
                        (ie.file_id, self._store),
545
527
                        ["inventory expects %d bytes" % ie.text_size,
546
528
                         "file is actually %d bytes" % fp['size'],
547
529
                         "store is probably damaged/corrupt"])
548
530
 
549
531
        if ie.text_sha1 != fp['sha1']:
550
 
            raise BzrError("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
 
532
            raise errors.BzrError("wrong SHA-1 for file %r in %r" %
 
533
                    (ie.file_id, self._store),
551
534
                    ["inventory expects %s" % ie.text_sha1,
552
535
                     "file is actually %s" % fp['sha1'],
553
536
                     "store is probably damaged/corrupt"])
554
537
 
555
 
    @needs_read_lock
556
538
    def path2id(self, path):
557
539
        """Return the id for path in this tree."""
558
 
        return self._inventory.path2id(path)
 
540
        raise NotImplementedError(self.path2id)
559
541
 
560
542
    def paths2ids(self, paths, trees=[], require_versioned=True):
561
543
        """Return all the ids that can be reached by walking from paths.
577
559
        return find_ids_across_trees(paths, [self] + list(trees), require_versioned)
578
560
 
579
561
    def iter_children(self, file_id):
580
 
        entry = self.iter_entries_by_dir([file_id]).next()[1]
581
 
        for child in getattr(entry, 'children', {}).itervalues():
582
 
            yield child.file_id
 
562
        """Iterate over the file ids of the children of an entry.
 
563
 
 
564
        :param file_id: File id of the entry
 
565
        :return: Iterator over child file ids.
 
566
        """
 
567
        raise NotImplementedError(self.iter_children)
583
568
 
584
569
    def lock_read(self):
585
 
        pass
 
570
        """Lock this tree for multiple read only operations.
 
571
 
 
572
        :return: A breezy.lock.LogicalLockResult.
 
573
        """
 
574
        return lock.LogicalLockResult(self.unlock)
586
575
 
587
576
    def revision_tree(self, revision_id):
588
577
        """Obtain a revision tree for the revision revision_id.
614
603
 
615
604
        :return: set of paths.
616
605
        """
617
 
        # NB: we specifically *don't* call self.has_filename, because for
618
 
        # WorkingTrees that can indicate files that exist on disk but that
619
 
        # are not versioned.
620
 
        pred = self.inventory.has_filename
621
 
        return set((p for p in paths if not pred(p)))
 
606
        raise NotImplementedError(self.filter_unversioned_files)
622
607
 
623
608
    def walkdirs(self, prefix=""):
624
609
        """Walk the contents of this tree from path down.
673
658
            return []
674
659
        if path is None:
675
660
            path = self.id2path(file_id)
676
 
        prefs = self.iter_search_rules([path], filter_pref_names).next()
 
661
        prefs = next(self.iter_search_rules([path], filter_pref_names))
677
662
        stk = filters._get_filter_stack_for(prefs)
678
663
        if 'filters' in debug.debug_flags:
679
 
            note("*** %s content-filter: %s => %r" % (path,prefs,stk))
 
664
            trace.note(gettext("*** {0} content-filter: {1} => {2!r}").format(path, prefs, stk))
680
665
        return stk
681
666
 
682
667
    def _content_filter_stack_provider(self):
721
706
        return searcher
722
707
 
723
708
 
724
 
######################################################################
725
 
# diff
726
 
 
727
 
# TODO: Merge these two functions into a single one that can operate
728
 
# on either a whole tree or a set of files.
729
 
 
730
 
# TODO: Return the diff in order by filename, not by category or in
731
 
# random order.  Can probably be done by lock-stepping through the
732
 
# filenames from both trees.
733
 
 
734
 
 
735
 
def file_status(filename, old_tree, new_tree):
736
 
    """Return single-letter status, old and new names for a file.
737
 
 
738
 
    The complexity here is in deciding how to represent renames;
739
 
    many complex cases are possible.
740
 
    """
741
 
    old_inv = old_tree.inventory
742
 
    new_inv = new_tree.inventory
743
 
    new_id = new_inv.path2id(filename)
744
 
    old_id = old_inv.path2id(filename)
745
 
 
746
 
    if not new_id and not old_id:
747
 
        # easy: doesn't exist in either; not versioned at all
748
 
        if new_tree.is_ignored(filename):
749
 
            return 'I', None, None
750
 
        else:
751
 
            return '?', None, None
752
 
    elif new_id:
753
 
        # There is now a file of this name, great.
754
 
        pass
755
 
    else:
756
 
        # There is no longer a file of this name, but we can describe
757
 
        # what happened to the file that used to have
758
 
        # this name.  There are two possibilities: either it was
759
 
        # deleted entirely, or renamed.
760
 
        if new_inv.has_id(old_id):
761
 
            return 'X', old_inv.id2path(old_id), new_inv.id2path(old_id)
762
 
        else:
763
 
            return 'D', old_inv.id2path(old_id), None
764
 
 
765
 
    # if the file_id is new in this revision, it is added
766
 
    if new_id and not old_inv.has_id(new_id):
767
 
        return 'A'
768
 
 
769
 
    # if there used to be a file of this name, but that ID has now
770
 
    # disappeared, it is deleted
771
 
    if old_id and not new_inv.has_id(old_id):
772
 
        return 'D'
773
 
 
774
 
    return 'wtf?'
775
 
 
776
 
 
777
 
@deprecated_function(deprecated_in((1, 9, 0)))
778
 
def find_renames(old_inv, new_inv):
779
 
    for file_id in old_inv:
780
 
        if file_id not in new_inv:
781
 
            continue
782
 
        old_name = old_inv.id2path(file_id)
783
 
        new_name = new_inv.id2path(file_id)
784
 
        if old_name != new_name:
785
 
            yield (old_name, new_name)
786
 
 
787
 
 
788
709
def find_ids_across_trees(filenames, trees, require_versioned=True):
789
710
    """Find the ids corresponding to specified filenames.
790
711
 
795
716
        None)
796
717
    :param trees: The trees to find file_ids within
797
718
    :param require_versioned: if true, all specified filenames must occur in
798
 
    at least one tree.
 
719
        at least one tree.
799
720
    :return: a set of file ids for the specified filenames and their children.
800
721
    """
801
722
    if not filenames:
864
785
    Its instances have methods like 'compare' and contain references to the
865
786
    source and target trees these operations are to be carried out on.
866
787
 
867
 
    Clients of bzrlib should not need to use InterTree directly, rather they
 
788
    Clients of breezy should not need to use InterTree directly, rather they
868
789
    should use the convenience methods on Tree such as 'Tree.compare()' which
869
790
    will pass through to InterTree as appropriate.
870
791
    """
877
798
 
878
799
    _optimisers = []
879
800
 
 
801
    @classmethod
 
802
    def is_compatible(kls, source, target):
 
803
        # The default implementation is naive and uses the public API, so
 
804
        # it works for all trees.
 
805
        return True
 
806
 
880
807
    def _changes_from_entries(self, source_entry, target_entry,
881
808
        source_path=None, target_path=None):
882
809
        """Generate a iter_changes tuple between source_entry and target_entry.
930
857
        if source_kind != target_kind:
931
858
            changed_content = True
932
859
        elif source_kind == 'file':
933
 
            if (self.source.get_file_sha1(file_id, source_path, source_stat) !=
934
 
                self.target.get_file_sha1(file_id, target_path, target_stat)):
 
860
            if not self.file_content_matches(file_id, file_id, source_path,
 
861
                    target_path, source_stat, target_stat):
935
862
                changed_content = True
936
863
        elif source_kind == 'symlink':
937
 
            if (self.source.get_symlink_target(file_id) !=
938
 
                self.target.get_symlink_target(file_id)):
 
864
            if (self.source.get_symlink_target(source_path, file_id) !=
 
865
                self.target.get_symlink_target(target_path, file_id)):
939
866
                changed_content = True
940
 
            # XXX: Yes, the indentation below is wrong. But fixing it broke
941
 
            # test_merge.TestMergerEntriesLCAOnDisk.
942
 
            # test_nested_tree_subtree_renamed_and_modified. We'll wait for
943
 
            # the fix from bzr.dev -- vila 2009026
944
 
            elif source_kind == 'tree-reference':
945
 
                if (self.source.get_reference_revision(file_id, source_path)
946
 
                    != self.target.get_reference_revision(file_id, target_path)):
 
867
        elif source_kind == 'tree-reference':
 
868
            if (self.source.get_reference_revision(source_path, file_id)
 
869
                != self.target.get_reference_revision(target_path, file_id)):
947
870
                    changed_content = True
948
871
        parent = (source_parent, target_parent)
949
872
        name = (source_name, target_name)
957
880
        return (file_id, (source_path, target_path), changed_content,
958
881
                versioned, parent, name, kind, executable), changes
959
882
 
960
 
    @needs_read_lock
961
883
    def compare(self, want_unchanged=False, specific_files=None,
962
884
        extra_trees=None, require_versioned=False, include_root=False,
963
885
        want_unversioned=False):
980
902
        trees = (self.source,)
981
903
        if extra_trees is not None:
982
904
            trees = trees + tuple(extra_trees)
983
 
        # target is usually the newer tree:
984
 
        specific_file_ids = self.target.paths2ids(specific_files, trees,
985
 
            require_versioned=require_versioned)
986
 
        if specific_files and not specific_file_ids:
987
 
            # All files are unversioned, so just return an empty delta
988
 
            # _compare_trees would think we want a complete delta
989
 
            result = delta.TreeDelta()
990
 
            fake_entry = InventoryFile('unused', 'unused', 'unused')
991
 
            result.unversioned = [(path, None,
992
 
                self.target._comparison_data(fake_entry, path)[0]) for path in
993
 
                specific_files]
994
 
            return result
995
 
        return delta._compare_trees(self.source, self.target, want_unchanged,
996
 
            specific_files, include_root, extra_trees=extra_trees,
997
 
            require_versioned=require_versioned,
998
 
            want_unversioned=want_unversioned)
 
905
        with self.lock_read():
 
906
            # target is usually the newer tree:
 
907
            specific_file_ids = self.target.paths2ids(specific_files, trees,
 
908
                require_versioned=require_versioned)
 
909
            if specific_files and not specific_file_ids:
 
910
                # All files are unversioned, so just return an empty delta
 
911
                # _compare_trees would think we want a complete delta
 
912
                result = delta.TreeDelta()
 
913
                fake_entry = inventory.InventoryFile('unused', 'unused', 'unused')
 
914
                result.unversioned = [(path, None,
 
915
                    self.target._comparison_data(fake_entry, path)[0]) for path in
 
916
                    specific_files]
 
917
                return result
 
918
            return delta._compare_trees(self.source, self.target, want_unchanged,
 
919
                specific_files, include_root, extra_trees=extra_trees,
 
920
                require_versioned=require_versioned,
 
921
                want_unversioned=want_unversioned)
999
922
 
1000
923
    def iter_changes(self, include_unchanged=False,
1001
924
                      specific_files=None, pb=None, extra_trees=[],
1058
981
                                     self.target.extras()
1059
982
                if specific_files is None or
1060
983
                    osutils.is_inside_any(specific_files, p)])
1061
 
            all_unversioned = deque(all_unversioned)
 
984
            all_unversioned = collections.deque(all_unversioned)
1062
985
        else:
1063
 
            all_unversioned = deque()
 
986
            all_unversioned = collections.deque()
1064
987
        to_paths = {}
1065
988
        from_entries_by_dir = list(self.source.iter_entries_by_dir(
1066
989
            specific_file_ids=specific_file_ids))
1072
995
        # the unversioned path lookup only occurs on real trees - where there
1073
996
        # can be extras. So the fake_entry is solely used to look up
1074
997
        # executable it values when execute is not supported.
1075
 
        fake_entry = InventoryFile('unused', 'unused', 'unused')
 
998
        fake_entry = inventory.InventoryFile('unused', 'unused', 'unused')
1076
999
        for target_path, target_entry in to_entries_by_dir:
1077
1000
            while (all_unversioned and
1078
1001
                all_unversioned[0][0] < target_path.split('/')):
1126
1049
            if file_id in to_paths:
1127
1050
                # already returned
1128
1051
                continue
1129
 
            if file_id not in self.target.all_file_ids():
 
1052
            if not self.target.has_id(file_id):
1130
1053
                # common case - paths we have not emitted are not present in
1131
1054
                # target.
1132
1055
                to_path = None
1164
1087
        :param file_id: The file_id to lookup.
1165
1088
        """
1166
1089
        try:
1167
 
            inventory = tree.inventory
 
1090
            inventory = tree.root_inventory
1168
1091
        except NotImplementedError:
1169
1092
            # No inventory available.
1170
1093
            try:
1239
1162
                precise_file_ids.add(new_parent_id)
1240
1163
                if changes:
1241
1164
                    if (result[6][0] == 'directory' and
1242
 
                        result[6][1] != 'directory'):
 
1165
                            result[6][1] != 'directory'):
1243
1166
                        # This stopped being a directory, the old children have
1244
1167
                        # to be included.
1245
1168
                        if old_entry is None:
1246
1169
                            # Reusing a discarded change.
1247
1170
                            old_entry = self._get_entry(self.source, file_id)
1248
 
                        for child in old_entry.children.values():
1249
 
                            precise_file_ids.add(child.file_id)
 
1171
                        precise_file_ids.update(
 
1172
                                self.source.iter_children(file_id))
1250
1173
                    changed_file_ids.add(result[0])
1251
1174
                    yield result
1252
1175
 
 
1176
    def file_content_matches(
 
1177
            self, source_file_id, target_file_id, source_path=None,
 
1178
            target_path=None, source_stat=None, target_stat=None):
 
1179
        """Check if two files are the same in the source and target trees.
 
1180
 
 
1181
        This only checks that the contents of the files are the same,
 
1182
        it does not touch anything else.
 
1183
 
 
1184
        :param source_file_id: File id of the file in the source tree
 
1185
        :param target_file_id: File id of the file in the target tree
 
1186
        :param source_path: Path of the file in the source tree
 
1187
        :param target_path: Path of the file in the target tree
 
1188
        :param source_stat: Optional stat value of the file in the source tree
 
1189
        :param target_stat: Optional stat value of the file in the target tree
 
1190
        :return: Boolean indicating whether the files have the same contents
 
1191
        """
 
1192
        with self.lock_read():
 
1193
            if source_path is None:
 
1194
                source_path = self.source.id2path(source_file_id)
 
1195
            if target_path is None:
 
1196
                target_path = self.target.id2path(target_file_id)
 
1197
            source_verifier_kind, source_verifier_data = (
 
1198
                    self.source.get_file_verifier(
 
1199
                        source_path, source_file_id, source_stat))
 
1200
            target_verifier_kind, target_verifier_data = (
 
1201
                self.target.get_file_verifier(
 
1202
                    target_path, target_file_id, target_stat))
 
1203
            if source_verifier_kind == target_verifier_kind:
 
1204
                return (source_verifier_data == target_verifier_data)
 
1205
            # Fall back to SHA1 for now
 
1206
            if source_verifier_kind != "SHA1":
 
1207
                source_sha1 = self.source.get_file_sha1(
 
1208
                        source_path, source_file_id, source_stat)
 
1209
            else:
 
1210
                source_sha1 = source_verifier_data
 
1211
            if target_verifier_kind != "SHA1":
 
1212
                target_sha1 = self.target.get_file_sha1(
 
1213
                        target_path, target_file_id, target_stat)
 
1214
            else:
 
1215
                target_sha1 = target_verifier_data
 
1216
            return (source_sha1 == target_sha1)
 
1217
 
 
1218
InterTree.register_optimiser(InterTree)
 
1219
 
1253
1220
 
1254
1221
class MultiWalker(object):
1255
1222
    """Walk multiple trees simultaneously, getting combined results."""
1289
1256
            If has_more is False, path and ie will be None.
1290
1257
        """
1291
1258
        try:
1292
 
            path, ie = iterator.next()
 
1259
            path, ie = next(iterator)
1293
1260
        except StopIteration:
1294
1261
            return False, None, None
1295
1262
        else:
1358
1325
            return (None, None)
1359
1326
        else:
1360
1327
            self._out_of_order_processed.add(file_id)
1361
 
            cur_ie = other_tree.inventory[file_id]
 
1328
            cur_ie = other_tree.root_inventory[file_id]
1362
1329
            return (cur_path, cur_ie)
1363
1330
 
1364
1331
    def iter_all(self):
1385
1352
                         for other in self._other_trees]
1386
1353
        other_entries = [self._step_one(walker) for walker in other_walkers]
1387
1354
        # Track extra nodes in the other trees
1388
 
        others_extra = [{} for i in xrange(len(self._other_trees))]
 
1355
        others_extra = [{} for _ in range(len(self._other_trees))]
1389
1356
 
1390
1357
        master_has_more = True
1391
1358
        step_one = self._step_one
1465
1432
        #       might ensure better ordering, in case a caller strictly
1466
1433
        #       requires parents before children.
1467
1434
        for idx, other_extra in enumerate(self._others_extra):
1468
 
            others = sorted(other_extra.itervalues(),
 
1435
            others = sorted(viewvalues(other_extra),
1469
1436
                            key=lambda x: self._path_to_key(x[0]))
1470
1437
            for other_path, other_ie in others:
1471
1438
                file_id = other_ie.file_id
1473
1440
                # the lookup_by_file_id will be removing anything processed
1474
1441
                # from the extras cache
1475
1442
                other_extra.pop(file_id)
1476
 
                other_values = [(None, None) for i in xrange(idx)]
 
1443
                other_values = [(None, None)] * idx
1477
1444
                other_values.append((other_path, other_ie))
1478
1445
                for alt_idx, alt_extra in enumerate(self._others_extra[idx+1:]):
1479
1446
                    alt_idx = alt_idx + idx + 1