← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

  • Committer: Patch Queue Manager
  • Date: 2016-04-21 04:10:52 UTC
  • mfrom: (6616.1.1 fix-en-user-guide)
  • Revision ID: pqm@pqm.ubuntu.com-20160421041052-clcye7ns1qcl2n7w
(richard-wilbur) Ensure build of English use guide always uses English text
 even when user's locale specifies a different language. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tree.py
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
23
 
22
24
from bzrlib.lazy_import import lazy_import
35
37
    rules,
36
38
    trace,
37
39
    )
 
40
from bzrlib.i18n import gettext
38
41
""")
39
42
 
40
43
from bzrlib.decorators import needs_read_lock
41
44
from bzrlib.inter import InterObject
 
45
from bzrlib.symbol_versioning import (
 
46
    deprecated_in,
 
47
    deprecated_method,
 
48
    )
42
49
 
43
50
 
44
51
class Tree(object):
54
61
    trees or versioned trees.
55
62
    """
56
63
 
 
64
    def has_versioned_directories(self):
 
65
        """Whether this tree can contain explicitly versioned directories.
 
66
 
 
67
        This defaults to True, but some implementations may want to override
 
68
        it.
 
69
        """
 
70
        return True
 
71
 
57
72
    def changes_from(self, other, want_unchanged=False, specific_files=None,
58
73
        extra_trees=None, require_versioned=False, include_root=False,
59
74
        want_unversioned=False):
123
138
    def has_id(self, file_id):
124
139
        raise NotImplementedError(self.has_id)
125
140
 
 
141
    @deprecated_method(deprecated_in((2, 4, 0)))
126
142
    def __contains__(self, file_id):
127
143
        return self.has_id(file_id)
128
144
 
137
153
        """
138
154
        return False
139
155
 
140
 
    def __iter__(self):
141
 
        """Yield all file ids in this tree."""
142
 
        raise NotImplementedError(self.__iter__)
143
 
 
144
156
    def all_file_ids(self):
145
157
        """Iterate through all file ids, including ids for missing files."""
146
 
        return set(self.inventory)
 
158
        raise NotImplementedError(self.all_file_ids)
147
159
 
148
160
    def id2path(self, file_id):
149
161
        """Return the path for a file id.
174
186
             g
175
187
 
176
188
        The yield order (ignoring root) would be::
 
189
 
177
190
          a, f, a/b, a/d, a/b/c, a/d/e, f/g
178
191
 
179
192
        :param yield_parents: If True, yield the parents from the root leading
182
195
        """
183
196
        raise NotImplementedError(self.iter_entries_by_dir)
184
197
 
 
198
    def iter_child_entries(self, file_id, path=None):
 
199
        """Iterate over the children of a directory or tree reference.
 
200
 
 
201
        :param file_id: File id of the directory/tree-reference
 
202
        :param path: Optional path of the directory
 
203
        :raise NoSuchId: When the file_id does not exist
 
204
        :return: Iterator over entries in the directory
 
205
        """
 
206
        raise NotImplementedError(self.iter_child_entries)
 
207
 
185
208
    def list_files(self, include_root=False, from_dir=None, recursive=True):
186
209
        """List all files in this tree.
187
210
 
275
298
 
276
299
        :param file_id: The file_id of the file.
277
300
        :param path: The path of the file.
 
301
 
278
302
        If both file_id and path are supplied, an implementation may use
279
303
        either one.
 
304
 
 
305
        :returns: A single byte string for the whole file.
280
306
        """
281
307
        my_file = self.get_file(file_id, path)
282
308
        try:
289
315
 
290
316
        :param file_id: The file_id of the file.
291
317
        :param path: The path of the file.
 
318
 
292
319
        If both file_id and path are supplied, an implementation may use
293
320
        either one.
294
321
        """
295
322
        return osutils.split_lines(self.get_file_text(file_id, path))
296
323
 
297
 
    def get_file_sha1(self, file_id, path=None):
 
324
    def get_file_verifier(self, file_id, path=None, stat_value=None):
 
