~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree_4.py

  • Committer: Robert Collins
  • Date: 2008-02-13 03:30:01 UTC
  • mfrom: (3221 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3224.
  • Revision ID: robertc@robertcollins.net-20080213033001-rw70ul0zb02ph856
Merge to fix conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""WorkingTree4 format and implementation.
18
18
 
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
31
34
import errno
 
35
import itertools
 
36
import operator
32
37
import stat
 
38
from time import time
 
39
import warnings
33
40
 
34
41
import bzrlib
35
42
from bzrlib import (
36
43
    bzrdir,
37
44
    cache_utf8,
 
45
    conflicts as _mod_conflicts,
38
46
    debug,
 
47
    delta,
39
48
    dirstate,
40
49
    errors,
41
50
    generate_ids,
 
51
    globbing,
 
52
    ignores,
 
53
    merge,
42
54
    osutils,
43
55
    revision as _mod_revision,
44
56
    revisiontree,
 
57
    textui,
45
58
    trace,
46
59
    transform,
47
 
    views,
 
60
    urlutils,
 
61
    xml5,
 
62
    xml6,
48
63
    )
49
64
import bzrlib.branch
 
65
from bzrlib.transport import get_transport
50
66
import bzrlib.ui
51
67
""")
52
68
 
 
69
from bzrlib import symbol_versioning
53
70
from bzrlib.decorators import needs_read_lock, needs_write_lock
54
 
from bzrlib.filters import filtered_input_file, internal_size_sha_file_byname
55
 
from bzrlib.inventory import Inventory, ROOT_ID, entry_factory
 
71
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, entry_factory
 
72
from bzrlib.lockable_files import LockableFiles, TransportLock
 
73
from bzrlib.lockdir import LockDir
56
74
import bzrlib.mutabletree
57
75
from bzrlib.mutabletree import needs_tree_write_lock
58
76
from bzrlib.osutils import (
59
77
    file_kind,
60
78
    isdir,
 
79
    normpath,
61
80
    pathjoin,
 
81
    rand_chars,
62
82
    realpath,
63
83
    safe_unicode,
 
84
    splitpath,
64
85
    )
65
 
from bzrlib.trace import mutter
 
86
from bzrlib.trace import mutter, note
66
87
from bzrlib.transport.local import LocalTransport
67
88
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
        )
68
97
from bzrlib.tree import Tree
69
98
from bzrlib.workingtree import WorkingTree, WorkingTree3, WorkingTreeFormat3
70
99
 
71
100
 
72
 
class DirStateWorkingTree(WorkingTree3):
 
101
# This is the Windows equivalent of ENOTDIR
 
102
# It is defined in pywin32.winerror, but we don't want a strong dependency for
 
103
# just an error code.
 
104
ERROR_PATH_NOT_FOUND = 3
 
105
ERROR_DIRECTORY = 267
 
106
 
 
107
 
 
108
class WorkingTree4(WorkingTree3):
 
109
    """This is the Format 4 working tree.
 
110
 
 
111
    This differs from WorkingTree3 by:
 
112
     - Having a consolidated internal dirstate, stored in a
 
113
       randomly-accessible sorted file on disk.
 
114
     - Not having a regular inventory attribute.  One can be synthesized 
 
115
       on demand but this is expensive and should be avoided.
 
116
 
 
117
    This is new in bzr 0.15.
 
118
    """
 
119
 
73
120
    def __init__(self, basedir,
74
121
                 branch,
75
122
                 _control_files=None,
84
131
        """
85
132
        self._format = _format
86
133
        self.bzrdir = _bzrdir
 
134
        assert isinstance(basedir, basestring), \
 
135
            "base directory %r is not a string" % basedir
87
136
        basedir = safe_unicode(basedir)
88
137
        mutter("opening working tree %r", basedir)
89
138
        self._branch = branch
 
139
        assert isinstance(self.branch, bzrlib.branch.Branch), \
 
140
            "branch %r is not a Branch" % self.branch
90
141
        self.basedir = realpath(basedir)
91
142
        # if branch is at our basedir and is a format 6 or less
92
143
        # assume all other formats have their own control files.
 
144
        assert isinstance(_control_files, LockableFiles), \
 
145
            "_control_files must be a LockableFiles, not %r" % _control_files
93
146
        self._control_files = _control_files
94
 
        self._transport = self._control_files._transport
95
147
        self._dirty = None
96
148
        #-------------
97
149
        # during a read or write lock these objects are set, and are
101
153
        #-------------
102
154
        self._setup_directory_is_tree_reference()
103
155
        self._detect_case_handling()
104
 
        self._rules_searcher = None
105
 
        self.views = self._make_views()
106
 
        #--- allow tests to select the dirstate iter_changes implementation
107
 
        self._iter_changes = dirstate._process_entry
108
156
 
109
157
    @needs_tree_write_lock
110
158
    def _add(self, files, ids, kinds):
138
186
    @needs_tree_write_lock
139
187
    def add_reference(self, sub_tree):
140
188
        # use standard implementation, which calls back to self._add
141
 
        #
 
189
        # 
142
190
        # So we don't store the reference_revision in the working dirstate,
143
 
        # it's just recorded at the moment of commit.
 
191
        # it's just recorded at the moment of commit. 
144
192
        self._add_reference(sub_tree)
145
193
 
146
194
    def break_lock(self):
185
233
            WorkingTree3._comparison_data(self, entry, path)
186
234
        # it looks like a plain directory, but it's really a reference -- see
187
235
        # also kind()
188
 
        if (self._repo_supports_tree_reference and kind == 'directory'
189
 
            and entry is not None and entry.kind == 'tree-reference'):
 
236
        if (self._repo_supports_tree_reference and
 
237
            kind == 'directory' and
 
238
            self._directory_is_tree_reference(path)):
190
239
            kind = 'tree-reference'
191
240
        return kind, executable, stat_value
192
241
 
218
267
            return self._dirstate
219
268
        local_path = self.bzrdir.get_workingtree_transport(None
220
269
            ).local_abspath('dirstate')
221
 
        self._dirstate = dirstate.DirState.on_file(local_path,
222
 
            self._sha1_provider())
 
270
        self._dirstate = dirstate.DirState.on_file(local_path)
223
271
        return self._dirstate
224
272
 
225
 
    def _sha1_provider(self):
226
 
        """A function that returns a SHA1Provider suitable for this tree.
227
 
 
228
 
        :return: None if content filtering is not supported by this tree.
229
 
          Otherwise, a SHA1Provider is returned that sha's the canonical
230
 
          form of files, i.e. after read filters are applied.
231
 
        """
232
 
        if self.supports_content_filtering():
233
 
            return ContentFilterAwareSHA1Provider(self)
234
 
        else:
235
 
            return None
236
 
 
237
273
    def filter_unversioned_files(self, paths):
238
274
        """Filter out paths that are versioned.
239
275
 
271
307
 
272
308
    def _generate_inventory(self):
273
309
        """Create and set self.inventory from the dirstate object.
274
 
 
 
310
        
275
311
        This is relatively expensive: we have to walk the entire dirstate.
276
312
        Ideally we would not, and can deprecate this function.
277
313
        """
281
317
        state._read_dirblocks_if_needed()
282
318
        root_key, current_entry = self._get_entry(path='')
283
319
        current_id = root_key[2]
284
 
        if not (current_entry[0][0] == 'd'): # directory
285
 
            raise AssertionError(current_entry)
 
320
        assert current_entry[0][0] == 'd' # directory
286
321
        inv = Inventory(root_id=current_id)
287
322
        # Turn some things into local variables
288
323
        minikind_to_kind = dirstate.DirState._minikind_to_kind
321
356
                    # add this entry to the parent map.
322
357
                    parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
323
358
                elif kind == 'tree-reference':
324
 
                    if not self._repo_supports_tree_reference:
325
 
                        raise errors.UnsupportedOperation(
326
 
                            self._generate_inventory,
327
 
                            self.branch.repository)
 
359
                    assert self._repo_supports_tree_reference, \
 
360
                        "repository of %r " \
 
361
                        "doesn't support tree references " \
 
362
                        "required by entry %r" \
 
363
                        % (self, name)
328
364
                    inv_entry.reference_revision = link_or_sha1 or None
329
365
                elif kind != 'symlink':
330
366
                    raise AssertionError("unknown kind %r" % kind)
331
367
                # These checks cost us around 40ms on a 55k entry tree
332
 
                if file_id in inv_byid:
333
 
                    raise AssertionError('file_id %s already in'
334
 
                        ' inventory as %s' % (file_id, inv_byid[file_id]))
335
 
                if name_unicode in parent_ie.children:
336
 
                    raise AssertionError('name %r already in parent'
337
 
                        % (name_unicode,))
 
368
                assert file_id not in inv_byid, ('file_id %s already in'
 
369
                    ' inventory as %s' % (file_id, inv_byid[file_id]))
 
370
                assert name_unicode not in parent_ie.children
338
371
                inv_byid[file_id] = inv_entry
339
372
                parent_ie.children[name_unicode] = inv_entry
340
373
        self._inventory = inv
345
378
        If either file_id or path is supplied, it is used as the key to lookup.
346
379
        If both are supplied, the fastest lookup is used, and an error is
347
380
        raised if they do not both point at the same row.
348
 
 
 
381
        
349
382
        :param file_id: An optional unicode file_id to be looked up.
350
383
        :param path: An optional unicode path to be looked up.
351
384
        :return: The dirstate row tuple for path/file_id, or (None, None)
375
408
                    return None
376
409
                else:
377
410
                    raise
378
 
        link_or_sha1 = dirstate.update_entry(state, entry, file_abspath,
379
 
            stat_value=stat_value)
 
411
        link_or_sha1 = state.update_entry(entry, file_abspath,
 
412
                                          stat_value=stat_value)
380
413
        if entry[1][0][0] == 'f':
381
 
            if link_or_sha1 is None:
382
 
                file_obj, statvalue = self.get_file_with_stat(file_id, path)
383
 
                try:
384
 
                    sha1 = osutils.sha_file(file_obj)
385
 
                finally:
386
 
                    file_obj.close()
387
 
                self._observed_sha1(file_id, path, (sha1, statvalue))
388
 
                return sha1
389
 
            else:
390
 
                return link_or_sha1
 
414
            return link_or_sha1
391
415
        return None
392
416
 
393
417
    def _get_inventory(self):
407
431
    @needs_read_lock
408
432
    def get_parent_ids(self):
409
433
        """See Tree.get_parent_ids.
410
 
 
 
434
        
411
435
        This implementation requests the ids list from the dirstate file.
412
436
        """
413
437
        return self.current_dirstate().get_parent_ids()
435
459
        return osutils.lexists(pathjoin(
436
460
                    self.basedir, row[0].decode('utf8'), row[1].decode('utf8')))
437
461
 
438
 
    def has_or_had_id(self, file_id):
439
 
        state = self.current_dirstate()
440
 
        row, parents = self._get_entry(file_id=file_id)
441
 
        return row is not None
442
 
 
443
462
    @needs_read_lock
444
463
    def id2path(self, file_id):
445
464
        "Convert a file-id to a path."
481
500
            mode = os.lstat(self.abspath(path)).st_mode
482
501
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
483
502
 
484
 
    def all_file_ids(self):
485
 
        """See Tree.iter_all_file_ids"""
486
 
        self._must_be_locked()
487
 
        result = set()
488
 
        for key, tree_details in self.current_dirstate()._iter_entries():
489
 
            if tree_details[0][0] in ('a', 'r'): # relocated
490
 
                continue
491
 
            result.add(key[2])
492
 
        return result
493
 
 
494
503
    @needs_read_lock
495
504
    def __iter__(self):
496
505
        """Iterate through file_ids for this tree.
509
518
        return iter(result)
510
519
 
511
520
    def iter_references(self):
512
 
        if not self._repo_supports_tree_reference:
513
 
            # When the repo doesn't support references, we will have nothing to
514
 
            # return
515
 
            return
516
521
        for key, tree_details in self.current_dirstate()._iter_entries():
517
522
            if tree_details[0][0] in ('a', 'r'): # absent, relocated
518
523
                # not relevant to the working tree
520
525
            if not key[1]:
521
526
                # the root is not a reference.
522
527
                continue
523
 
            relpath = pathjoin(key[0].decode('utf8'), key[1].decode('utf8'))
 
528
            path = pathjoin(self.basedir, key[0].decode('utf8'), key[1].decode('utf8'))
524
529
            try:
525
 
                if self._kind(relpath) == 'tree-reference':
526
 
                    yield relpath, key[2]
 
530
                if self._kind(path) == 'tree-reference':
 
531
                    yield path, key[2]
527
532
            except errors.NoSuchFile:
528
533
                # path is missing on disk.
529
534
                continue
530
535
 
531
 
    def _observed_sha1(self, file_id, path, (sha1, statvalue)):
532
 
        """See MutableTree._observed_sha1."""
533
 
        state = self.current_dirstate()
534
 
        entry = self._get_entry(file_id=file_id, path=path)
535
 
        state._observed_sha1(entry, sha1, statvalue)
536
 
 
537
536
    def kind(self, file_id):
538
537
        """Return the kind of a file.
539
538
 
543
542
        Note: The caller is expected to take a read-lock before calling this.
544
543
        """
545
544
        relpath = self.id2path(file_id)
546
 
        if relpath is None:
547
 
            raise AssertionError(
548
 
                "path for id {%s} is None!" % file_id)
 
545
        assert relpath != None, \
 
546
            "path for id {%s} is None!" % file_id
549
547
        return self._kind(relpath)
550
548
 
551
549
    def _kind(self, relpath):
552
550
        abspath = self.abspath(relpath)
553
551
        kind = file_kind(abspath)
554
 
        if (self._repo_supports_tree_reference and kind == 'directory'):
555
 
            entry = self._get_entry(path=relpath)
556
 
            if entry[1] is not None:
557
 
                if entry[1][0][0] == 't':
558
 
                    kind = 'tree-reference'
 
552
        if (self._repo_supports_tree_reference and
 
553
            kind == 'directory' and
 
554
            self._directory_is_tree_reference(relpath)):
 
555
            kind = 'tree-reference'
559
556
        return kind
560
557
 
561
558
    @needs_read_lock
624
621
        result = []
625
622
        if not from_paths:
626
623
            return result
 
624
 
627
625
        state = self.current_dirstate()
628
 
        if isinstance(from_paths, basestring):
629
 
            raise ValueError()
 
626
 
 
627
        assert not isinstance(from_paths, basestring)
630
628
        to_dir_utf8 = to_dir.encode('utf8')
631
629
        to_entry_dirname, to_basename = os.path.split(to_dir_utf8)
632
630
        id_index = state._get_id_index()
654
652
        if self._inventory is not None:
655
653
            update_inventory = True
656
654
            inv = self.inventory
 
655
            to_dir_ie = inv[to_dir_id]
657
656
            to_dir_id = to_entry[0][2]
658
 
            to_dir_ie = inv[to_dir_id]
659
657
        else:
660
658
            update_inventory = False
661
659
 
692
690
            from_entry = self._get_entry(path=from_rel)
693
691
            if from_entry == (None, None):
694
692
                raise errors.BzrMoveFailedError(from_rel,to_dir,
695
 
                    errors.NotVersionedError(path=from_rel))
 
693
                    errors.NotVersionedError(path=str(from_rel)))
