← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree_4.py

  • Committer: Ross Lagerwall
  • Date: 2012-08-07 06:32:51 UTC
  • mto: (6437.63.5 2.5)
  • mto: This revision was merged to the branch mainline in revision 6558.
  • Revision ID: rosslagerwall@gmail.com-20120807063251-x9p03ghg2ws8oqjc
Add bzrlib/locale to .bzrignore

bzrlib/locale is generated with ./setup.py build_mo which is in turn called
by ./setup.py build

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree_4.py
1
 
# Copyright (C) 2007-2012 Canonical Ltd
 
1
# Copyright (C) 2007-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
38
38
    cache_utf8,
39
39
    config,
40
40
    conflicts as _mod_conflicts,
41
 
    controldir,
42
41
    debug,
43
42
    dirstate,
44
43
    errors,
69
68
    realpath,
70
69
    safe_unicode,
71
70
    )
72
 
from bzrlib.symbol_versioning import (
73
 
    deprecated_in,
74
 
    deprecated_method,
75
 
    )
76
71
from bzrlib.transport.local import LocalTransport
77
72
from bzrlib.tree import (
78
73
    InterTree,
260
255
 
261
256
        :return: an integer. -1 means never save.
262
257
        """
263
 
        conf = self.get_config_stack()
 
258
        # FIXME: We want a WorkingTreeStack here -- vila 20110812
 
259
        conf = config.BranchStack(self.branch)
264
260
        return conf.get('bzr.workingtree.worth_saving_limit')
265
261
 
266
262
    def filter_unversioned_files(self, paths):
419
415
                return link_or_sha1
420
416
        return None
421
417
 
422
 
    def _get_root_inventory(self):
 
418
    def _get_inventory(self):
423
419
        """Get the inventory for the tree. This is only valid within a lock."""
424
420
        if 'evil' in debug.debug_flags:
425
421
            trace.mutter_callsite(2,
430
426
        self._generate_inventory()
431
427
        return self._inventory
432
428
 
433
 
    @deprecated_method(deprecated_in((2, 5, 0)))
434
 
    def _get_inventory(self):
435
 
        return self.root_inventory
436
 
 
437
429
    inventory = property(_get_inventory,
438
430
                         doc="Inventory of this Tree")
439
431
 
440
 
    root_inventory = property(_get_root_inventory,
441
 
        "Root inventory of this tree")
442
 
 
443
432
    @needs_read_lock
444
433
    def get_parent_ids(self):
445
434
        """See Tree.get_parent_ids.
692
681
 
693
682
        if self._inventory is not None:
694
683
            update_inventory = True
695
 
            inv = self.root_inventory
 
684
            inv = self.inventory
696
685
            to_dir_id = to_entry[0][2]
697
686
            to_dir_ie = inv[to_dir_id]
698
687
        else:
894
883
    @needs_read_lock
895
884
    def path2id(self, path):
896
885
        """Return the id for path in this tree."""
897
 
        if isinstance(path, list):
898
 
            if path == []:
899
 
                path = [""]
900
 
            path = osutils.pathjoin(*path)
901
886
        path = path.strip('/')
902
887
        entry = self._get_entry(path=path)
903
888
        if entry == (None, None):
1051
1036
 
1052
1037
        This is a meaningless operation for dirstate, but we obey it anyhow.
1053
1038
        """
1054
 
        return self.root_inventory
 
1039
        return self.inventory
1055
1040
 
1056
1041
    @needs_read_lock
1057
1042
    def revision_tree(self, revision_id):
1165
1150
                # _make_delta if we can't get the RevisionTree
1166
1151
                pass
1167
1152
            else:
1168
 
                delta = rev_tree.root_inventory._make_delta(
1169
 
                    basis_tree.root_inventory)
 
1153
                delta = rev_tree.inventory._make_delta(basis_tree.inventory)
1170
1154
                dirstate.update_basis_by_delta(delta, rev_id)
1171
1155
                updated = True
1172
1156
        if not updated:
1343
1327
        # being created.
1344
1328
        self._inventory = None
1345
1329
        # generate a delta,
1346
 
        delta = inv._make_delta(self.root_inventory)
 
1330
        delta = inv._make_delta(self.inventory)
1347
1331
        # and apply it.
1348
1332
        self.apply_inventory_delta(delta)
1349
1333
        if had_inventory:
1369
1353
            base_tree = trees[0][1]
1370
1354
        state = self.current_dirstate()
1371
1355
        # We don't support ghosts yet
1372
 
        state.set_state_from_scratch(base_tree.root_inventory, trees, [])
 
1356
        state.set_state_from_scratch(base_tree.inventory, trees, [])
1373
1357
 
1374
1358
 
1375
1359
class ContentFilterAwareSHA1Provider(dirstate.SHA1Provider):
1613
1597
    def _get_matchingbzrdir(self):
1614
1598
        """Overrideable method to get a bzrdir for testing."""
1615
1599
        # please test against something that will let us do tree references
1616
 
        return controldir.format_registry.make_bzrdir(
1617
 
            'development-subtree')
 
1600
        return bzrdir.format_registry.make_bzrdir(
 
1601
            'dirstate-with-subtree')
1618
1602
 
1619
1603
    _matchingbzrdir = property(__get_matchingbzrdir)
1620
1604
 
1693
1677
    def supports_views(self):
1694
1678
        return True
1695
1679
 
1696
 
    def _get_matchingbzrdir(self):
1697
 
        """Overrideable method to get a bzrdir for testing."""
1698
 
        # We use 'development-subtree' instead of '2a', because we have a
1699
 
        # few tests that want to test tree references
1700
 
        return bzrdir.format_registry.make_bzrdir('development-subtree')
1701
 
 
1702
1680
 
1703
1681
class DirStateRevisionTree(InventoryTree):
1704
1682
    """A revision tree pulling the inventory from a dirstate.
1787
1765
        if path is not None:
1788
1766
            path = path.encode('utf8')
1789
1767
        parent_index = self._get_parent_index()
1790
 
        return self._dirstate._get_entry(parent_index, fileid_utf8=file_id,
1791
 
            path_utf8=path)
 
1768
        return self._dirstate._get_entry(parent_index, fileid_utf8=file_id, path_utf8=path)
1792
1769
 
1793
1770
    def _generate_inventory(self):
1794
1771
        """Create and set self.inventory from the dirstate object.
1895
1872
 
1896
1873
    @needs_read_lock
1897
1874
    def get_file_revision(self, file_id):
1898
 
        inv, inv_file_id = self._unpack_file_id(file_id)
1899
 
        return inv[inv_file_id].revision
 
1875
        return self.inventory[file_id].revision
1900
1876
 
1901
1877
    def get_file(self, file_id, path=None):
1902
1878
        return StringIO(self.get_file_text(file_id))
1903
1879
 
1904
1880
    def get_file_size(self, file_id):
1905
1881
        """See Tree.get_file_size"""
1906
 
        inv, inv_file_id = self._unpack_file_id(file_id)
1907
 
        return inv[inv_file_id].text_size
 
1882
        return self.inventory[file_id].text_size
1908
1883
 
1909
1884
    def get_file_text(self, file_id, path=None):
1910
 
        content = None
1911
 
        for _, content_iter in self.iter_files_bytes([(file_id, None)]):
1912
 
            if content is not None:
1913
 
                raise AssertionError('iter_files_bytes returned'
1914
 
                    ' too many entries')
1915
 
            # For each entry returned by iter_files_bytes, we must consume the
1916
 
            # content_iter before we step the files iterator.
1917
 
            content = ''.join(content_iter)
1918
 
        if content is None:
1919
 
            raise AssertionError('iter_files_bytes did not return'
1920
 
                ' the requested data')
1921
 
        return content
 
1885
        _, content = list(self.iter_files_bytes([(file_id, None)]))[0]
 
1886
        return ''.join(content)
1922
1887
 
1923
1888
    def get_reference_revision(self, file_id, path=None):
1924
 
        inv, inv_file_id = self._unpack_file_id(file_id)
1925
 
        return inv[inv_file_id].reference_revision
 
1889
        return self.inventory[file_id].reference_revision
1926
1890
 
1927
1891
    def iter_files_bytes(self, desired_files):
1928
1892
        """See Tree.iter_files_bytes.
1952
1916
        """Return the revision id for this tree."""
1953
1917
        return self._revision_id
1954
1918
 
1955
 
    def _get_root_inventory(self):
 
1919
    def _get_inventory(self):
1956
1920
        if self._inventory is not None:
1957
1921
            return self._inventory
1958
1922
        self._must_be_locked()
1959
1923
        self._generate_inventory()
1960
1924
        return self._inventory
1961
1925
 
1962
 
    root_inventory = property(_get_root_inventory,
1963
 
                         doc="Inventory of this Tree")
1964
 
 
1965
 
    @deprecated_method(deprecated_in((2, 5, 0)))
1966
 
    def _get_inventory(self):
1967
 
        return self.root_inventory
1968
 
 
1969
1926
    inventory = property(_get_inventory,
1970
1927
                         doc="Inventory of this Tree")
1971
1928
 
1989
1946
 
1990
1947
    def path_content_summary(self, path):
1991
1948
        """See Tree.path_content_summary."""
1992
 
        inv, inv_file_id = self._path2inv_file_id(path)
1993
 
        if inv_file_id is None:
 
1949
        id = self.inventory.path2id(path)
 
1950
        if id is None:
1994
1951
            return ('missing', None, None, None)
1995
 
        entry = inv[inv_file_id]
 
1952
        entry = self._inventory[id]
1996
1953
        kind = entry.kind
1997
1954
        if kind == 'file':
1998
1955
            return (kind, entry.text_size, entry.executable, entry.text_sha1)
2002
1959
            return (kind, None, None, None)
2003
1960
 
2004
1961
    def is_executable(self, file_id, path=None):
2005
 
        inv, inv_file_id = self._unpack_file_id(file_id)
2006
 
        ie = inv[inv_file_id]
 
1962
        ie = self.inventory[file_id]
2007
1963
        if ie.kind != "file":
2008
1964
            return False
2009
1965
        return ie.executable
2014
1970
    def list_files(self, include_root=False, from_dir=None, recursive=True):
2015
1971
        # We use a standard implementation, because DirStateRevisionTree is
2016
1972
        # dealing with one of the parents of the current state
 
1973
        inv = self._get_inventory()
2017
1974
        if from_dir is None:
2018
 
            inv = self.root_inventory
2019
1975
            from_dir_id = None
2020
1976
        else:
2021
 
            inv, from_dir_id = self._path2inv_file_id(from_dir)
 
1977
            from_dir_id = inv.path2id(from_dir)
2022
1978
            if from_dir_id is None:
2023
1979
                # Directory not versioned
2024
1980
                return
2025
 
        # FIXME: Support nested trees
2026
1981
        entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
2027
1982
        if inv.root is not None and not include_root and from_dir is None:
2028
1983
            entries.next()
2050
2005
    def path2id(self, path):
2051
2006
        """Return the id for path in this tree."""
2052
2007
        # lookup by path: faster than splitting and walking the ivnentory.
2053
 
        if isinstance(path, list):
2054
 
            if path == []:
2055
 
                path = [""]
2056
 
            path = osutils.pathjoin(*path)
2057
2008
        entry = self._get_entry(path=path)
2058
2009
        if entry == (None, None):
2059
2010
            return None
2082
2033
        # So for now, we just build up the parent inventory, and extract
2083
2034
        # it the same way RevisionTree does.
2084
2035
        _directory = 'directory'
2085
 
        inv = self._get_root_inventory()
 
2036
        inv = self._get_inventory()
2086
2037
        top_id = inv.path2id(prefix)
2087
2038
        if top_id is None:
2088
2039
            pending = []