325
        """Return a verifier for a file.
 
326
 
 
327
        The default implementation returns a sha1.
 
328
 
 
329
        :param file_id: The handle for this file.
 
330
        :param path: The path that this file can be found at.
 
331
            These must point to the same object.
 
332
        :param stat_value: Optional stat value for the object
 
333
        :return: Tuple with verifier name and verifier data
 
334
        """
 
335
        return ("SHA1", self.get_file_sha1(file_id, path=path,
 
336
            stat_value=stat_value))
 
337
 
 
338
    def get_file_sha1(self, file_id, path=None, stat_value=None):
298
339
        """Return the SHA1 file for a file.
299
340
 
 
341
        :note: callers should use get_file_verifier instead
 
342
            where possible, as the underlying repository implementation may
 
343
            have quicker access to a non-sha1 verifier.
 
344
 
300
345
        :param file_id: The handle for this file.
301
346
        :param path: The path that this file can be found at.
302
347
            These must point to the same object.
 
348
        :param stat_value: Optional stat value for the object
303
349
        """
304
350
        raise NotImplementedError(self.get_file_sha1)
305
351
 
321
367
        """
322
368
        raise NotImplementedError(self.get_file_size)
323
369
 
324
 
    def get_file_by_path(self, path):
325
 
        raise NotImplementedError(self.get_file_by_path)
326
 
 
327
370
    def is_executable(self, file_id, path=None):
328
371
        """Check if a file is executable.
329
372
 
359
402
            cur_file = (self.get_file_text(file_id),)
360
403
            yield identifier, cur_file
361
404
 
362
 
    def get_symlink_target(self, file_id):
 
405
    def get_symlink_target(self, file_id, path=None):
363
406
        """Get the target for a given file_id.
364
407
 
365
408
        It is assumed that the caller already knows that file_id is referencing
366
409
        a symlink.
367
410
        :param file_id: Handle for the symlink entry.
 
411
        :param path: The path of the file.
 
412
        If both file_id and path are supplied, an implementation may use
 
413
        either one.
368
414
        :return: The path the symlink points to.
369
415
        """
370
416
        raise NotImplementedError(self.get_symlink_target)
371
417
 
372
 
 
373
418
    def get_root_id(self):
374
419
        """Return the file_id for the root of this tree."""
375
420
        raise NotImplementedError(self.get_root_id)
497
542
        return find_ids_across_trees(paths, [self] + list(trees), require_versioned)
498
543
 
499
544
    def iter_children(self, file_id):
500
 
        entry = self.iter_entries_by_dir([file_id]).next()[1]
501
 
        for child in getattr(entry, 'children', {}).itervalues():
502
 
            yield child.file_id
 
545
        """Iterate over the file ids of the children of an entry.
 
546
 
 
547
        :param file_id: File id of the entry
 
548
        :return: Iterator over child file ids.
 
549
        """
 
550
        raise NotImplementedError(self.iter_children)
503
551
 
504
552
    def lock_read(self):
505
553
        """Lock this tree for multiple read only operations.
506
 
        
 
554
 
507
555
        :return: A bzrlib.lock.LogicalLockResult.
508
556
        """
509
557
        pass
596
644
        prefs = self.iter_search_rules([path], filter_pref_names).next()
597
645
        stk = filters._get_filter_stack_for(prefs)
598
646
        if 'filters' in debug.debug_flags:
599
 
            trace.note("*** %s content-filter: %s => %r" % (path,prefs,stk))
 
647
            trace.note(gettext("*** {0} content-filter: {1} => {2!r}").format(path,prefs,stk))
600
648
        return stk
601
649
 
602
650
    def _content_filter_stack_provider(self):
733
781
            yield cur_path
734
782
        # all done.
735
783
 
 
784
    @deprecated_method(deprecated_in((2, 5, 0)))
736
785
    def _get_inventory(self):
737
786
        return self._inventory
738
787
 
739
788
    inventory = property(_get_inventory,
740
789
                         doc="Inventory of this Tree")
741
790
 
 
791
    def _get_root_inventory(self):
 
792
        return self._inventory
 
793
 
 
794
    root_inventory = property(_get_root_inventory,
 
795
        doc="Root inventory of this tree")
 
796
 
 
797
    def _unpack_file_id(self, file_id):
 
