~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

  • Committer: Jelmer Vernooij
  • Date: 2010-08-28 11:19:49 UTC
  • mto: This revision was merged to the branch mainline in revision 5418.
  • Revision ID: jelmer@samba.org-20100828111949-6ke9opiop2oomr4f
Move get_config to ControlDir.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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
18
18
"""
19
19
 
20
20
import os
21
 
 
22
 
from bzrlib.lazy_import import lazy_import
23
 
lazy_import(globals(), """
24
 
import collections
25
 
 
 
21
from collections import deque
 
22
 
 
23
import bzrlib
26
24
from bzrlib import (
27
25
    conflicts as _mod_conflicts,
28
26
    debug,
29
27
    delta,
30
 
    errors,
31
28
    filters,
32
 
    inventory,
33
29
    osutils,
34
30
    revision as _mod_revision,
35
31
    rules,
36
 
    trace,
37
32
    )
38
 
""")
39
 
 
40
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
41
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
42
41
 
43
42
 
44
43
class Tree(object):
50
49
 
51
50
    * `RevisionTree` is a tree as recorded at some point in the past.
52
51
 
 
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
 
53
59
    Trees can be compared, etc, regardless of whether they are working
54
60
    trees or versioned trees.
55
61
    """
121
127
        raise NotImplementedError(self.has_filename)
122
128
 
123
129
    def has_id(self, file_id):
124
 
        raise NotImplementedError(self.has_id)
 
130
        return self.inventory.has_id(file_id)
125
131
 
126
132
    def __contains__(self, file_id):
127
133
        return self.has_id(file_id)
128
134
 
129
135
    def has_or_had_id(self, file_id):
130
 
        raise NotImplementedError(self.has_or_had_id)
 
136
        return self.inventory.has_id(file_id)
131
137
 
132
138
    def is_ignored(self, filename):
133
139
        """Check whether the filename is ignored by this tree.
138
144
        return False
139
145
 
140
146
    def __iter__(self):
141
 
        """Yield all file ids in this tree."""
142
 
        raise NotImplementedError(self.__iter__)
 
147
        return iter(self.inventory)
143
148
 
144
149
    def all_file_ids(self):
145
150
        """Iterate through all file ids, including ids for missing files."""
150
155
 
151
156
        :raises NoSuchId:
152
157
        """
153
 
        raise NotImplementedError(self.id2path)
154
 
 
 
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
155
173
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
156
174
        """Walk the tree in 'by_dir' order.
157
175
 
180
198
            down to specific_file_ids that have been requested. This has no
181
199
            impact if specific_file_ids is None.
182
200
        """
183
 
        raise NotImplementedError(self.iter_entries_by_dir)
184
 
 
185
 
    def list_files(self, include_root=False, from_dir=None, recursive=True):
186
 
        """List all files in this tree.
187
 
 
188
 
        :param include_root: Whether to include the entry for the tree root
189
 
        :param from_dir: Directory under which to list files
190
 
        :param recursive: Whether to list files recursively
191
 
        :return: iterator over tuples of (path, versioned, kind, file_id,
192
 
            inventory entry)
193
 
        """
194
 
        raise NotImplementedError(self.list_files)
 
201
        return self.inventory.iter_entries_by_dir(
 
202
            specific_file_ids=specific_file_ids, yield_parents=yield_parents)
195
203
 
196
204
    def iter_references(self):
197
205
        if self.supports_tree_reference():
248
256
    def _file_size(self, entry, stat_value):
249
257
        raise NotImplementedError(self._file_size)
250
258
 
 
259
    def _get_inventory(self):
 
260
        return self._inventory
 
261
 
251
262
    def get_file(self, file_id, path=None):
252
263
        """Return a file object for the file file_id in the tree.
253
264
 
294
305
        """
295
306
        return osutils.split_lines(self.get_file_text(file_id, path))
296
307
 
297
 
    def get_file_sha1(self, file_id, path=None):
298
 
        """Return the SHA1 file for a file.
299
 
 
300
 
        :param file_id: The handle for this file.
301
 
        :param path: The path that this file can be found at.
302
 
            These must point to the same object.
303
 
        """
304
 
        raise NotImplementedError(self.get_file_sha1)
305
 
 
306
308
    def get_file_mtime(self, file_id, path=None):
307
309
        """Return the modification time for a file.
308
310
 
322
324
        raise NotImplementedError(self.get_file_size)
323
325
 
324
326
    def get_file_by_path(self, path):
325
 
        raise NotImplementedError(self.get_file_by_path)
326
 
 
327
 
    def is_executable(self, file_id, path=None):
328
 
        """Check if a file is executable.