696
694
 
697
695
            from_id = from_entry[0][2]
698
696
            to_rel = pathjoin(to_dir, from_tail)
787
785
                if minikind == 'd':
788
786
                    def update_dirblock(from_dir, to_key, to_dir_utf8):
789
787
                        """Recursively update all entries in this dirblock."""
790
 
                        if from_dir == '':
791
 
                            raise AssertionError("renaming root not supported")
 
788
                        assert from_dir != '', "renaming root not supported"
792
789
                        from_key = (from_dir, '')
793
790
                        from_block_idx, present = \
794
791
                            state._find_block_index_from_key(from_key)
807
804
 
808
805
                        # Grab a copy since move_one may update the list.
809
806
                        for entry in from_block[1][:]:
810
 
                            if not (entry[0][0] == from_dir):
811
 
                                raise AssertionError()
 
807
                            assert entry[0][0] == from_dir
812
808
                            cur_details = entry[1][0]
813
809
                            to_key = (to_dir_utf8, entry[0][1], entry[0][2])
814
810
                            from_path_utf8 = osutils.pathjoin(entry[0][0], entry[0][1])
873
869
        for tree in trees:
874
870
            if not (isinstance(tree, DirStateRevisionTree) and tree._revision_id in
875
871
                parents):
876
 
                return super(DirStateWorkingTree, self).paths2ids(paths,
877
 
                    trees, require_versioned)
 
872
                return super(WorkingTree4, self).paths2ids(paths, trees, require_versioned)
878
873
        search_indexes = [0] + [1 + parents.index(tree._revision_id) for tree in trees]
879
874
        # -- make all paths utf8 --
880
875
        paths_utf8 = set()
941
936
                raise errors.PathsNotVersionedError(paths)
942
937
        # -- remove redundancy in supplied paths to prevent over-scanning --
943
938
        search_paths = osutils.minimum_path_selection(paths)
944
 
        # sketch:
 
939
        # sketch: 
945
940
        # for all search_indexs in each path at or under each element of
946
941
        # search_paths, if the detail is relocated: add the id, and add the
947
942
        # relocated path as one to search if its not searched already. If the
1003
998
 
1004
999
    def read_working_inventory(self):
1005
1000
        """Read the working inventory.
1006
 
 
 
1001
        
1007
1002
        This is a meaningless operation for dirstate, but we obey it anyhow.
1008
1003
        """
1009
1004
        return self.inventory
1027
1022
    def set_last_revision(self, new_revision):
1028
1023
        """Change the last revision in the working tree."""
1029
1024
        parents = self.get_parent_ids()
1030
 
        if new_revision in (_mod_revision.NULL_REVISION, None):
1031
 
            if len(parents) >= 2:
1032
 
                raise AssertionError(
1033
 
                    "setting the last parent to none with a pending merge is "
1034
 
                    "unsupported.")
 
1025
        if new_revision in (NULL_REVISION, None):
 
1026
            assert len(parents) < 2, (
 
1027
                "setting the last parent to none with a pending merge is "
 
1028
                "unsupported.")
1035
1029
            self.set_parent_ids([])
1036
1030
        else:
1037
1031
            self.set_parent_ids([new_revision] + parents[1:],
1040
1034
    @needs_tree_write_lock
1041
1035
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
1042
1036
        """Set the parent ids to revision_ids.
1043
 
 
 
1037
        
1044
1038
        See also set_parent_trees. This api will try to retrieve the tree data
1045
1039
        for each element of revision_ids from the trees repository. If you have
1046
1040
        tree data already available, it is more efficient to use
1078
1072
                raise errors.GhostRevisionUnusableHere(parents_list[0][0])
1079
1073
        real_trees = []
1080
1074
        ghosts = []
1081
 
 
1082
 
        parent_ids = [rev_id for rev_id, tree in parents_list]
1083
 
        graph = self.branch.repository.get_graph()
1084
 
        heads = graph.heads(parent_ids)
1085
 
        accepted_revisions = set()
1086
 
 
1087
1075
        # convert absent trees to the null tree, which we convert back to
1088
1076
        # missing on access.
1089
1077
        for rev_id, tree in parents_list:
1090
 
            if len(accepted_revisions) > 0:
1091
 
                # we always accept the first tree
1092
 
                if rev_id in accepted_revisions or rev_id not in heads:
1093
 
                    # We have already included either this tree, or its
1094
 
                    # descendent, so we skip it.
1095
 
                    continue
1096
1078
            _mod_revision.check_not_reserved_id(rev_id)
1097
1079
            if tree is not None:
1098
1080
                real_trees.append((rev_id, tree))
1099
1081
            else:
1100
1082
                real_trees.append((rev_id,
1101
 
                    self.branch.repository.revision_tree(
1102
 
                        _mod_revision.NULL_REVISION)))
 
1083
                    self.branch.repository.revision_tree(None)))
1103
1084
                ghosts.append(rev_id)
1104
 
            accepted_revisions.add(rev_id)
1105
1085
        dirstate.set_parent_trees(real_trees, ghosts=ghosts)
1106
1086
        self._make_dirty(reset_inventory=False)
1107
1087
 
1200
1180
                # just forget the whole block.
1201
1181
                entry_index = 0
1202
1182
                while entry_index < len(block[1]):
 
1183
                    # Mark this file id as having been removed
1203
1184
                    entry = block[1][entry_index]
1204
 
                    if entry[1][0][0] in 'ar':
1205
 
                        # don't remove absent or renamed entries
 
1185
                    ids_to_unversion.discard(entry[0][2])
 
1186
                    if (entry[1][0][0] in 'ar' # don't remove absent or renamed
 
1187
                                               # entries
 
1188
                        or not state._make_absent(entry)):
1206
1189
                        entry_index += 1
1207
 
                    else:
1208
 
                        # Mark this file id as having been removed
1209
 
                        ids_to_unversion.discard(entry[0][2])
1210
 
                        if not state._make_absent(entry):
1211
 
                            # The block has not shrunk.
1212
 
                            entry_index += 1
1213
1190
                # go to the next block. (At the moment we dont delete empty
1214
1191
                # dirblocks)
1215
1192
                block_index += 1
1238
1215
            for file_id in file_ids:
1239
1216
                self._inventory.remove_recursive_id(file_id)
1240
1217
 
1241
 
    @needs_tree_write_lock
1242
 
    def rename_one(self, from_rel, to_rel, after=False):
1243
 
        """See WorkingTree.rename_one"""
1244
 
        self.flush()
1245
 
        WorkingTree.rename_one(self, from_rel, to_rel, after)
1246
 
 
1247
 
    @needs_tree_write_lock
1248
 
    def apply_inventory_delta(self, changes):
1249
 
        """See MutableTree.apply_inventory_delta"""
1250
 
        state = self.current_dirstate()
1251
 
        state.update_by_delta(changes)
1252
 
        self._make_dirty(reset_inventory=True)
1253
 
 
1254
1218
    def update_basis_by_delta(self, new_revid, delta):
1255
1219
        """See MutableTree.update_basis_by_delta."""
1256
 
        if self.last_revision() == new_revid:
1257
 
            raise AssertionError()
 
1220
        assert self.last_revision() != new_revid
1258
1221
        self.current_dirstate().update_basis_by_delta(delta, new_revid)
1259
1222
 
1260
1223
    @needs_read_lock
1264
1227
    @needs_tree_write_lock
1265
1228
    def _write_inventory(self, inv):
1266
1229
        """Write inventory as the current inventory."""
1267
 
        if self._dirty:
1268
 
            raise AssertionError("attempting to write an inventory when the "
1269
 
                "dirstate is dirty will lose pending changes")
1270
 
        had_inventory = self._inventory is not None
1271
 
        # Setting self._inventory = None forces the dirstate to regenerate the
1272
 
        # working inventory. We do this because self.inventory may be inv, or
1273
 
        # may have been modified, and either case would prevent a clean delta
1274
 
        # being created.
1275
 
        self._inventory = None
1276
 
        # generate a delta,
1277
 
        delta = inv._make_delta(self.inventory)
1278
 
        # and apply it.
1279
 
        self.apply_inventory_delta(delta)
1280
 
        if had_inventory:
 
1230
        assert not self._dirty, ("attempting to write an inventory when the "
 
1231
            "dirstate is dirty will cause data loss")
 
1232
        self.current_dirstate().set_state_from_inventory(inv)
 
1233
        self._make_dirty(reset_inventory=False)
 
1234
        if self._inventory is not None:
1281
1235
            self._inventory = inv
1282
1236
        self.flush()
1283
1237
 
1284
1238
 
1285
 
class ContentFilterAwareSHA1Provider(dirstate.SHA1Provider):
1286
 
 
1287
 
    def __init__(self, tree):
1288
 
        self.tree = tree
1289
 
 
1290
 
    def sha1(self, abspath):
1291
 
        """See dirstate.SHA1Provider.sha1()."""
1292
 
        filters = self.tree._content_filter_stack(
1293
 
            self.tree.relpath(osutils.safe_unicode(abspath)))
1294
 
        return internal_size_sha_file_byname(abspath, filters)[1]
1295
 
 
1296
 
    def stat_and_sha1(self, abspath):
1297
 
        """See dirstate.SHA1Provider.stat_and_sha1()."""
1298
 
        filters = self.tree._content_filter_stack(
1299
 
            self.tree.relpath(osutils.safe_unicode(abspath)))
1300
 
        file_obj = file(abspath, 'rb', 65000)
1301
 
        try:
1302
 
            statvalue = os.fstat(file_obj.fileno())
1303
 
            if filters:
1304
 
                file_obj = filtered_input_file(file_obj, filters)
1305
 
            sha1 = osutils.size_sha_file(file_obj)[1]
1306
 
        finally:
1307
 
            file_obj.close()
1308
 
        return statvalue, sha1
1309
 
 
1310
 
 
1311
 
class ContentFilteringDirStateWorkingTree(DirStateWorkingTree):
1312
 
    """Dirstate working tree that supports content filtering.
1313
 
 
1314
 
    The dirstate holds the hash and size of the canonical form of the file, 
1315
 
    and most methods must return that.
1316
 
    """
1317
 
 
1318
 
    def _file_content_summary(self, path, stat_result):
1319
 
        # This is to support the somewhat obsolete path_content_summary method
1320
 
        # with content filtering: see
1321
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/415508>.
1322
 
        #
1323
 
        # If the dirstate cache is up to date and knows the hash and size,
1324
 
        # return that.
1325
 
        # Otherwise if there are no content filters, return the on-disk size
1326
 
        # and leave the hash blank.
1327
 
        # Otherwise, read and filter the on-disk file and use its size and
1328
 
        # hash.
1329
 
        #
1330
 
        # The dirstate doesn't store the size of the canonical form so we
1331
 
        # can't trust it for content-filtered trees.  We just return None.
1332
 
        dirstate_sha1 = self._dirstate.sha1_from_stat(path, stat_result)
1333
 
        executable = self._is_executable_from_path_and_stat(path, stat_result)
1334
 
        return ('file', None, executable, dirstate_sha1)
1335
 
 
1336
 
 
1337
 
class WorkingTree4(DirStateWorkingTree):
1338
 
    """This is the Format 4 working tree.
1339
 
 
1340
 
    This differs from WorkingTree3 by:
1341
 
     - Having a consolidated internal dirstate, stored in a
1342
 
       randomly-accessible sorted file on disk.
1343
 
     - Not having a regular inventory attribute.  One can be synthesized
1344
 
       on demand but this is expensive and should be avoided.
1345
 
 
1346
 
    This is new in bzr 0.15.
1347
 
    """
1348
 
 
1349
 
 
1350
 
class WorkingTree5(ContentFilteringDirStateWorkingTree):
1351
 
    """This is the Format 5 working tree.
1352
 
 
1353
 
    This differs from WorkingTree4 by:
1354
 
     - Supporting content filtering.
1355
 
 
1356
 
    This is new in bzr 1.11.
1357
 
    """
1358
 
 
1359
 
 
1360
 
class WorkingTree6(ContentFilteringDirStateWorkingTree):
1361
 
    """This is the Format 6 working tree.
1362
 
 
1363
 
    This differs from WorkingTree5 by:
1364
 
     - Supporting a current view that may mask the set of files in a tree
1365
 
       impacted by most user operations.
1366
 
 
1367
 
    This is new in bzr 1.14.
1368
 
    """
1369
 
 
1370
 
    def _make_views(self):
1371
 
        return views.PathBasedViews(self)
1372
 
 
1373
 
 
1374
 
class DirStateWorkingTreeFormat(WorkingTreeFormat3):
 
1239
class WorkingTreeFormat4(WorkingTreeFormat3):
 
1240
    """The first consolidated dirstate working tree format.
 
1241
 
 
1242
    This format:
 
1243
        - exists within a metadir controlling .bzr
 
1244
        - includes an explicit version marker for the workingtree control
 
1245
          files, separate from the BzrDir format
 
1246
        - modifies the hash cache format
 
1247
        - is new in bzr 0.15
 
1248
        - uses a LockDir to guard access to it.
 
1249
    """
 
1250
 
 
1251
    upgrade_recommended = False
 
1252
 
 
1253
    def get_format_string(self):
 
1254
        """See WorkingTreeFormat.get_format_string()."""
 
1255
        return "Bazaar Working Tree Format 4 (bzr 0.15)\n"
 
1256
 
 
1257
    def get_format_description(self):
 
1258
        """See WorkingTreeFormat.get_format_description()."""
 
1259
        return "Working tree format 4"
1375
1260
 
1376
1261
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
1377
 
                   accelerator_tree=None, hardlink=False):
 
1262
                   accelerator_tree=None):
1378
1263
        """See WorkingTreeFormat.initialize().
1379
1264
 
1380
1265
        :param revision_id: allows creating a working tree at a different
1383
1268
            contents more quickly than the revision tree, i.e. a workingtree.
1384
1269
            The revision tree will be used for cases where accelerator_tree's
1385
1270
            content is different.
1386
 
        :param hardlink: If true, hard-link files from accelerator_tree,
1387
 
            where possible.
1388
1271
 
1389
1272
        These trees get an initial random root id, if their repository supports
1390
1273
        rich root data, TREE_ROOT otherwise.
1395
1278
        control_files = self._open_control_files(a_bzrdir)
1396
1279
        control_files.create_lock()
1397
1280
        control_files.lock_write()
1398
 
        transport.put_bytes('format', self.get_format_string(),
1399
 
            mode=a_bzrdir._get_file_mode())
 
1281
        control_files.put_utf8('format', self.get_format_string())
1400
1282
        if from_branch is not None:
1401
1283
            branch = from_branch
1402
1284
        else:
1408
1290
        state = dirstate.DirState.initialize(local_path)
1409
1291
        state.unlock()
1410
1292
        del state
1411
 
        wt = self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
 
1293
        wt = WorkingTree4(a_bzrdir.root_transport.local_abspath('.'),
1412
1294
                         branch,
1413
1295
                         _format=self,
1414
1296
                         _bzrdir=a_bzrdir,
1416
1298
        wt._new_tree()
1417
1299
        wt.lock_tree_write()
1418
1300
        try:
1419
 
            self._init_custom_control_files(wt)
1420
 
            if revision_id in (None, _mod_revision.NULL_REVISION):
 
1301
            if revision_id in (None, NULL_REVISION):
1421
1302
                if branch.repository.supports_rich_root():
1422
1303
                    wt._set_root_id(generate_ids.gen_root_id())
1423
1304
                else:
1434
1315
                    pass
1435
1316
            if basis is None:
1436
1317
                basis = branch.repository.revision_tree(revision_id)
1437
 
            if revision_id == _mod_revision.NULL_REVISION:
 
1318
            if revision_id == NULL_REVISION:
1438
1319
                parents_list = []
1439
1320
            else:
1440
1321
                parents_list = [(revision_id, basis)]
1441
1322
            basis.lock_read()
1442
 
            try:
1443
 
                wt.set_parent_trees(parents_list, allow_leftmost_as_ghost=True)
 
1323
            wt.set_parent_trees(parents_list, allow_leftmost_as_ghost=True)
 
1324
            wt.flush()
 
1325
            # if the basis has a root id we have to use that; otherwise we use
 
1326
            # a new random one
 
1327
            basis_root_id = basis.get_root_id()
 
1328
            if basis_root_id is not None:
 
1329
                wt._set_root_id(basis_root_id)
1444
1330
                wt.flush()
1445
 
                # if the basis has a root id we have to use that; otherwise we
1446
 
                # use a new random one
1447
 
                basis_root_id = basis.get_root_id()
1448
 
                if basis_root_id is not None:
1449
 
                    wt._set_root_id(basis_root_id)
1450
 
                    wt.flush()
1451
 
                if wt.supports_content_filtering():
1452
 
                    # The original tree may not have the same content filters
1453
 
                    # applied so we can't safely build the inventory delta from
1454
 
                    # the source tree.
1455
 
                    delta_from_tree = False
1456
 
                else:
1457
 
                    delta_from_tree = True
1458
 
                # delta_from_tree is safe even for DirStateRevisionTrees,
1459
 
                # because wt4.apply_inventory_delta does not mutate the input
1460
 
                # inventory entries.
1461
 
                transform.build_tree(basis, wt, accelerator_tree,
1462
 
                                     hardlink=hardlink,
1463
 
                                     delta_from_tree=delta_from_tree)
1464
 
            finally:
1465
 
                basis.unlock()
 
1331
            transform.build_tree(basis, wt, accelerator_tree)
 
1332
            basis.unlock()
1466
1333
        finally:
1467
1334
            control_files.unlock()
1468
1335
            wt.unlock()
1469
1336
        return wt
1470
1337
 
1471
 
    def _init_custom_control_files(self, wt):
1472
 
        """Subclasses with custom control files should override this method.
1473
 
 
1474
 
        The working tree and control files are locked for writing when this
1475
 
        method is called.
1476
 
 
1477
 
        :param wt: the WorkingTree object
1478
 
        """
1479
 
 
1480
1338
    def _open(self, a_bzrdir, control_files):
1481
1339
        """Open the tree itself.
1482
1340
 
1483
1341
        :param a_bzrdir: the dir for the tree.
1484
1342
        :param control_files: the control files for the tree.
1485
1343
        """
1486
 
        return self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
 
1344
        return WorkingTree4(a_bzrdir.root_transport.local_abspath('.'),
1487
1345
                           branch=a_bzrdir.open_branch(),
1488
1346
                           _format=self,
1489
1347
                           _bzrdir=a_bzrdir,
1490
1348
                           _control_files=control_files)
1491
1349
 
1492
1350
    def __get_matchingbzrdir(self):
1493
 
        return self._get_matchingbzrdir()
1494
 
 
1495
 
    def _get_matchingbzrdir(self):
1496
 
        """Overrideable method to get a bzrdir for testing."""
1497
1351
        # please test against something that will let us do tree references
1498
1352
        return bzrdir.format_registry.make_bzrdir(
1499
1353
            'dirstate-with-subtree')
1501
1355
    _matchingbzrdir = property(__get_matchingbzrdir)
1502
1356
 
1503
1357
 
1504
 
class WorkingTreeFormat4(DirStateWorkingTreeFormat):
1505
 
    """The first consolidated dirstate working tree format.
1506
 
 
1507
 
    This format:
1508
 
        - exists within a metadir controlling .bzr
1509
 
        - includes an explicit version marker for the workingtree control
1510
 
          files, separate from the BzrDir format
1511
 
        - modifies the hash cache format
1512
 
        - is new in bzr 0.15
1513
 
        - uses a LockDir to guard access to it.
1514
 
    """
1515
 
 
1516
 
    upgrade_recommended = False
1517
 
 
1518
 
    _tree_class = WorkingTree4
1519
 
 
1520
 
    def get_format_string(self):
1521
 
        """See WorkingTreeFormat.get_format_string()."""
1522
 
        return "Bazaar Working Tree Format 4 (bzr 0.15)\n"
1523
 
 
1524
 
    def get_format_description(self):
1525
 
        """See WorkingTreeFormat.get_format_description()."""
1526
 
        return "Working tree format 4"
1527
 
 
1528
 
 
1529
 
class WorkingTreeFormat5(DirStateWorkingTreeFormat):
1530
 
    """WorkingTree format supporting content filtering.
1531
 
    """
1532
 
 
1533
 
    upgrade_recommended = False
1534
 
 
1535
 
    _tree_class = WorkingTree5
1536
 
 
1537
 
    def get_format_string(self):
1538
 
        """See WorkingTreeFormat.get_format_string()."""
1539
 
        return "Bazaar Working Tree Format 5 (bzr 1.11)\n"
1540
 
 
1541
 
    def get_format_description(self):
1542
 
        """See WorkingTreeFormat.get_format_description()."""
1543
 
        return "Working tree format 5"
1544
 
 
1545
 
    def supports_content_filtering(self):
1546
 
        return True
1547
 
 
1548
 
 
1549
 
class WorkingTreeFormat6(DirStateWorkingTreeFormat):
1550
 
    """WorkingTree format supporting views.
1551
 
    """
1552
 
 
1553
 
    upgrade_recommended = False
1554
 
 
1555
 
    _tree_class = WorkingTree6
1556
 
 
1557
 
    def get_format_string(self):
1558
 
        """See WorkingTreeFormat.get_format_string()."""
1559
 
        return "Bazaar Working Tree Format 6 (bzr 1.14)\n"
1560
 
 
1561
 
    def get_format_description(self):
1562
 
        """See WorkingTreeFormat.get_format_description()."""
1563
 
        return "Working tree format 6"
1564
 
 
1565
 
    def _init_custom_control_files(self, wt):
1566
 
        """Subclasses with custom control files should override this method."""
1567
 
        wt._transport.put_bytes('views', '', mode=wt.bzrdir._get_file_mode())
1568
 
 
1569
 
    def supports_content_filtering(self):
1570
 
        return True
1571
 
 
1572
 
    def supports_views(self):
1573
 
        return True
1574
 
 
1575
 
 
1576
1358
class DirStateRevisionTree(Tree):
1577
 
    """A revision tree pulling the inventory from a dirstate.
1578
 
    
1579
 
    Note that this is one of the historical (ie revision) trees cached in the
1580
 
    dirstate for easy access, not the workingtree.
1581
 
    """
 
1359
    """A revision tree pulling the inventory from a dirstate."""
1582
1360
 
1583
1361
    def __init__(self, dirstate, revision_id, repository):
1584
1362
        self._dirstate = dirstate
1587
1365
        self._inventory = None
1588
1366
        self._locked = 0
1589
1367
        self._dirstate_locked = False
1590
 
        self._repo_supports_tree_reference = getattr(
1591
 
            repository._format, "supports_tree_reference",
1592
 
            False)
1593
1368
 
1594
1369
    def __repr__(self):
1595
1370
        return "<%s of %s in %s>" % \
1598
1373
    def annotate_iter(self, file_id,
1599
1374
                      default_revision=_mod_revision.CURRENT_REVISION):
1600
1375
        """See Tree.annotate_iter"""
1601
 
        text_key = (file_id, self.inventory[file_id].revision)
1602
 
        annotations = self._repository.texts.annotate(text_key)
1603
 
        return [(key[-1], line) for (key, line) in annotations]
 
1376
        w = self._get_weave(file_id)
 
1377
        return w.annotate_iter(self.inventory[file_id].revision)
1604
1378
 
1605
1379
    def _get_ancestors(self, default_revision):
1606
1380
        return set(self._repository.get_ancestry(self._revision_id,
1635
1409
        path_utf8 = osutils.pathjoin(entry[0][0], entry[0][1])
1636
1410
        return path_utf8.decode('utf8')
1637
1411
 
1638
 
    def iter_references(self):
1639
 
        if not self._repo_supports_tree_reference:
1640
 
            # When the repo doesn't support references, we will have nothing to
1641
 
            # return
1642
 
            return iter([])
1643
 
        # Otherwise, fall back to the default implementation
1644
 
        return super(DirStateRevisionTree, self).iter_references()
1645
 
 
1646
1412
    def _get_parent_index(self):
1647
1413
        """Return the index in the dirstate referenced by this tree."""
1648
1414
        return self._dirstate.get_parent_ids().index(self._revision_id) + 1
1653
1419
        If either file_id or path is supplied, it is used as the key to lookup.
1654
1420
        If both are supplied, the fastest lookup is used, and an error is
1655
1421
        raised if they do not both point at the same row.
1656
 
 
 
1422
        
1657
1423
        :param file_id: An optional unicode file_id to be looked up.
1658
1424
        :param path: An optional unicode path to be looked up.
1659
1425
        :return: The dirstate row tuple for path/file_id, or (None, None)
1673
1439
 
1674
1440
        This is relatively expensive: we have to walk the entire dirstate.
1675
1441
        """
1676
 
        if not self._locked:
1677
 
            raise AssertionError(
1678
 
                'cannot generate inventory of an unlocked '
1679
 
                'dirstate revision tree')
 
1442
        assert self._locked, 'cannot generate inventory of an unlocked '\
 
1443
            'dirstate revision tree'
1680
1444
        # separate call for profiling - makes it clear where the costs are.
1681
1445
        self._dirstate._read_dirblocks_if_needed()
1682
 
        if self._revision_id not in self._dirstate.get_parent_ids():
1683
 
            raise AssertionError(
1684
 
                'parent %s has disappeared from %s' % (
1685
 
                self._revision_id, self._dirstate.get_parent_ids()))
 
1446
        assert self._revision_id in self._dirstate.get_parent_ids(), \
 
1447
            'parent %s has disappeared from %s' % (
 
1448
            self._revision_id, self._dirstate.get_parent_ids())
1686
1449
        parent_index = self._dirstate.get_parent_ids().index(self._revision_id) + 1
1687
1450
        # This is identical now to the WorkingTree _generate_inventory except
1688
1451
        # for the tree index use.
1689
1452
        root_key, current_entry = self._dirstate._get_entry(parent_index, path_utf8='')
1690
1453
        current_id = root_key[2]
1691
 
        if current_entry[parent_index][0] != 'd':
1692
 
            raise AssertionError()
 
1454
        assert current_entry[parent_index][0] == 'd'
1693
1455
        inv = Inventory(root_id=current_id, revision_id=self._revision_id)
1694
1456
        inv.root.revision = current_entry[parent_index][4]
1695
1457
        # Turn some things into local variables
1735
1497
                    raise AssertionError("cannot convert entry %r into an InventoryEntry"
1736
1498
                            % entry)
1737
1499
                # These checks cost us around 40ms on a 55k entry tree
1738
 
                if file_id in inv_byid:
1739
 
                    raise AssertionError('file_id %s already in'
1740
 
                        ' inventory as %s' % (file_id, inv_byid[file_id]))
1741
 
                if name_unicode in parent_ie.children:
1742
 
                    raise AssertionError('name %r already in parent'
1743
 
                        % (name_unicode,))
 
1500
                assert file_id not in inv_byid
 
1501
                assert name_unicode not in parent_ie.children
1744
1502
                inv_byid[file_id] = inv_entry
1745
1503
                parent_ie.children[name_unicode] = inv_entry
1746
1504
        self._inventory = inv
1756
1514
            return None
1757
1515
        parent_index = self._get_parent_index()
1758
1516
        last_changed_revision = entry[1][parent_index][4]
1759
 
        try:
1760
 
            rev = self._repository.get_revision(last_changed_revision)
1761
 
        except errors.NoSuchRevision:
1762
 
            raise errors.FileTimestampUnavailable(self.id2path(file_id))
1763
 
        return rev.timestamp
 
1517
        return self._repository.get_revision(last_changed_revision).timestamp
1764
1518
 
1765
1519
    def get_file_sha1(self, file_id, path=None, stat_value=None):
1766
1520
        entry = self._get_entry(file_id=file_id, path=path)
1770
1524
            return parent_details[1]
1771
1525
        return None
1772
1526
 
 
1527
    @symbol_versioning.deprecated_method(symbol_versioning.zero_ninety)
 
1528
    def get_weave(self, file_id):
 
1529
        return self._get_weave(file_id)
 
1530
 
 
1531
    def _get_weave(self, file_id):
 
1532
        return self._repository.weave_store.get_weave(file_id,
 
1533
                self._repository.get_transaction())
 
1534
 
1773
1535
    def get_file(self, file_id, path=None):
1774
1536
        return StringIO(self.get_file_text(file_id))
1775
1537
 
 
1538
    def get_file_lines(self, file_id):
 
1539
        entry = self._get_entry(file_id=file_id)[1]
 
1540
        if entry == None:
 
1541
            raise errors.NoSuchId(tree=self, file_id=file_id)
 
1542
        return self._get_weave(file_id).get_lines(entry[1][4])
 
1543
 
1776
1544
    def get_file_size(self, file_id):
1777
 
        """See Tree.get_file_size"""
1778
1545
        return self.inventory[file_id].text_size
1779
1546
 
1780
 
    def get_file_text(self, file_id, path=None):
1781
 
        _, content = list(self.iter_files_bytes([(file_id, None)]))[0]
1782
 
        return ''.join(content)
 
1547
    def get_file_text(self, file_id):
 
1548
        return ''.join(self.get_file_lines(file_id))
1783
1549
 
1784
1550
    def get_reference_revision(self, file_id, path=None):
1785
1551
        return self.inventory[file_id].reference_revision
1804
1570
        if entry[1][parent_index][0] != 'l':
1805
1571
            return None
1806
1572
        else:
1807
 
            target = entry[1][parent_index][1]
1808
 
            target = target.decode('utf8')
1809
 
            return target
 
1573
            # At present, none of the tree implementations supports non-ascii
 
1574
            # symlink targets. So we will just assume that the dirstate path is
 
1575
            # correct.
 
1576
            return entry[1][parent_index][1]
1810
1577
 
1811
1578
    def get_revision_id(self):
1812
1579
        """Return the revision id for this tree."""
1831
1598
 
1832
1599
    def kind(self, file_id):
1833
1600
        entry = self._get_entry(file_id=file_id)[1]
1834
 
        if entry is None:
 
1601
        if entry == None:
1835
1602
            raise errors.NoSuchId(tree=self, file_id=file_id)
1836
 
        parent_index = self._get_parent_index()
1837
 
        return dirstate.DirState._minikind_to_kind[entry[parent_index][0]]
1838
 
 
1839
 
    def stored_kind(self, file_id):
1840
 
        """See Tree.stored_kind"""
1841
 
        return self.kind(file_id)
 
1603
        return dirstate.DirState._minikind_to_kind[entry[1][0]]
1842
1604
 
1843
1605
    def path_content_summary(self, path):
1844
1606
        """See Tree.path_content_summary."""
1860
1622
            return None
1861
1623
        return ie.executable
1862
1624
 
1863
 
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
1625
    def list_files(self, include_root=False):
1864
1626
        # We use a standard implementation, because DirStateRevisionTree is
1865
1627
        # dealing with one of the parents of the current state
1866
1628
        inv = self._get_inventory()
1867
 
        if from_dir is None:
1868
 
            from_dir_id = None
1869
 
        else:
1870
 
            from_dir_id = inv.path2id(from_dir)
1871
 
            if from_dir_id is None:
1872
 
                # Directory not versioned
1873
 
                return
1874
 
        entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
1875
 
        if inv.root is not None and not include_root and from_dir is None:
 
1629
        entries = inv.iter_entries()
 
1630
        if self.inventory.root is not None and not include_root:
1876
1631
            entries.next()
1877
1632
        for path, entry in entries:
1878
1633
            yield path, 'V', entry.kind, entry.file_id, entry
1911
1666
                self._dirstate_locked = False
1912
1667
            self._repository.unlock()
1913
1668
 
1914
 
    @needs_read_lock
1915
 
    def supports_tree_reference(self):
1916
 
        return self._repo_supports_tree_reference
1917
 
 
1918
1669
    def walkdirs(self, prefix=""):
1919
1670
        # TODO: jam 20070215 This is the lazy way by using the RevisionTree
1920
 
        # implementation based on an inventory.
 
1671
        # implementation based on an inventory.  
1921
1672
        # This should be cleaned up to use the much faster Dirstate code
1922
1673
        # So for now, we just build up the parent inventory, and extract
1923
1674
        # it the same way RevisionTree does.
1952
1703
 
1953
1704
class InterDirStateTree(InterTree):
1954
1705
    """Fast path optimiser for changes_from with dirstate trees.
1955
 
 
1956
 
    This is used only when both trees are in the dirstate working file, and
1957
 
    the source is any parent within the dirstate, and the destination is
 
1706
    
 
1707
    This is used only when both trees are in the dirstate working file, and 
 
1708
    the source is any parent within the dirstate, and the destination is 
1958
1709
    the current working tree of the same dirstate.
1959
1710
    """
1960
1711
    # this could be generalized to allow comparisons between any trees in the
1973
1724
        target.set_parent_ids([revid])
1974
1725
        return target.basis_tree(), target
1975
1726
 
1976
 
    @classmethod
1977
 
    def make_source_parent_tree_python_dirstate(klass, test_case, source, target):
1978
 
        result = klass.make_source_parent_tree(source, target)
1979
 
        result[1]._iter_changes = dirstate.ProcessEntryPython
1980
 
        return result
1981
 
 
1982
 
    @classmethod
1983
 
    def make_source_parent_tree_compiled_dirstate(klass, test_case, source,
1984
 
                                                  target):
1985
 
        from bzrlib.tests.test__dirstate_helpers import \
1986
 
            compiled_dirstate_helpers_feature
1987
 
        test_case.requireFeature(compiled_dirstate_helpers_feature)
1988
 
        from bzrlib._dirstate_helpers_pyx import ProcessEntryC
1989
 
        result = klass.make_source_parent_tree(source, target)
1990
 
        result[1]._iter_changes = ProcessEntryC
1991
 
        return result
1992
 
 
1993
1727
    _matching_from_tree_format = WorkingTreeFormat4()
1994
1728
    _matching_to_tree_format = WorkingTreeFormat4()
1995
 
 
1996
 
    @classmethod
1997
 
    def _test_mutable_trees_to_test_trees(klass, test_case, source, target):
1998
 
        # This method shouldn't be called, because we have python and C
1999
 
        # specific flavours.
2000
 
        raise NotImplementedError
2001
 
 
2002
 
    def iter_changes(self, include_unchanged=False,
 
1729
    _test_mutable_trees_to_test_trees = make_source_parent_tree
 
1730
 
 
1731
    def _iter_changes(self, include_unchanged=False,
2003
1732
                      specific_files=None, pb=None, extra_trees=[],
2004
1733
                      require_versioned=True, want_unversioned=False):
2005
1734
        """Return the changes from source to target.
2006
1735
 
2007
 
        :return: An iterator that yields tuples. See InterTree.iter_changes
 
1736
        :return: An iterator that yields tuples. See InterTree._iter_changes
2008
1737
            for details.
2009
1738
        :param specific_files: An optional list of file paths to restrict the
2010
1739
            comparison to. When mapping filenames to ids, all matches in all
2021
1750
            output. An unversioned file is defined as one with (False, False)
2022
1751
            for the versioned pair.
2023
1752
        """
 
1753
        utf8_decode = cache_utf8._utf8_decode
 
1754
        _minikind_to_kind = dirstate.DirState._minikind_to_kind
 
1755
        cmp_by_dirs = dirstate.cmp_by_dirs
 
1756
        # NB: show_status depends on being able to pass in non-versioned files
 
1757
        # and report them as unknown
2024
1758
        # TODO: handle extra trees in the dirstate.
2025
1759
        if (extra_trees or specific_files == []):
2026
1760
            # we can't fast-path these cases (yet)
2027
 
            return super(InterDirStateTree, self).iter_changes(
 
1761
            for f in super(InterDirStateTree, self)._iter_changes(
2028
1762
                include_unchanged, specific_files, pb, extra_trees,
2029
 
                require_versioned, want_unversioned=want_unversioned)
 
1763
                require_versioned, want_unversioned=want_unversioned):
 
1764
                yield f
 
1765
            return
2030
1766
        parent_ids = self.target.get_parent_ids()
2031
 
        if not (self.source._revision_id in parent_ids
2032
 
                or self.source._revision_id == _mod_revision.NULL_REVISION):
2033
 
            raise AssertionError(
2034
 
                "revision {%s} is not stored in {%s}, but %s "
2035
 
                "can only be used for trees stored in the dirstate"
2036
 
                % (self.source._revision_id, self.target, self.iter_changes))
 
1767
        assert (self.source._revision_id in parent_ids
 
1768
                or self.source._revision_id == NULL_REVISION), \
 
1769
                "revision {%s} is not stored in {%s}, but %s " \
 
1770
                "can only be used for trees stored in the dirstate" \
 
1771
                % (self.source._revision_id, self.target, self._iter_changes)
2037
1772
        target_index = 0
2038
 
        if self.source._revision_id == _mod_revision.NULL_REVISION:
 
1773
        if self.source._revision_id == NULL_REVISION:
2039
1774
            source_index = None
2040
1775
            indices = (target_index,)
2041
1776
        else:
2042
 
            if not (self.source._revision_id in parent_ids):
2043
 
                raise AssertionError(
2044
 
                    "Failure: source._revision_id: %s not in target.parent_ids(%s)" % (
2045
 
                    self.source._revision_id, parent_ids))
 
1777
            assert (self.source._revision_id in parent_ids), \
 
1778
                "Failure: source._revision_id: %s not in target.parent_ids(%s)" % (
 
1779
                self.source._revision_id, parent_ids)
2046
1780
            source_index = 1 + parent_ids.index(self.source._revision_id)
2047
1781
            indices = (source_index, target_index)
2048
1782
        # -- make all specific_files utf8 --
2049
1783
        if specific_files:
2050
1784
            specific_files_utf8 = set()
2051
1785
            for path in specific_files:
2052
 
                # Note, if there are many specific files, using cache_utf8
2053
 
                # would be good here.
2054
1786
                specific_files_utf8.add(path.encode('utf8'))
2055
1787
            specific_files = specific_files_utf8
2056
1788
        else:
2057
1789
            specific_files = set([''])
2058
1790
        # -- specific_files is now a utf8 path set --
2059
 
 
2060
1791
        # -- get the state object and prepare it.
2061
1792
        state = self.target.current_dirstate()
2062
1793
        state._read_dirblocks_if_needed()
 
1794
        def _entries_for_path(path):
 
1795
            """Return a list with all the entries that match path for all ids.
 
1796
            """
 
1797
            dirname, basename = os.path.split(path)
 
1798
            key = (dirname, basename, '')
 
1799
            block_index, present = state._find_block_index_from_key(key)
 
1800
            if not present:
 
1801
                # the block which should contain path is absent.
 
1802
                return []
 
1803
            result = []
 
1804
            block = state._dirblocks[block_index][1]
 
1805
            entry_index, _ = state._find_entry_index(key, block)
 
1806
            # we may need to look at multiple entries at this path: walk while the specific_files match.
 
1807
            while (entry_index < len(block) and
 
1808
                block[entry_index][0][0:2] == key[0:2]):
 
1809
                result.append(block[entry_index])
 
1810
                entry_index += 1
 
1811
            return result
2063
1812
        if require_versioned:
2064
1813
            # -- check all supplied paths are versioned in a search tree. --
2065
 
            not_versioned = []
 
1814
            all_versioned = True
2066
1815
            for path in specific_files:
2067
 
                path_entries = state._entries_for_path(path)
 
1816
                path_entries = _entries_for_path(path)
2068
1817
                if not path_entries:
2069
1818
                    # this specified path is not present at all: error
2070
 
                    not_versioned.append(path)
2071
 
                    continue
 
1819
                    all_versioned = False
 
1820
                    break
2072
1821
                found_versioned = False
2073
1822
                # for each id at this path
2074
1823
                for entry in path_entries:
2081
1830
                if not found_versioned:
2082
1831
                    # none of the indexes was not 'absent' at all ids for this
2083
1832
                    # path.
2084
 
                    not_versioned.append(path)
2085
 
            if len(not_versioned) > 0:
2086
 
                raise errors.PathsNotVersionedError(not_versioned)
 
1833
                    all_versioned = False
 
1834
                    break
 
1835
            if not all_versioned:
 
1836
                raise errors.PathsNotVersionedError(specific_files)
2087
1837
        # -- remove redundancy in supplied specific_files to prevent over-scanning --
2088
 
        search_specific_files = osutils.minimum_path_selection(specific_files)
 
1838
        search_specific_files = set()
 
1839
        for path in specific_files:
 
1840
            other_specific_files = specific_files.difference(set([path]))
 
1841
            if not osutils.is_inside_any(other_specific_files, path):
 
1842
                # this is a top level path, we must check it.
 
1843
                search_specific_files.add(path)
 
1844
        # sketch: 
 
1845
        # compare source_index and target_index at or under each element of search_specific_files.
 
1846
        # follow the following comparison table. Note that we only want to do diff operations when
 
1847
        # the target is fdl because thats when the walkdirs logic will have exposed the pathinfo 
 
1848
        # for the target.
 
1849
        # cases:
 
1850
        # 
 
1851
        # Source | Target | disk | action
 
1852
        #   r    | fdlt   |      | add source to search, add id path move and perform
 
1853
        #        |        |      | diff check on source-target
 
1854
        #   r    | fdlt   |  a   | dangling file that was present in the basis. 
 
1855
        #        |        |      | ???
 
1856
        #   r    |  a     |      | add source to search
 
1857
        #   r    |  a     |  a   | 
 
1858
        #   r    |  r     |      | this path is present in a non-examined tree, skip.
 
1859
        #   r    |  r     |  a   | this path is present in a non-examined tree, skip.
 
1860
        #   a    | fdlt   |      | add new id
 
1861
        #   a    | fdlt   |  a   | dangling locally added file, skip
 
1862
        #   a    |  a     |      | not present in either tree, skip
 
1863
        #   a    |  a     |  a   | not present in any tree, skip
 
1864
        #   a    |  r     |      | not present in either tree at this path, skip as it
 
1865
        #        |        |      | may not be selected by the users list of paths.
 
1866
        #   a    |  r     |  a   | not present in either tree at this path, skip as it
 
1867
        #        |        |      | may not be selected by the users list of paths.
 
1868
        #  fdlt  | fdlt   |      | content in both: diff them
 
1869
        #  fdlt  | fdlt   |  a   | deleted locally, but not unversioned - show as deleted ?
 
1870
        #  fdlt  |  a     |      | unversioned: output deleted id for now
 
1871
        #  fdlt  |  a     |  a   | unversioned and deleted: output deleted id
 
1872
        #  fdlt  |  r     |      | relocated in this tree, so add target to search.
 
1873
        #        |        |      | Dont diff, we will see an r,fd; pair when we reach
 
1874
        #        |        |      | this id at the other path.
 
1875
        #  fdlt  |  r     |  a   | relocated in this tree, so add target to search.
 
1876
        #        |        |      | Dont diff, we will see an r,fd; pair when we reach
 
1877
        #        |        |      | this id at the other path.
 
1878
 
 
1879
        # for all search_indexs in each path at or under each element of
 
1880
        # search_specific_files, if the detail is relocated: add the id, and add the
 
1881
        # relocated path as one to search if its not searched already. If the
 
1882
        # detail is not relocated, add the id.
 
1883
        searched_specific_files = set()
 
1884
        NULL_PARENT_DETAILS = dirstate.DirState.NULL_PARENT_DETAILS
 
1885
        # Using a list so that we can access the values and change them in
 
1886
        # nested scope. Each one is [path, file_id, entry]
 
1887
        last_source_parent = [None, None]
 
1888
        last_target_parent = [None, None]
2089
1889
 
2090
1890
        use_filesystem_for_exec = (sys.platform != 'win32')
2091
 
        iter_changes = self.target._iter_changes(include_unchanged,
2092
 
            use_filesystem_for_exec, search_specific_files, state,
2093
 
            source_index, target_index, want_unversioned, self.target)
2094
 
        return iter_changes.iter_changes()
 
1891
 
 
1892
        # Just a sentry, so that _process_entry can say that this
 
1893
        # record is handled, but isn't interesting to process (unchanged)
 
1894
        uninteresting = object()
 
1895
 
 
1896
 
 
1897
        old_dirname_to_file_id = {}
 
1898
        new_dirname_to_file_id = {}
 
1899
        # TODO: jam 20070516 - Avoid the _get_entry lookup overhead by
 
1900
        #       keeping a cache of directories that we have seen.
 
1901
 
 
1902
        def _process_entry(entry, path_info):
 
1903
            """Compare an entry and real disk to generate delta information.
 
1904
 
 
1905
            :param path_info: top_relpath, basename, kind, lstat, abspath for
 
1906
                the path of entry. If None, then the path is considered absent.
 
1907
                (Perhaps we should pass in a concrete entry for this ?)
 
1908
                Basename is returned as a utf8 string because we expect this
 
1909
                tuple will be ignored, and don't want to take the time to
 
1910
                decode.
 
1911
            :return: None if these don't match
 
1912
                     A tuple of information about the change, or
 
1913
                     the object 'uninteresting' if these match, but are
 
1914
                     basically identical.
 
1915
            """
 
1916
            if source_index is None:
 
1917
                source_details = NULL_PARENT_DETAILS
 
1918
            else:
 
1919
                source_details = entry[1][source_index]
 
1920
            target_details = entry[1][target_index]
 
1921
            target_minikind = target_details[0]
 
1922
            if path_info is not None and target_minikind in 'fdlt':
 
1923
                assert target_index == 0
 
1924
                link_or_sha1 = state.update_entry(entry, abspath=path_info[4],
 
1925
                                                  stat_value=path_info[3])
 
1926
                # The entry may have been modified by update_entry
 
1927
                target_details = entry[1][target_index]
 
1928
                target_minikind = target_details[0]
 
1929
            else:
 
1930
                link_or_sha1 = None
 
1931
            file_id = entry[0][2]
 
1932
            source_minikind = source_details[0]
 
1933
            if source_minikind in 'fdltr' and target_minikind in 'fdlt':
 
1934
                # claimed content in both: diff
 
1935
                #   r    | fdlt   |      | add source to search, add id path move and perform
 
1936
                #        |        |      | diff check on source-target
 
1937
                #   r    | fdlt   |  a   | dangling file that was present in the basis.
 
1938
                #        |        |      | ???
 
1939
                if source_minikind in 'r':
 
1940
                    # add the source to the search path to find any children it
 
1941
                    # has.  TODO ? : only add if it is a container ?
 
1942
                    if not osutils.is_inside_any(searched_specific_files,
 
1943
                                                 source_details[1]):
 
1944
                        search_specific_files.add(source_details[1])
 
1945
                    # generate the old path; this is needed for stating later
 
1946
                    # as well.
 
1947
                    old_path = source_details[1]
 
1948
                    old_dirname, old_basename = os.path.split(old_path)
 
1949
                    path = pathjoin(entry[0][0], entry[0][1])
 
1950
                    old_entry = state._get_entry(source_index,
 
1951
                                                 path_utf8=old_path)
 
1952
                    # update the source details variable to be the real
 
1953
                    # location.
 
1954
                    source_details = old_entry[1][source_index]
 
1955
                    source_minikind = source_details[0]
 
1956
                else:
 
1957
                    old_dirname = entry[0][0]
 
1958
                    old_basename = entry[0][1]
 
1959
                    old_path = path = None
 
1960
                if path_info is None:
 
1961
                    # the file is missing on disk, show as removed.
 
1962
                    content_change = True
 
1963
                    target_kind = None
 
1964
                    target_exec = False
 
1965
                else:
 
1966
                    # source and target are both versioned and disk file is present.
 
1967
                    target_kind = path_info[2]
 
1968
                    if target_kind == 'directory':
 
1969
                        if path is None:
 
1970
                            old_path = path = pathjoin(old_dirname, old_basename)
 
1971
                        new_dirname_to_file_id[path] = file_id
 
1972
                        if source_minikind != 'd':
 
1973
                            content_change = True
 
1974
                        else:
 
1975
                            # directories have no fingerprint
 
1976
                            content_change = False
 
1977
                        target_exec = False
 
1978
                    elif target_kind == 'file':
 
1979
                        if source_minikind != 'f':
 
1980
                            content_change = True
 
1981
                        else:
 
1982
                            # We could check the size, but we already have the
 
1983
                            # sha1 hash.
 
1984
                            content_change = (link_or_sha1 != source_details[1])
 
1985
                        # Target details is updated at update_entry time
 
1986
                        if use_filesystem_for_exec:
 
1987
                            # We don't need S_ISREG here, because we are sure
 
1988
                            # we are dealing with a file.
 
1989
                            target_exec = bool(stat.S_IEXEC & path_info[3].st_mode)
 
1990
                        else:
 
1991
                            target_exec = target_details[3]
 
1992
                    elif target_kind == 'symlink':
 
1993
                        if source_minikind != 'l':
 
1994
                            content_change = True
 
1995
                        else:
 
1996
                            content_change = (link_or_sha1 != source_details[1])
 
1997
                        target_exec = False
 
1998
                    elif target_kind == 'tree-reference':
 
1999
                        if source_minikind != 't':
 
2000
                            content_change = True
 
2001
                        else:
 
2002
                            content_change = False
 
2003
                        target_exec = False
 
2004
                    else:
 
2005
                        raise Exception, "unknown kind %s" % path_info[2]
 
2006
                if source_minikind == 'd':
 
2007
                    if path is None:
 
2008
                        old_path = path = pathjoin(old_dirname, old_basename)
 
2009
                    old_dirname_to_file_id[old_path] = file_id
 
2010
                # parent id is the entry for the path in the target tree
 
2011
                if old_dirname == last_source_parent[0]:
 
2012
                    source_parent_id = last_source_parent[1]
 
2013
                else:
 
2014
                    try:
 
2015
                        source_parent_id = old_dirname_to_file_id[old_dirname]
 
2016
                    except KeyError:
 
2017
                        source_parent_entry = state._get_entry(source_index,
 
2018
                                                               path_utf8=old_dirname)
 
2019
                        source_parent_id = source_parent_entry[0][2]
 
2020
                    if source_parent_id == entry[0][2]:
 
2021
                        # This is the root, so the parent is None
 
2022
                        source_parent_id = None
 
2023
                    else:
 
2024
                        last_source_parent[0] = old_dirname
 
2025
                        last_source_parent[1] = source_parent_id
 
2026
                new_dirname = entry[0][0]
 
2027
                if new_dirname == last_target_parent[0]:
 
2028
                    target_parent_id = last_target_parent[1]
 
2029
                else:
 
2030
                    try:
 
2031
                        target_parent_id = new_dirname_to_file_id[new_dirname]
 
2032
                    except KeyError:
 
2033
                        # TODO: We don't always need to do the lookup, because the
 
2034
                        #       parent entry will be the same as the source entry.
 
2035
                        target_parent_entry = state._get_entry(target_index,
 
2036
                                                               path_utf8=new_dirname)
 
2037
                        assert target_parent_entry != (None, None), (
 
2038
                            "Could not find target parent in wt: %s\nparent of: %s"
 
2039
                            % (new_dirname, entry))
 
2040
                        target_parent_id = target_parent_entry[0][2]
 
2041
                    if target_parent_id == entry[0][2]:
 
2042
                        # This is the root, so the parent is None
 
2043
                        target_parent_id = None
 
2044
                    else:
 
2045
                        last_target_parent[0] = new_dirname
 
2046
                        last_target_parent[1] = target_parent_id
 
2047
 
 
2048
                source_exec = source_details[3]
 
2049
                if (include_unchanged
 
2050
                    or content_change
 
2051
                    or source_parent_id != target_parent_id
 
2052
                    or old_basename != entry[0][1]
 
2053
                    or source_exec != target_exec
 
2054
                    ):
 
2055
                    if old_path is None:
 
2056
                        old_path = path = pathjoin(old_dirname, old_basename)
 
2057
                        old_path_u = utf8_decode(old_path)[0]
 
2058
                        path_u = old_path_u
 
2059
                    else:
 
2060
                        old_path_u = utf8_decode(old_path)[0]
 
2061
                        if old_path == path:
 
2062
                            path_u = old_path_u
 
2063
                        else:
 
2064
                            path_u = utf8_decode(path)[0]
 
2065
                    source_kind = _minikind_to_kind[source_minikind]
 
2066
                    return (entry[0][2],
 
2067
                           (old_path_u, path_u),
 
2068
                           content_change,
 
2069
                           (True, True),
 
2070
                           (source_parent_id, target_parent_id),
 
2071
                           (utf8_decode(old_basename)[0], utf8_decode(entry[0][1])[0]),
 
2072
                           (source_kind, target_kind),
 
2073
                           (source_exec, target_exec))
 
2074
                else:
 
2075
                    return uninteresting
 
2076
            elif source_minikind in 'a' and target_minikind in 'fdlt':
 
2077
                # looks like a new file
 
2078
                if path_info is not None:
 
2079
                    path = pathjoin(entry[0][0], entry[0][1])
 
2080
                    # parent id is the entry for the path in the target tree
 
2081
                    # TODO: these are the same for an entire directory: cache em.
 
2082
                    parent_id = state._get_entry(target_index,
 
2083
                                                 path_utf8=entry[0][0])[0][2]
 
2084
                    if parent_id == entry[0][2]:
 
2085
                        parent_id = None
 
2086
                    if use_filesystem_for_exec:
 
2087
                        # We need S_ISREG here, because we aren't sure if this
 
2088
                        # is a file or not.
 
2089
                        target_exec = bool(
 
2090
                            stat.S_ISREG(path_info[3].st_mode)
 
2091
                            and stat.S_IEXEC & path_info[3].st_mode)
 
2092
                    else:
 
2093
                        target_exec = target_details[3]
 
2094
                    return (entry[0][2],
 
2095
                           (None, utf8_decode(path)[0]),
 
2096
                           True,
 
2097
                           (False, True),
 
2098
                           (None, parent_id),
 
2099
                           (None, utf8_decode(entry[0][1])[0]),
 
2100
                           (None, path_info[2]),
 
2101
                           (None, target_exec))
 
2102
                else:
 
2103
                    # but its not on disk: we deliberately treat this as just
 
2104
                    # never-present. (Why ?! - RBC 20070224)
 
2105
                    pass
 
2106
            elif source_minikind in 'fdlt' and target_minikind in 'a':
 
2107
                # unversioned, possibly, or possibly not deleted: we dont care.
 
2108
                # if its still on disk, *and* theres no other entry at this
 
2109
                # path [we dont know this in this routine at the moment -
 
2110
                # perhaps we should change this - then it would be an unknown.
 
2111
                old_path = pathjoin(entry[0][0], entry[0][1])
 
2112
                # parent id is the entry for the path in the target tree
 
2113
                parent_id = state._get_entry(source_index, path_utf8=entry[0][0])[0][2]
 
2114
                if parent_id == entry[0][2]:
 
2115
                    parent_id = None
 
2116
                return (entry[0][2],
 
2117
                       (utf8_decode(old_path)[0], None),
 
2118
                       True,
 
2119
                       (True, False),
 
2120
                       (parent_id, None),
 
2121
                       (utf8_decode(entry[0][1])[0], None),
 
2122
                       (_minikind_to_kind[source_minikind], None),
 
2123
                       (source_details[3], None))
 
2124
            elif source_minikind in 'fdlt' and target_minikind in 'r':
 
2125
                # a rename; could be a true rename, or a rename inherited from
 
2126
                # a renamed parent. TODO: handle this efficiently. Its not
 
2127
                # common case to rename dirs though, so a correct but slow
 
2128
                # implementation will do.
 
2129
                if not osutils.is_inside_any(searched_specific_files, target_details[1]):
 
2130
                    search_specific_files.add(target_details[1])
 
2131
            elif source_minikind in 'ra' and target_minikind in 'ra':
 
2132
                # neither of the selected trees contain this file,
 
2133
                # so skip over it. This is not currently directly tested, but
 
2134
                # is indirectly via test_too_much.TestCommands.test_conflicts.
 
2135
                pass
 
2136
            else:
 
2137
                raise AssertionError("don't know how to compare "
 
2138
                    "source_minikind=%r, target_minikind=%r"
 
2139
                    % (source_minikind, target_minikind))
 
2140
                ## import pdb;pdb.set_trace()
 
2141
            return None
 
2142
 
 
2143
        while search_specific_files:
 
2144
            # TODO: the pending list should be lexically sorted?  the
 
2145
            # interface doesn't require it.
 
2146
            current_root = search_specific_files.pop()
 
2147
            current_root_unicode = current_root.decode('utf8')
 
2148
            searched_specific_files.add(current_root)
 
2149
            # process the entries for this containing directory: the rest will be
 
2150
            # found by their parents recursively.
 
2151
            root_entries = _entries_for_path(current_root)
 
2152
            root_abspath = self.target.abspath(current_root_unicode)
 
2153
            try:
 
2154
                root_stat = os.lstat(root_abspath)
 
2155
            except OSError, e:
 
2156
                if e.errno == errno.ENOENT:
 
2157
                    # the path does not exist: let _process_entry know that.
 
2158
                    root_dir_info = None
 
2159
                else:
 
2160
                    # some other random error: hand it up.
 
2161
                    raise
 
2162
            else:
 
2163
                root_dir_info = ('', current_root,
 
2164
                    osutils.file_kind_from_stat_mode(root_stat.st_mode), root_stat,
 
2165
                    root_abspath)
 
2166
                if root_dir_info[2] == 'directory':
 
2167
                    if self.target._directory_is_tree_reference(
 
2168
                        current_root.decode('utf8')):
 
2169
                        root_dir_info = root_dir_info[:2] + \
 
2170
                            ('tree-reference',) + root_dir_info[3:]
 
2171
 
 
2172
            if not root_entries and not root_dir_info:
 
2173
                # this specified path is not present at all, skip it.
 
2174
                continue
 
2175
            path_handled = False
 
2176
            for entry in root_entries:
 
2177
                result = _process_entry(entry, root_dir_info)
 
2178
                if result is not None:
 
2179
                    path_handled = True
 
2180
                    if result is not uninteresting:
 
2181
                        yield result
 
2182
            if want_unversioned and not path_handled and root_dir_info:
 
2183
                new_executable = bool(
 
2184
                    stat.S_ISREG(root_dir_info[3].st_mode)
 
2185
                    and stat.S_IEXEC & root_dir_info[3].st_mode)
 
2186
                yield (None,
 
2187
                       (None, current_root_unicode),
 
2188
                       True,
 
2189
                       (False, False),
 
2190
                       (None, None),
 
2191
                       (None, splitpath(current_root_unicode)[-1]),
 
2192
                       (None, root_dir_info[2]),
 
2193
                       (None, new_executable)
 
2194
                      )
 
2195
            initial_key = (current_root, '', '')
 
2196
            block_index, _ = state._find_block_index_from_key(initial_key)
 
2197
            if block_index == 0:
 
2198
                # we have processed the total root already, but because the
 
2199
                # initial key matched it we should skip it here.
 
2200
                block_index +=1
 
2201
            if root_dir_info and root_dir_info[2] == 'tree-reference':
 
2202
                current_dir_info = None
 
2203
            else:
 
2204
                dir_iterator = osutils._walkdirs_utf8(root_abspath, prefix=current_root)
 
2205
                try:
 
2206
                    current_dir_info = dir_iterator.next()
 
2207
                except OSError, e:
 
2208
                    # on win32, python2.4 has e.errno == ERROR_DIRECTORY, but
 
2209
                    # python 2.5 has e.errno == EINVAL,
 
2210
                    #            and e.winerror == ERROR_DIRECTORY
 
2211
                    e_winerror = getattr(e, 'winerror', None)
 
2212
                    win_errors = (ERROR_DIRECTORY, ERROR_PATH_NOT_FOUND)
 
2213
                    # there may be directories in the inventory even though
 
2214
                    # this path is not a file on disk: so mark it as end of
 
2215
                    # iterator
 
2216
                    if e.errno in (errno.ENOENT, errno.ENOTDIR, errno.EINVAL):
 
2217
                        current_dir_info = None
 
2218
                    elif (sys.platform == 'win32'
 
2219
                          and (e.errno in win_errors
 
2220
                               or e_winerror in win_errors)):
 
2221
                        current_dir_info = None
 
2222
                    else:
 
2223
                        raise
 
2224
                else:
 
2225
                    if current_dir_info[0][0] == '':
 
2226
                        # remove .bzr from iteration
 
2227
                        bzr_index = bisect_left(current_dir_info[1], ('.bzr',))
 
2228
                        assert current_dir_info[1][bzr_index][0] == '.bzr'
 
2229
                        del current_dir_info[1][bzr_index]
 
2230
            # walk until both the directory listing and the versioned metadata
 
2231
            # are exhausted. 
 
2232
            if (block_index < len(state._dirblocks) and
 
2233
                osutils.is_inside(current_root, state._dirblocks[block_index][0])):
 
2234
                current_block = state._dirblocks[block_index]
 
2235
            else:
 
2236
                current_block = None
 
2237
            while (current_dir_info is not None or
 
2238
                   current_block is not None):
 
2239
                if (current_dir_info and current_block
 
2240
                    and current_dir_info[0][0] != current_block[0]):
 
2241
                    if cmp_by_dirs(current_dir_info[0][0], current_block[0]) < 0:
 
2242
                        # filesystem data refers to paths not covered by the dirblock.
 
2243
                        # this has two possibilities:
 
2244
                        # A) it is versioned but empty, so there is no block for it
 
2245
                        # B) it is not versioned.
 
2246
 
 
2247
                        # if (A) then we need to recurse into it to check for
 
2248
                        # new unknown files or directories.
 
2249
                        # if (B) then we should ignore it, because we don't
 
2250
                        # recurse into unknown directories.
 
2251
                        path_index = 0
 
2252
                        while path_index < len(current_dir_info[1]):
 
2253
                                current_path_info = current_dir_info[1][path_index]
 
2254
                                if want_unversioned:
 
2255
                                    if current_path_info[2] == 'directory':
 
2256
                                        if self.target._directory_is_tree_reference(
 
2257
                                            current_path_info[0].decode('utf8')):
 
2258
                                            current_path_info = current_path_info[:2] + \
 
2259
                                                ('tree-reference',) + current_path_info[3:]
 
2260
                                    new_executable = bool(
 
2261
                                        stat.S_ISREG(current_path_info[3].st_mode)
 
2262
                                        and stat.S_IEXEC & current_path_info[3].st_mode)
 
2263
                                    yield (None,
 
2264
                                        (None, utf8_decode(current_path_info[0])[0]),
 
2265
                                        True,
 
2266
                                        (False, False),
 
2267
                                        (None, None),
 
2268
                                        (None, utf8_decode(current_path_info[1])[0]),
 
2269
                                        (None, current_path_info[2]),
 
2270
                                        (None, new_executable))
 
2271
                                # dont descend into this unversioned path if it is
 
2272
                                # a dir
 
2273
                                if current_path_info[2] in ('directory',
 
2274
                                                            'tree-reference'):
 
2275
                                    del current_dir_info[1][path_index]
 
2276
                                    path_index -= 1
 
2277
                                path_index += 1
 
2278
 
 
2279
                        # This dir info has been handled, go to the next
 
2280
                        try:
 
2281
                            current_dir_info = dir_iterator.next()
 
2282
                        except StopIteration:
 
2283
                            current_dir_info = None
 
2284
                    else:
 
2285
                        # We have a dirblock entry for this location, but there
 
2286
                        # is no filesystem path for this. This is most likely
 
2287
                        # because a directory was removed from the disk.
 
2288
                        # We don't have to report the missing directory,
 
2289
                        # because that should have already been handled, but we
 
2290
                        # need to handle all of the files that are contained
 
2291
                        # within.
 
2292
                        for current_entry in current_block[1]:
 
2293
                            # entry referring to file not present on disk.
 
2294
                            # advance the entry only, after processing.
 
2295
                            result = _process_entry(current_entry, None)
 
2296
                            if result is not None:
 
2297
                                if result is not uninteresting:
 
2298
                                    yield result
 
2299
                        block_index +=1
 
2300
                        if (block_index < len(state._dirblocks) and
 
2301
                            osutils.is_inside(current_root,
 
2302
                                              state._dirblocks[block_index][0])):
 
2303
                            current_block = state._dirblocks[block_index]
 
2304
                        else:
 
2305
                            current_block = None
 
2306
                    continue
 
2307
                entry_index = 0
 
2308
                if current_block and entry_index < len(current_block[1]):
 
2309
                    current_entry = current_block[1][entry_index]
 
2310
                else:
 
2311
                    current_entry = None
 
2312
                advance_entry = True
 
2313
                path_index = 0
 
2314
                if current_dir_info and path_index < len(current_dir_info[1]):
 
2315
                    current_path_info = current_dir_info[1][path_index]
 
2316
                    if current_path_info[2] == 'directory':
 
2317
                        if self.target._directory_is_tree_reference(
 
2318
                            current_path_info[0].decode('utf8')):
 
2319
                            current_path_info = current_path_info[:2] + \
 
2320
                                ('tree-reference',) + current_path_info[3:]
 
2321
                else:
 
2322
                    current_path_info = None
 
2323
                advance_path = True
 
2324
                path_handled = False
 
2325
                while (current_entry is not None or
 
2326
                    current_path_info is not None):
 
2327
                    if current_entry is None:
 
2328
                        # the check for path_handled when the path is adnvaced
 
2329
                        # will yield this path if needed.
 
2330
                        pass
 
2331
                    elif current_path_info is None:
 
2332
                        # no path is fine: the per entry code will handle it.
 
2333
                        result = _process_entry(current_entry, current_path_info)
 
2334
                        if result is not None:
 
2335
                            if result is not uninteresting:
 
2336
                                yield result
 
2337
                    elif (current_entry[0][1] != current_path_info[1]
 
2338
                          or current_entry[1][target_index][0] in 'ar'):
 
2339
                        # The current path on disk doesn't match the dirblock
 
2340
                        # record. Either the dirblock is marked as absent, or
 
2341
                        # the file on disk is not present at all in the
 
2342
                        # dirblock. Either way, report about the dirblock
 
2343
                        # entry, and let other code handle the filesystem one.
 
2344
 
 
2345
                        # Compare the basename for these files to determine
 
2346
                        # which comes first
 
2347
                        if current_path_info[1] < current_entry[0][1]:
 
2348
                            # extra file on disk: pass for now, but only
 
2349
                            # increment the path, not the entry
 
2350
                            advance_entry = False
 
2351
                        else:
 
2352
                            # entry referring to file not present on disk.
 
2353
                            # advance the entry only, after processing.
 
2354
                            result = _process_entry(current_entry, None)
 
2355
                            if result is not None:
 
2356
                                if result is not uninteresting:
 
2357
                                    yield result
 
2358
                            advance_path = False
 
2359
                    else:
 
2360
                        result = _process_entry(current_entry, current_path_info)
 
2361
                        if result is not None:
 
2362
                            path_handled = True
 
2363
                            if result is not uninteresting:
 
2364
                                yield result
 
2365
                    if advance_entry and current_entry is not None:
 
2366
                        entry_index += 1
 
2367
                        if entry_index < len(current_block[1]):
 
2368
                            current_entry = current_block[1][entry_index]
 
2369
                        else:
 
2370
                            current_entry = None
 
2371
                    else:
 
2372
                        advance_entry = True # reset the advance flaga
 
2373
                    if advance_path and current_path_info is not None:
 
2374
                        if not path_handled:
 
2375
                            # unversioned in all regards
 
2376
                            if want_unversioned:
 
2377
                                new_executable = bool(
 
2378
                                    stat.S_ISREG(current_path_info[3].st_mode)
 
2379
                                    and stat.S_IEXEC & current_path_info[3].st_mode)
 
2380
                                yield (None,
 
2381
                                    (None, utf8_decode(current_path_info[0])[0]),
 
2382
                                    True,
 
2383
                                    (False, False),
 
2384
                                    (None, None),
 
2385
                                    (None, utf8_decode(current_path_info[1])[0]),
 
2386
                                    (None, current_path_info[2]),
 
2387
                                    (None, new_executable))
 
2388
                            # dont descend into this unversioned path if it is
 
2389
                            # a dir
 
2390
                            if current_path_info[2] in ('directory'):
 
2391
                                del current_dir_info[1][path_index]
 
2392
                                path_index -= 1
 
2393
                        # dont descend the disk iterator into any tree 
 
2394
                        # paths.
 
2395
                        if current_path_info[2] == 'tree-reference':
 
2396
                            del current_dir_info[1][path_index]
 
2397
                            path_index -= 1
 
2398
                        path_index += 1
 
2399
                        if path_index < len(current_dir_info[1]):
 
2400
                            current_path_info = current_dir_info[1][path_index]
 
2401
                            if current_path_info[2] == 'directory':
 
2402
                                if self.target._directory_is_tree_reference(
 
2403
                                    current_path_info[0].decode('utf8')):
 
2404
                                    current_path_info = current_path_info[:2] + \
 
2405
                                        ('tree-reference',) + current_path_info[3:]
 
2406
                        else:
 
2407
                            current_path_info = None
 
2408
                        path_handled = False
 
2409
                    else:
 
2410
                        advance_path = True # reset the advance flagg.
 
2411
                if current_block is not None:
 
2412
                    block_index += 1
 
2413
                    if (block_index < len(state._dirblocks) and
 
2414
                        osutils.is_inside(current_root, state._dirblocks[block_index][0])):
 
2415
                        current_block = state._dirblocks[block_index]
 
2416
                    else:
 
2417
                        current_block = None
 
2418
                if current_dir_info is not None:
 
2419
                    try:
 
2420
                        current_dir_info = dir_iterator.next()
 
2421
                    except StopIteration:
 
2422
                        current_dir_info = None
 
2423
 
2095
2424
 
2096
2425
    @staticmethod
2097
2426
    def is_compatible(source, target):
2098
2427
        # the target must be a dirstate working tree
2099
 
        if not isinstance(target, DirStateWorkingTree):
 
2428
        if not isinstance(target, WorkingTree4):
2100
2429
            return False
2101
 
        # the source must be a revtree or dirstate rev tree.
 
2430
        # the source must be a revtreee or dirstate rev tree.
2102
2431
        if not isinstance(source,
2103
2432
            (revisiontree.RevisionTree, DirStateRevisionTree)):
2104
2433
            return False
2105
2434
        # the source revid must be in the target dirstate
2106
 
        if not (source._revision_id == _mod_revision.NULL_REVISION or
 
2435
        if not (source._revision_id == NULL_REVISION or
2107
2436
            source._revision_id in target.get_parent_ids()):
2108
 
            # TODO: what about ghosts? it may well need to
 
2437
            # TODO: what about ghosts? it may well need to 
2109
2438
            # check for them explicitly.
2110
2439
            return False
2111
2440
        return True
2121
2450
 
2122
2451
    def convert(self, tree):
2123
2452
        # lock the control files not the tree, so that we dont get tree
2124
 
        # on-unlock behaviours, and so that noone else diddles with the
 
2453
        # on-unlock behaviours, and so that noone else diddles with the 
2125
2454
        # tree during upgrade.
2126
2455
        tree._control_files.lock_write()
2127
2456
        try:
2153
2482
 
2154
2483
    def update_format(self, tree):
2155
2484
        """Change the format marker."""
2156
 
        tree._transport.put_bytes('format',
2157
 
            self.target_format.get_format_string(),
2158
 
            mode=tree.bzrdir._get_file_mode())
2159
 
 
2160
 
 
2161
 
class Converter4to5(object):
2162
 
    """Perform an in-place upgrade of format 4 to format 5 trees."""
2163
 
 
2164
 
    def __init__(self):
2165
 
        self.target_format = WorkingTreeFormat5()
2166
 
 
2167
 
    def convert(self, tree):
2168
 
        # lock the control files not the tree, so that we don't get tree
2169
 
        # on-unlock behaviours, and so that no-one else diddles with the
2170
 
        # tree during upgrade.
2171
 
        tree._control_files.lock_write()
2172
 
        try:
2173
 
            self.update_format(tree)
2174
 
        finally:
2175
 
            tree._control_files.unlock()
2176
 
 
2177
 
    def update_format(self, tree):
2178
 
        """Change the format marker."""
2179
 
        tree._transport.put_bytes('format',
2180
 
            self.target_format.get_format_string(),
2181
 
            mode=tree.bzrdir._get_file_mode())
2182
 
 
2183
 
 
2184
 
class Converter4or5to6(object):
2185
 
    """Perform an in-place upgrade of format 4 or 5 to format 6 trees."""
2186
 
 
2187
 
    def __init__(self):
2188
 
        self.target_format = WorkingTreeFormat6()
2189
 
 
2190
 
    def convert(self, tree):
2191
 
        # lock the control files not the tree, so that we don't get tree
2192
 
        # on-unlock behaviours, and so that no-one else diddles with the
2193
 
        # tree during upgrade.
2194
 
        tree._control_files.lock_write()
2195
 
        try:
2196
 
            self.init_custom_control_files(tree)
2197
 
            self.update_format(tree)
2198
 
        finally:
2199
 
            tree._control_files.unlock()
2200
 
 
2201
 
    def init_custom_control_files(self, tree):
2202
 
        """Initialize custom control files."""
2203
 
        tree._transport.put_bytes('views', '',
2204
 
            mode=tree.bzrdir._get_file_mode())
2205
 
 
2206
 
    def update_format(self, tree):
2207
 
        """Change the format marker."""
2208
 
        tree._transport.put_bytes('format',
2209
 
            self.target_format.get_format_string(),
2210
 
            mode=tree.bzrdir._get_file_mode())
 
2485
        tree._control_files.put_utf8('format',
 
2486
            self.target_format.get_format_string())