798
        """Find the inventory and inventory file id for a tree file id.
 
799
 
 
800
        :param file_id: The tree file id, as bytestring or tuple
 
801
        :return: Inventory and inventory file id
 
802
        """
 
803
        if isinstance(file_id, tuple):
 
804
            if len(file_id) != 1:
 
805
                raise ValueError("nested trees not yet supported: %r" % file_id)
 
806
            file_id = file_id[0]
 
807
        return self.root_inventory, file_id
 
808
 
742
809
    @needs_read_lock
743
810
    def path2id(self, path):
744
811
        """Return the id for path in this tree."""
745
 
        return self._inventory.path2id(path)
 
812
        return self._path2inv_file_id(path)[1]
 
813
 
 
814
    def _path2inv_file_id(self, path):
 
815
        """Lookup a inventory and inventory file id by path.
 
816
 
 
817
        :param path: Path to look up
 
818
        :return: tuple with inventory and inventory file id
 
819
        """
 
820
        # FIXME: Support nested trees
 
821
        return self.root_inventory, self.root_inventory.path2id(path)
746
822
 
747
823
    def id2path(self, file_id):
748
824
        """Return the path for a file id.
749
825
 
750
826
        :raises NoSuchId:
751
827
        """
752
 
        return self.inventory.id2path(file_id)
 
828
        inventory, file_id = self._unpack_file_id(file_id)
 
829
        return inventory.id2path(file_id)
753
830
 
754
831
    def has_id(self, file_id):
755
 
        return self.inventory.has_id(file_id)
 
832
        inventory, file_id = self._unpack_file_id(file_id)
 
833
        return inventory.has_id(file_id)
756
834
 
757
835
    def has_or_had_id(self, file_id):
758
 
        return self.inventory.has_id(file_id)
759
 
 
 
836
        inventory, file_id = self._unpack_file_id(file_id)
 
837
        return inventory.has_id(file_id)
 
838
 
 
839
    def all_file_ids(self):
 
840
        return set(
 
841
            [entry.file_id for path, entry in self.iter_entries_by_dir()])
 
842
 
 
843
    @deprecated_method(deprecated_in((2, 4, 0)))
760
844
    def __iter__(self):
761
 
        return iter(self.inventory)
 
845
        return iter(self.all_file_ids())
762
846
 
763
847
    def filter_unversioned_files(self, paths):
764
848
        """Filter out paths that are versioned.
768
852
        # NB: we specifically *don't* call self.has_filename, because for
769
853
        # WorkingTrees that can indicate files that exist on disk but that
770
854
        # are not versioned.
771
 
        pred = self.inventory.has_filename
772
 
        return set((p for p in paths if not pred(p)))
 
855
        return set((p for p in paths if self.path2id(p) is None))
773
856
 
774
857
    @needs_read_lock
775
858
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
784
867
            down to specific_file_ids that have been requested. This has no
785
868
            impact if specific_file_ids is None.
786
869
        """
787
 
        return self.inventory.iter_entries_by_dir(
788
 
            specific_file_ids=specific_file_ids, yield_parents=yield_parents)
789
 
 
 
870
        if specific_file_ids is None:
 
871
            inventory_file_ids = None
 
872
        else:
 
873
            inventory_file_ids = []
 
874
            for tree_file_id in specific_file_ids:
 
875
                inventory, inv_file_id = self._unpack_file_id(tree_file_id)
 
876
                if not inventory is self.root_inventory: # for now
 
877
                    raise AssertionError("%r != %r" % (
 
878
                        inventory, self.root_inventory))
 
879
                inventory_file_ids.append(inv_file_id)
 
880
        # FIXME: Handle nested trees
 
881
        return self.root_inventory.iter_entries_by_dir(
 
882
            specific_file_ids=inventory_file_ids, yield_parents=yield_parents)
 
883
 
 
884
    @needs_read_lock
 
885
    def iter_child_entries(self, file_id, path=None):
 
886
        inv, inv_file_id = self._unpack_file_id(file_id)
 
887
        return inv[inv_file_id].children.itervalues()
 
888
 
 
889
    @deprecated_method(deprecated_in((2, 5, 0)))