329
 
 
330
 
        :param file_id: The handle for this file.
331
 
        :param path: The path that this file can be found at.
332
 
            These must point to the same object.
333
 
        """
334
 
        raise NotImplementedError(self.is_executable)
 
327
        return self.get_file(self._inventory.path2id(path), path)
335
328
 
336
329
    def iter_files_bytes(self, desired_files):
337
330
        """Iterate through file contents.
369
362
        """
370
363
        raise NotImplementedError(self.get_symlink_target)
371
364
 
 
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.
372
442
 
373
443
    def get_root_id(self):
374
444
        """Return the file_id for the root of this tree."""
433
503
            except errors.NoSuchRevisionInTree:
434
504
                yield self.repository.revision_tree(revision_id)
435
505
 
 
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
 
436
515
    def _get_file_revision(self, file_id, vf, tree_revision):
437
516
        """Ensure that file_id, tree_revision is in vf to plan the merge."""
438
517
 
439
518
        if getattr(self, '_repository', None) is None:
440
519
            last_revision = tree_revision
441
 
            parent_keys = [(file_id, t.get_file_revision(file_id)) for t in
 
520
            parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
442
521
                self._iter_parent_trees()]
443
522
            vf.add_lines((file_id, last_revision), parent_keys,
444
523
                         self.get_file_lines(file_id))
445
524
            repo = self.branch.repository
446
525
            base_vf = repo.texts
447
526
        else:
448
 
            last_revision = self.get_file_revision(file_id)
 
527
            last_revision = self._file_revision(self, file_id)
449
528
            base_vf = self._repository.texts
450
529
        if base_vf not in vf.fallback_versionedfiles:
451
530
            vf.fallback_versionedfiles.append(base_vf)
452
531
        return last_revision
453
532
 
 
533
    inventory = property(_get_inventory,
 
534
                         doc="Inventory of this Tree")
 
535
 
454
536
    def _check_retrieved(self, ie, f):
455
537
        if not __debug__:
456
538
            return
457
 
        fp = osutils.fingerprint_file(f)
 
539
        fp = fingerprint_file(f)
458
540
        f.seek(0)
459
541
 
460
542
        if ie.text_size is not None:
461
543
            if ie.text_size != fp['size']:
462
 
                raise errors.BzrError(
463
 
                        "mismatched size for file %r in %r" %
464
 
                        (ie.file_id, self._store),
 
544
                raise BzrError("mismatched size for file %r in %r" % (ie.file_id, self._store),
465
545
                        ["inventory expects %d bytes" % ie.text_size,
466
546
                         "file is actually %d bytes" % fp['size'],
467
547
                         "store is probably damaged/corrupt"])
468
548
 
469
549
        if ie.text_sha1 != fp['sha1']:
470
 
            raise errors.BzrError("wrong SHA-1 for file %r in %r" %
471
 
                    (ie.file_id, self._store),
 
550
            raise BzrError("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
472
551
                    ["inventory expects %s" % ie.text_sha1,
473
552
                     "file is actually %s" % fp['sha1'],
474
553
                     "store is probably damaged/corrupt"])
475
554
 
 
555
    @needs_read_lock
476
556
    def path2id(self, path):
477
557
        """Return the id for path in this tree."""
478
 
        raise NotImplementedError(self.path2id)
 
558
        return self._inventory.path2id(path)
479
559
 
480
560
    def paths2ids(self, paths, trees=[], require_versioned=True):
481
561
        """Return all the ids that can be reached by walking from paths.
538
618
 
539
619
        :return: set of paths.
540
620
        """
541
 
        raise NotImplementedError(self.filter_unversioned_files)
 
621
        # NB: we specifically *don't* call self.has_filename, because for
 
622
        # WorkingTrees that can indicate files that exist on disk but that
 
623
        # are not versioned.
 
624
        pred = self.inventory.has_filename
 
625
        return set((p for p in paths if not pred(p)))
542
626
 
543
627
    def walkdirs(self, prefix=""):
544
628
        """Walk the contents of this tree from path down.
596
680
        prefs = self.iter_search_rules([path], filter_pref_names).next()
597
681
        stk = filters._get_filter_stack_for(prefs)
598
682
        if 'filters' in debug.debug_flags:
599
 
            trace.note("*** %s content-filter: %s => %r" % (path,prefs,stk))
 
683
            note("*** %s content-filter: %s => %r" % (path,prefs,stk))
600
684
        return stk
601
685
 
