/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 bzrlib/workingtree_4.py

  • Committer: Martin Pool
  • Date: 2009-07-17 10:38:41 UTC
  • mfrom: (4536 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4558.
  • Revision ID: mbp@sourcefrog.net-20090717103841-z35onk04bkiw7zb6
Merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree_4.py
28
28
 
29
29
from bzrlib.lazy_import import lazy_import
30
30
lazy_import(globals(), """
31
 
from bisect import bisect_left
32
 
import collections
33
 
from copy import deepcopy
34
31
import errno
35
 
import itertools
36
 
import operator
37
32
import stat
38
 
from time import time
39
 
import warnings
40
33
 
41
34
import bzrlib
42
35
from bzrlib import (
43
36
    bzrdir,
44
37
    cache_utf8,
45
 
    conflicts as _mod_conflicts,
46
38
    debug,
47
 
    delta,
48
39
    dirstate,
49
40
    errors,
50
41
    generate_ids,
51
 
    globbing,
52
 
    ignores,
53
 
    merge,
54
42
    osutils,
55
43
    revision as _mod_revision,
56
44
    revisiontree,
57
 
    textui,
58
45
    trace,
59
46
    transform,
60
 
    urlutils,
61
47
    views,
62
 
    xml5,
63
 
    xml6,
64
48
    )
65
49
import bzrlib.branch
66
 
from bzrlib.transport import get_transport
67
50
import bzrlib.ui
68
51
""")
69
52
 
70
 
from bzrlib import symbol_versioning
71
53
from bzrlib.decorators import needs_read_lock, needs_write_lock
72
54
from bzrlib.filters import filtered_input_file, internal_size_sha_file_byname
73
 
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, entry_factory
 
55
from bzrlib.inventory import Inventory, ROOT_ID, entry_factory
74
56
import bzrlib.mutabletree
75
57
from bzrlib.mutabletree import needs_tree_write_lock
76
58
from bzrlib.osutils import (
77
59
    file_kind,
78
60
    isdir,
79
 
    normpath,
80
61
    pathjoin,
81
 
    rand_chars,
82
62
    realpath,
83
63
    safe_unicode,
84
 
    splitpath,
85
64
    )
86
 
from bzrlib.trace import mutter, note
 
65
from bzrlib.trace import mutter
87
66
from bzrlib.transport.local import LocalTransport
88
67
from bzrlib.tree import InterTree
89
 
from bzrlib.progress import DummyProgress, ProgressPhase
90
 
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
91
 
from bzrlib.rio import RioReader, rio_file, Stanza
92
 
from bzrlib.symbol_versioning import (deprecated_passed,
93
 
        deprecated_method,
94
 
        deprecated_function,
95
 
        DEPRECATED_PARAMETER,
96
 
        )
97
68
from bzrlib.tree import Tree
98
69
from bzrlib.workingtree import WorkingTree, WorkingTree3, WorkingTreeFormat3
99
70
 
716
687
            from_entry = self._get_entry(path=from_rel)
717
688
            if from_entry == (None, None):
718
689
                raise errors.BzrMoveFailedError(from_rel,to_dir,
719
 
                    errors.NotVersionedError(path=str(from_rel)))
 
690
                    errors.NotVersionedError(path=from_rel))
720
691
 
721
692
            from_id = from_entry[0][2]
722
693
            to_rel = pathjoin(to_dir, from_tail)
1051
1022
    def set_last_revision(self, new_revision):
1052
1023
        """Change the last revision in the working tree."""
1053
1024
        parents = self.get_parent_ids()
1054
 
        if new_revision in (NULL_REVISION, None):
 
1025
        if new_revision in (_mod_revision.NULL_REVISION, None):
1055
1026
            if len(parents) >= 2:
1056
1027
                raise AssertionError(
1057
1028
                    "setting the last parent to none with a pending merge is "
1403
1374
        wt.lock_tree_write()
1404
1375
        try:
1405
1376
            self._init_custom_control_files(wt)
1406
 
            if revision_id in (None, NULL_REVISION):
 
1377
            if revision_id in (None, _mod_revision.NULL_REVISION):
1407
1378
                if branch.repository.supports_rich_root():
1408
1379
                    wt._set_root_id(generate_ids.gen_root_id())
1409
1380
                else:
1420
1391
                    pass
1421
1392
            if basis is None:
1422
1393
                basis = branch.repository.revision_tree(revision_id)
1423
 
            if revision_id == NULL_REVISION:
 
1394
            if revision_id == _mod_revision.NULL_REVISION:
1424
1395
                parents_list = []
1425
1396
            else:
1426
1397
                parents_list = [(revision_id, basis)]
1844
1815
            return None
1845
1816
        return ie.executable
1846
1817
 
1847
 
    def list_files(self, include_root=False):
 
1818
    def list_files(self, include_root=False, from_dir=None, recursive=True):
1848
1819
        # We use a standard implementation, because DirStateRevisionTree is
1849
1820
        # dealing with one of the parents of the current state
1850
1821
        inv = self._get_inventory()
1851
 
        entries = inv.iter_entries()
1852
 
        if self.inventory.root is not None and not include_root:
 
1822
        if from_dir is None:
 
1823
            from_dir_id = None
 
1824
        else:
 
1825
            from_dir_id = inv.path2id(from_dir)
 
1826
            if from_dir_id is None:
 
1827
                # Directory not versioned
 
1828
                return
 
1829
        entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
 
1830
        if inv.root is not None and not include_root and from_dir is None:
1853
1831
            entries.next()
1854
1832
        for path, entry in entries:
1855
1833
            yield path, 'V', entry.kind, entry.file_id, entry
1963
1941
        if not CompiledDirstateHelpersFeature.available():
1964
1942
            from bzrlib.tests import UnavailableFeature
1965
1943
            raise UnavailableFeature(CompiledDirstateHelpersFeature)
1966
 
        from bzrlib._dirstate_helpers_c import ProcessEntryC
 
1944
        from bzrlib._dirstate_helpers_pyx import ProcessEntryC
1967
1945
        result = klass.make_source_parent_tree(source, target)
1968
1946
        result[1]._iter_changes = ProcessEntryC
1969
1947
        return result
2009
1987
                require_versioned, want_unversioned=want_unversioned)
2010
1988
        parent_ids = self.target.get_parent_ids()
2011
1989
        if not (self.source._revision_id in parent_ids
2012
 
                or self.source._revision_id == NULL_REVISION):
 
1990
                or self.source._revision_id == _mod_revision.NULL_REVISION):
2013
1991
            raise AssertionError(
2014
1992
                "revision {%s} is not stored in {%s}, but %s "
2015
1993
                "can only be used for trees stored in the dirstate"
2016
1994
                % (self.source._revision_id, self.target, self.iter_changes))
2017
1995
        target_index = 0
2018
 
        if self.source._revision_id == NULL_REVISION:
 
1996
        if self.source._revision_id == _mod_revision.NULL_REVISION:
2019
1997
            source_index = None
2020
1998
            indices = (target_index,)
2021
1999
        else:
2042
2020
        state._read_dirblocks_if_needed()
2043
2021
        if require_versioned:
2044
2022
            # -- check all supplied paths are versioned in a search tree. --
2045
 
            all_versioned = True
 
2023
            not_versioned = []
2046
2024
            for path in specific_files:
2047
2025
                path_entries = state._entries_for_path(path)
2048
2026
                if not path_entries:
2049
2027
                    # this specified path is not present at all: error
2050
 
                    all_versioned = False
2051
 
                    break
 
2028
                    not_versioned.append(path)
 
2029
                    continue
2052
2030
                found_versioned = False
2053
2031
                # for each id at this path
2054
2032
                for entry in path_entries:
2061
2039
                if not found_versioned:
2062
2040
                    # none of the indexes was not 'absent' at all ids for this
2063
2041
                    # path.
2064
 
                    all_versioned = False
2065
 
                    break
2066
 
            if not all_versioned:
2067
 
                raise errors.PathsNotVersionedError(specific_files)
 
2042
                    not_versioned.append(path)
 
2043
            if len(not_versioned) > 0:
 
2044
                raise errors.PathsNotVersionedError(not_versioned)
2068
2045
        # -- remove redundancy in supplied specific_files to prevent over-scanning --
2069
2046
        search_specific_files = osutils.minimum_path_selection(specific_files)
2070
2047
 
2084
2061
            (revisiontree.RevisionTree, DirStateRevisionTree)):
2085
2062
            return False
2086
2063
        # the source revid must be in the target dirstate
2087
 
        if not (source._revision_id == NULL_REVISION or
 
2064
        if not (source._revision_id == _mod_revision.NULL_REVISION or
2088
2065
            source._revision_id in target.get_parent_ids()):
2089
2066
            # TODO: what about ghosts? it may well need to
2090
2067
            # check for them explicitly.