790
890
    def get_file_by_path(self, path):
791
 
        return self.get_file(self._inventory.path2id(path), path)
792
 
 
793
 
 
794
 
######################################################################
795
 
# diff
796
 
 
797
 
# TODO: Merge these two functions into a single one that can operate
798
 
# on either a whole tree or a set of files.
799
 
 
800
 
# TODO: Return the diff in order by filename, not by category or in
801
 
# random order.  Can probably be done by lock-stepping through the
802
 
# filenames from both trees.
803
 
 
804
 
 
805
 
def file_status(filename, old_tree, new_tree):
806
 
    """Return single-letter status, old and new names for a file.
807
 
 
808
 
    The complexity here is in deciding how to represent renames;
809
 
    many complex cases are possible.
810
 
    """
811
 
    old_inv = old_tree.inventory
812
 
    new_inv = new_tree.inventory
813
 
    new_id = new_inv.path2id(filename)
814
 
    old_id = old_inv.path2id(filename)
815
 
 
816
 
    if not new_id and not old_id:
817
 
        # easy: doesn't exist in either; not versioned at all
818
 
        if new_tree.is_ignored(filename):
819
 
            return 'I', None, None
820
 
        else:
821
 
            return '?', None, None
822
 
    elif new_id:
823
 
        # There is now a file of this name, great.
824
 
        pass
825
 
    else:
826
 
        # There is no longer a file of this name, but we can describe
827
 
        # what happened to the file that used to have
828
 
        # this name.  There are two possibilities: either it was
829
 
        # deleted entirely, or renamed.
830
 
        if new_inv.has_id(old_id):
831
 
            return 'X', old_inv.id2path(old_id), new_inv.id2path(old_id)
832
 
        else:
833
 
            return 'D', old_inv.id2path(old_id), None
834
 
 
835
 
    # if the file_id is new in this revision, it is added
836
 
    if new_id and not old_inv.has_id(new_id):
837
 
        return 'A'
838
 
 
839
 
    # if there used to be a file of this name, but that ID has now
840
 
    # disappeared, it is deleted
841
 
    if old_id and not new_inv.has_id(old_id):
842
 
        return 'D'
843
 
 
844
 
    return 'wtf?'
 
891
        return self.get_file(self.path2id(path), path)
 
892
 
 
893
    def iter_children(self, file_id, path=None):
 
894
        """See Tree.iter_children."""
 
895
        entry = self.iter_entries_by_dir([file_id]).next()[1]
 
896
        for child in getattr(entry, 'children', {}).itervalues():
 
897
            yield child.file_id
845
898
 
846
899
 
847
900
def find_ids_across_trees(filenames, trees, require_versioned=True):
854
907
        None)
855
908
    :param trees: The trees to find file_ids within
856
909
    :param require_versioned: if true, all specified filenames must occur in
857
 
    at least one tree.
 
910
        at least one tree.
858
911
    :return: a set of file ids for the specified filenames and their children.
859
912
    """
860
913
    if not filenames:
936
989
 
937
990
    _optimisers = []
938
991
 
 
992
    @classmethod
 
993
    def is_compatible(kls, source, target):
 
994
        # The default implementation is naive and uses the public API, so
 
995
        # it works for all trees.
 
996
        return True
 
997
 
939
998
    def _changes_from_entries(self, source_entry, target_entry,
940
999
        source_path=None, target_path=None):
941
1000
        """Generate a iter_changes tuple between source_entry and target_entry.
989
1048
        if source_kind != target_kind:
990
1049
            changed_content = True
991
1050
        elif source_kind == 'file':
992
 
            if (self.source.get_file_sha1(file_id, source_path, source_stat) !=
993
 
                self.target.get_file_sha1(file_id, target_path, target_stat)):
 
1051
            if not self.file_content_matches(file_id, file_id, source_path,
 
1052
                    target_path, source_stat, target_stat):
994
1053
                changed_content = True
995
1054
        elif source_kind == 'symlink':
996
1055
            if (self.source.get_symlink_target(file_id) !=
997
1056
                self.target.get_symlink_target(file_id)):
998
1057
                changed_content = True