602
686
    def _content_filter_stack_provider(self):
641
725
        return searcher
642
726
 
643
727
 
644
 
class InventoryTree(Tree):
645
 
    """A tree that relies on an inventory for its metadata.
646
 
 
647
 
    Trees contain an `Inventory` object, and also know how to retrieve
648
 
    file texts mentioned in the inventory, either from a working
649
 
    directory or from a store.
650
 
 
651
 
    It is possible for trees to contain files that are not described
652
 
    in their inventory or vice versa; for this use `filenames()`.
653
 
 
654
 
    Subclasses should set the _inventory attribute, which is considered
655
 
    private to external API users.
656
 
    """
657
 
 
658
 
    def get_canonical_inventory_paths(self, paths):
659
 
        """Like get_canonical_inventory_path() but works on multiple items.
660
 
 
661
 
        :param paths: A sequence of paths relative to the root of the tree.
662
 
        :return: A list of paths, with each item the corresponding input path
663
 
        adjusted to account for existing elements that match case
664
 
        insensitively.
665
 
        """
666
 
        return list(self._yield_canonical_inventory_paths(paths))
667
 
 
668
 
    def get_canonical_inventory_path(self, path):
669
 
        """Returns the first inventory item that case-insensitively matches path.
670
 
 
671
 
        If a path matches exactly, it is returned. If no path matches exactly
672
 
        but more than one path matches case-insensitively, it is implementation
673
 
        defined which is returned.
674
 
 
675
 
        If no path matches case-insensitively, the input path is returned, but
676
 
        with as many path entries that do exist changed to their canonical
677
 
        form.
678
 
 
679
 
        If you need to resolve many names from the same tree, you should
680
 
        use get_canonical_inventory_paths() to avoid O(N) behaviour.
681
 
 
682
 
        :param path: A paths relative to the root of the tree.
683
 
        :return: The input path adjusted to account for existing elements
684
 
        that match case insensitively.
685
 
        """
686
 
        return self._yield_canonical_inventory_paths([path]).next()
687
 
 
688
 
    def _yield_canonical_inventory_paths(self, paths):
689
 
        for path in paths:
690
 
            # First, if the path as specified exists exactly, just use it.
691
 
            if self.path2id(path) is not None:
692
 
                yield path
693
 
                continue
694
 
            # go walkin...
695
 
            cur_id = self.get_root_id()
696
 
            cur_path = ''
697
 
            bit_iter = iter(path.split("/"))
698
 
            for elt in bit_iter:
699
 
                lelt = elt.lower()
700
 
                new_path = None
701
 
                for child in self.iter_children(cur_id):
702
 
                    try:
703
 
                        # XXX: it seem like if the child is known to be in the
704
 
                        # tree, we shouldn't need to go from its id back to
705
 
                        # its path -- mbp 2010-02-11
706
 
                        #
707
 
                        # XXX: it seems like we could be more efficient
708
 
                        # by just directly looking up the original name and
709
 
                        # only then searching all children; also by not
710
 
                        # chopping paths so much. -- mbp 2010-02-11
711
 
                        child_base = os.path.basename(self.id2path(child))
712
 
                        if (child_base == elt):
713
 
                            # if we found an exact match, we can stop now; if
714
 
                            # we found an approximate match we need to keep
715
 
                            # searching because there might be an exact match
716
 
                            # later.  
717
 
                            cur_id = child
718
 
                            new_path = osutils.pathjoin(cur_path, child_base)
719
 
                            break
720
 
                        elif child_base.lower() == lelt:
721
 
                            cur_id = child
722
 
                            new_path = osutils.pathjoin(cur_path, child_base)
723
 
                    except errors.NoSuchId:
724
 
                        # before a change is committed we can see this error...
725
 
                        continue
726
 
                if new_path:
727
 
                    cur_path = new_path
728
 
                else:
729
 
                    # got to the end of this directory and no entries matched.
730
 
                    # Return what matched so far, plus the rest as specified.
731
 
                    cur_path = osutils.pathjoin(cur_path, elt, *list(bit_iter))
732
 
                    break
733
 
            yield cur_path
734
 
        # all done.
735
 
 
736
 
    def _get_inventory(self):
737
 
        return self._inventory
738
 
 
739
 
    inventory = property(_get_inventory,
740
 
                         doc="Inventory of this Tree")
741
 
 
742
 
    @needs_read_lock
743
 
    def path2id(self, path):
744
 
        """Return the id for path in this tree."""
745
 
        return self._inventory.path2id(path)