999
 
            # XXX: Yes, the indentation below is wrong. But fixing it broke
1000
 
            # test_merge.TestMergerEntriesLCAOnDisk.
1001
 
            # test_nested_tree_subtree_renamed_and_modified. We'll wait for
1002
 
            # the fix from bzr.dev -- vila 2009026
1003
 
            elif source_kind == 'tree-reference':
1004
 
                if (self.source.get_reference_revision(file_id, source_path)
1005
 
                    != self.target.get_reference_revision(file_id, target_path)):
 
1058
        elif source_kind == 'tree-reference':
 
1059
            if (self.source.get_reference_revision(file_id, source_path)
 
1060
                != self.target.get_reference_revision(file_id, target_path)):
1006
1061
                    changed_content = True
1007
1062
        parent = (source_parent, target_parent)
1008
1063
        name = (source_name, target_name)
1223
1278
        :param file_id: The file_id to lookup.
1224
1279
        """
1225
1280
        try:
1226
 
            inventory = tree.inventory
 
1281
            inventory = tree.root_inventory
1227
1282
        except NotImplementedError:
1228
1283
            # No inventory available.
1229
1284
            try:
1304
1359
                        if old_entry is None:
1305
1360
                            # Reusing a discarded change.
1306
1361
                            old_entry = self._get_entry(self.source, file_id)
1307
 
                        for child in old_entry.children.values():
1308
 
                            precise_file_ids.add(child.file_id)
 
1362
                        precise_file_ids.update(
 
1363
                                self.source.iter_children(file_id))
1309
1364
                    changed_file_ids.add(result[0])
1310
1365
                    yield result
1311
1366
 
 
1367
    @needs_read_lock
 
1368
    def file_content_matches(self, source_file_id, target_file_id,
 
1369
            source_path=None, target_path=None, source_stat=None, target_stat=None):
 
1370
        """Check if two files are the same in the source and target trees.
 
1371
 
 
1372
        This only checks that the contents of the files are the same,
 
1373
        it does not touch anything else.
 
1374
 
 
1375
        :param source_file_id: File id of the file in the source tree
 
1376
        :param target_file_id: File id of the file in the target tree
 
1377
        :param source_path: Path of the file in the source tree
 
1378
        :param target_path: Path of the file in the target tree
 
1379
        :param source_stat: Optional stat value of the file in the source tree
 
1380
        :param target_stat: Optional stat value of the file in the target tree
 
1381
        :return: Boolean indicating whether the files have the same contents
 
1382
        """
 
1383
        source_verifier_kind, source_verifier_data = self.source.get_file_verifier(
 
1384
            source_file_id, source_path, source_stat)
 
1385
        target_verifier_kind, target_verifier_data = self.target.get_file_verifier(
 
1386
            target_file_id, target_path, target_stat)
 
1387
        if source_verifier_kind == target_verifier_kind:
 
1388
            return (source_verifier_data == target_verifier_data)
 
1389
        # Fall back to SHA1 for now
 
1390
        if source_verifier_kind != "SHA1":
 
1391
            source_sha1 = self.source.get_file_sha1(source_file_id,
 
1392
                    source_path, source_stat)
 
1393
        else:
 
1394
            source_sha1 = source_verifier_data
 
1395
        if target_verifier_kind != "SHA1":
 
1396
            target_sha1 = self.target.get_file_sha1(target_file_id,
 
1397
                    target_path, target_stat)
 
1398
        else:
 
1399
            target_sha1 = target_verifier_data
 
1400
        return (source_sha1 == target_sha1)
 
1401
 
 
1402
InterTree.register_optimiser(InterTree)
 
1403
 
1312
1404
 
1313
1405
class MultiWalker(object):
1314
1406
    """Walk multiple trees simultaneously, getting combined results."""
1417
1509
            return (None, None)
1418
1510
        else:
1419
1511
            self._out_of_order_processed.add(file_id)
1420
 
            cur_ie = other_tree.inventory[file_id]
 
1512
            cur_ie = other_tree.root_inventory[file_id]
1421
1513
            return (cur_path, cur_ie)
1422
1514
 
1423
1515
    def iter_all(self):