746
 
 
747
 
    def id2path(self, file_id):
748
 
        """Return the path for a file id.
749
 
 
750
 
        :raises NoSuchId:
751
 
        """
752
 
        return self.inventory.id2path(file_id)
753
 
 
754
 
    def has_id(self, file_id):
755
 
        return self.inventory.has_id(file_id)
756
 
 
757
 
    def has_or_had_id(self, file_id):
758
 
        return self.inventory.has_id(file_id)
759
 
 
760
 
    def __iter__(self):
761
 
        return iter(self.inventory)
762
 
 
763
 
    def filter_unversioned_files(self, paths):
764
 
        """Filter out paths that are versioned.
765
 
 
766
 
        :return: set of paths.
767
 
        """
768
 
        # NB: we specifically *don't* call self.has_filename, because for
769
 
        # WorkingTrees that can indicate files that exist on disk but that
770
 
        # are not versioned.
771
 
        pred = self.inventory.has_filename
772
 
        return set((p for p in paths if not pred(p)))
773
 
 
774
 
    @needs_read_lock
775
 
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
776
 
        """Walk the tree in 'by_dir' order.
777
 
 
778
 
        This will yield each entry in the tree as a (path, entry) tuple.
779
 
        The order that they are yielded is:
780
 
 
781
 
        See Tree.iter_entries_by_dir for details.
782
 
 
783
 
        :param yield_parents: If True, yield the parents from the root leading
784
 
            down to specific_file_ids that have been requested. This has no
785
 
            impact if specific_file_ids is None.
786
 
        """
787
 
        return self.inventory.iter_entries_by_dir(
788
 
            specific_file_ids=specific_file_ids, yield_parents=yield_parents)
789
 
 
790
 
    def get_file_by_path(self, path):
791
 
        return self.get_file(self._inventory.path2id(path), path)
792
 
 
793
 
 
794
728
######################################################################
795
729
# diff
796
730
 
844
778
    return 'wtf?'
845
779
 
846
780
 
 
781
@deprecated_function(deprecated_in((1, 9, 0)))
 
782
def find_renames(old_inv, new_inv):
 
783
    for file_id in old_inv:
 
784
        if file_id not in new_inv:
 
785
            continue
 
786
        old_name = old_inv.id2path(file_id)
 
787
        new_name = new_inv.id2path(file_id)
 
788
        if old_name != new_name:
 
789
            yield (old_name, new_name)
 
790
 
 
791
 
847
792
def find_ids_across_trees(filenames, trees, require_versioned=True):
848
793
    """Find the ids corresponding to specified filenames.
849
794
 
1046
991
            # All files are unversioned, so just return an empty delta
1047
992
            # _compare_trees would think we want a complete delta
1048
993
            result = delta.TreeDelta()
1049
 
            fake_entry = inventory.InventoryFile('unused', 'unused', 'unused')
 
994
            fake_entry = InventoryFile('unused', 'unused', 'unused')
1050
995
            result.unversioned = [(path, None,
1051
996
                self.target._comparison_data(fake_entry, path)[0]) for path in
1052
997
                specific_files]
1117
1062
                                     self.target.extras()
1118
1063
                if specific_files is None or
1119
1064
                    osutils.is_inside_any(specific_files, p)])
1120
 
            all_unversioned = collections.deque(all_unversioned)
 
1065
            all_unversioned = deque(all_unversioned)
1121
1066
        else:
1122
 
            all_unversioned = collections.deque()
 
1067
            all_unversioned = deque()
1123
1068
        to_paths = {}
1124
1069
        from_entries_by_dir = list(self.source.iter_entries_by_dir(
1125
1070
            specific_file_ids=specific_file_ids))
1131
1076
        # the unversioned path lookup only occurs on real trees - where there
1132
1077
        # can be extras. So the fake_entry is solely used to look up
1133
1078
        # executable it values when execute is not supported.
1134
 
        fake_entry = inventory.InventoryFile('unused', 'unused', 'unused')
 
1079
        fake_entry = InventoryFile('unused', 'unused', 'unused')
1135
1080
        for target_path, target_entry in to_entries_by_dir:
1136
1081
            while (all_unversioned and
1137
1082
                all_unversioned[0][0] < target_path.split('/')):
1185
1130
            if file_id in to_paths:
1186
1131
                # already returned
1187
1132
                continue
1188
 
            if not self.target.has_id(file_id):
 
1133
            if file_id not in self.target.all_file_ids():
1189
1134
                # common case - paths we have not emitted are not present in
1190
1135
                # target.
1191
1136
                to_path = None