~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree_4.py

Fix some more PEP8isms and delete useless import

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2007-2012 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 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
 
22
22
WorkingTree.open(dir).
23
23
"""
24
24
 
25
 
from __future__ import absolute_import
26
 
 
27
25
from cStringIO import StringIO
28
26
import os
29
27
import sys
30
28
 
31
29
from bzrlib.lazy_import import lazy_import
32
30
lazy_import(globals(), """
 
31
from bisect import bisect_left
 
32
import collections
 
33
from copy import deepcopy
33
34
import errno
 
35
import itertools
 
36
import operator
34
37
import stat
 
38
from time import time
 
39
import warnings
35
40
 
 
41
import bzrlib
36
42
from bzrlib import (
37
43
    bzrdir,
38
44
    cache_utf8,
39
 
    config,
40
45
    conflicts as _mod_conflicts,
41
 
    controldir,
42
46
    debug,
 
47
    delta,
43
48
    dirstate,
44
49
    errors,
45
 
    filters as _mod_filters,
46
50
    generate_ids,
 
51
    globbing,
 
52
    ignores,
 
53
    merge,
47
54
    osutils,
48
55
    revision as _mod_revision,
49
56
    revisiontree,
 
57
    textui,
50
58
    trace,
51
59
    transform,
52
 
    views,
 
60
    urlutils,
 
61
    xml5,
 
62
    xml6,
53
63
    )
 
64
import bzrlib.branch
 
65
from bzrlib.transport import get_transport
 
66
import bzrlib.ui
54
67
""")
55
68
 
 
69
from bzrlib import symbol_versioning
56
70
from bzrlib.decorators import needs_read_lock, needs_write_lock
57
 
from bzrlib.inventory import Inventory, ROOT_ID, entry_factory
58
 
from bzrlib.lock import LogicalLockResult
59
 
from bzrlib.lockable_files import LockableFiles
 
71
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, entry_factory
 
72
from bzrlib.lockable_files import LockableFiles, TransportLock
60
73
from bzrlib.lockdir import LockDir
61
 
from bzrlib.mutabletree import (
62
 
    MutableTree,
63
 
    needs_tree_write_lock,
64
 
    )
 
74
import bzrlib.mutabletree
 
75
from bzrlib.mutabletree import needs_tree_write_lock
65
76
from bzrlib.osutils import (
66
77
    file_kind,
67
78
    isdir,
 
79
    normpath,
68
80
    pathjoin,
 
81
    rand_chars,
69
82
    realpath,
70
83
    safe_unicode,
71
 
    )
72
 
from bzrlib.symbol_versioning import (
73
 
    deprecated_in,
74
 
    deprecated_method,
75
 
    )
 
84
    splitpath,
 
85
    )
 
86
from bzrlib.trace import mutter, note
76
87
from bzrlib.transport.local import LocalTransport
77
 
from bzrlib.tree import (
78
 
    InterTree,
79
 
    InventoryTree,
80
 
    )
81
 
from bzrlib.workingtree import (
82
 
    InventoryWorkingTree,
83
 
    WorkingTree,
84
 
    WorkingTreeFormatMetaDir,
85
 
    )
86
 
 
87
 
 
88
 
class DirStateWorkingTree(InventoryWorkingTree):
 
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
        )
 
97
from bzrlib.tree import Tree
 
98
from bzrlib.workingtree import WorkingTree, WorkingTree3, WorkingTreeFormat3
 
99
 
 
100
 
 
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
    """
89
119
 
90
120
    def __init__(self, basedir,
91
121
                 branch,
102
132
        self._format = _format
103
133
        self.bzrdir = _bzrdir
104
134
        basedir = safe_unicode(basedir)
105
 
        trace.mutter("opening working tree %r", basedir)
 
135
        mutter("opening working tree %r", basedir)
106
136
        self._branch = branch
107
137
        self.basedir = realpath(basedir)
108
138
        # if branch is at our basedir and is a format 6 or less
119
149
        self._setup_directory_is_tree_reference()
120
150
        self._detect_case_handling()
121
151
        self._rules_searcher = None
122
 
        self.views = self._make_views()
123
 
        #--- allow tests to select the dirstate iter_changes implementation
124
 
        self._iter_changes = dirstate._process_entry
125
152
 
126
153
    @needs_tree_write_lock
127
154
    def _add(self, files, ids, kinds):
142
169
            state.add(f, file_id, kind, None, '')
143
170
        self._make_dirty(reset_inventory=True)
144
171
 
145
 
    def _get_check_refs(self):
146
 
        """Return the references needed to perform a check of this tree."""
147
 
        return [('trees', self.last_revision())]
148
 
 
149
172
    def _make_dirty(self, reset_inventory):
150
173
        """Make the tree state dirty.
151
174
 
159
182
    @needs_tree_write_lock
160
183
    def add_reference(self, sub_tree):
161
184
        # use standard implementation, which calls back to self._add
162
 
        #
 
185
        # 
163
186
        # So we don't store the reference_revision in the working dirstate,
164
 
        # it's just recorded at the moment of commit.
 
187
        # it's just recorded at the moment of commit. 
165
188
        self._add_reference(sub_tree)
166
189
 
167
190
    def break_lock(self):
203
226
 
204
227
    def _comparison_data(self, entry, path):
205
228
        kind, executable, stat_value = \
206
 
            WorkingTree._comparison_data(self, entry, path)
 
229
            WorkingTree3._comparison_data(self, entry, path)
207
230
        # it looks like a plain directory, but it's really a reference -- see
208
231
        # also kind()
209
 
        if (self._repo_supports_tree_reference and kind == 'directory'
210
 
            and entry is not None and entry.kind == 'tree-reference'):
 
232
        if (self._repo_supports_tree_reference and
 
233
            kind == 'directory' and
 
234
            self._directory_is_tree_reference(path)):
211
235
            kind = 'tree-reference'
212
236
        return kind, executable, stat_value
213
237
 
215
239
    def commit(self, message=None, revprops=None, *args, **kwargs):
216
240
        # mark the tree as dirty post commit - commit
217
241
        # can change the current versioned list by doing deletes.
218
 
        result = WorkingTree.commit(self, message, revprops, *args, **kwargs)
 
242
        result = WorkingTree3.commit(self, message, revprops, *args, **kwargs)
219
243
        self._make_dirty(reset_inventory=True)
220
244
        return result
221
245
 
239
263
            return self._dirstate
240
264
        local_path = self.bzrdir.get_workingtree_transport(None
241
265
            ).local_abspath('dirstate')
242
 
        self._dirstate = dirstate.DirState.on_file(local_path,
243
 
            self._sha1_provider(), self._worth_saving_limit())
 
266
        self._dirstate = dirstate.DirState.on_file(local_path)
244
267
        return self._dirstate
245
268
 
246
 
    def _sha1_provider(self):
247
 
        """A function that returns a SHA1Provider suitable for this tree.
248
 
 
249
 
        :return: None if content filtering is not supported by this tree.
250
 
          Otherwise, a SHA1Provider is returned that sha's the canonical
251
 
          form of files, i.e. after read filters are applied.
252
 
        """
253
 
        if self.supports_content_filtering():
254
 
            return ContentFilterAwareSHA1Provider(self)
255
 
        else:
256
 
            return None
257
 
 
258
 
    def _worth_saving_limit(self):
259
 
        """How many hash changes are ok before we must save the dirstate.
260
 
 
261
 
        :return: an integer. -1 means never save.
262
 
        """
263
 
        conf = self.get_config_stack()
264
 
        return conf.get('bzr.workingtree.worth_saving_limit')
265
 
 
266
269
    def filter_unversioned_files(self, paths):
267
270
        """Filter out paths that are versioned.
268
271
 
300
303
 
301
304
    def _generate_inventory(self):
302
305
        """Create and set self.inventory from the dirstate object.
303
 
 
 
306
        
304
307
        This is relatively expensive: we have to walk the entire dirstate.
305
308
        Ideally we would not, and can deprecate this function.
306
309
        """
351
354
                    parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
352
355
                elif kind == 'tree-reference':
353
356
                    if not self._repo_supports_tree_reference:
354
 
                        raise errors.UnsupportedOperation(
355
 
                            self._generate_inventory,
356
 
                            self.branch.repository)
 
357
                        raise AssertionError(
 
358
                            "repository of %r "
 
359
                            "doesn't support tree references "
 
360
                            "required by entry %r"
 
361
                            % (self, name))
357
362
                    inv_entry.reference_revision = link_or_sha1 or None
358
363
                elif kind != 'symlink':
359
364
                    raise AssertionError("unknown kind %r" % kind)
374
379
        If either file_id or path is supplied, it is used as the key to lookup.
375
380
        If both are supplied, the fastest lookup is used, and an error is
376
381
        raised if they do not both point at the same row.
377
 
 
 
382
        
378
383
        :param file_id: An optional unicode file_id to be looked up.
379
384
        :param path: An optional unicode path to be looked up.
380
385
        :return: The dirstate row tuple for path/file_id, or (None, None)
398
403
        state = self.current_dirstate()
399
404
        if stat_value is None:
400
405
            try:
401
 
                stat_value = osutils.lstat(file_abspath)
 
406
                stat_value = os.lstat(file_abspath)
402
407
            except OSError, e:
403
408
                if e.errno == errno.ENOENT:
404
409
                    return None
405
410
                else:
406
411
                    raise
407
 
        link_or_sha1 = dirstate.update_entry(state, entry, file_abspath,
408
 
            stat_value=stat_value)
 
412
        link_or_sha1 = state.update_entry(entry, file_abspath,
 
413
                                          stat_value=stat_value)
409
414
        if entry[1][0][0] == 'f':
410
 
            if link_or_sha1 is None:
411
 
                file_obj, statvalue = self.get_file_with_stat(file_id, path)
412
 
                try:
413
 
                    sha1 = osutils.sha_file(file_obj)
414
 
                finally:
415
 
                    file_obj.close()
416
 
                self._observed_sha1(file_id, path, (sha1, statvalue))
417
 
                return sha1
418
 
            else:
419
 
                return link_or_sha1
 
415
            return link_or_sha1
420
416
        return None
421
417
 
422
 
    def _get_root_inventory(self):
 
418
    def _get_inventory(self):
423
419
        """Get the inventory for the tree. This is only valid within a lock."""
424
420
        if 'evil' in debug.debug_flags:
425
421
            trace.mutter_callsite(2,
430
426
        self._generate_inventory()
431
427
        return self._inventory
432
428
 
433
 
    @deprecated_method(deprecated_in((2, 5, 0)))
434
 
    def _get_inventory(self):
435
 
        return self.root_inventory
436
 
 
437
429
    inventory = property(_get_inventory,
438
430
                         doc="Inventory of this Tree")
439
431
 
440
 
    root_inventory = property(_get_root_inventory,
441
 
        "Root inventory of this tree")
442
 
 
443
432
    @needs_read_lock
444
433
    def get_parent_ids(self):
445
434
        """See Tree.get_parent_ids.
446
 
 
 
435
        
447
436
        This implementation requests the ids list from the dirstate file.
448
437
        """
449
438
        return self.current_dirstate().get_parent_ids()
471
460
        return osutils.lexists(pathjoin(
472
461
                    self.basedir, row[0].decode('utf8'), row[1].decode('utf8')))
473
462
 
474
 
    def has_or_had_id(self, file_id):
475
 
        state = self.current_dirstate()
476
 
        row, parents = self._get_entry(file_id=file_id)
477
 
        return row is not None
478
 
 
479
463
    @needs_read_lock
480
464
    def id2path(self, file_id):
481
465
        "Convert a file-id to a path."
492
476
            return False # Missing entries are not executable
493
477
        return entry[1][0][3] # Executable?
494
478
 
495
 
    def is_executable(self, file_id, path=None):
496
 
        """Test if a file is executable or not.
 
479
    if not osutils.supports_executable():
 
480
        def is_executable(self, file_id, path=None):
 
481
            """Test if a file is executable or not.
497
482
 
498
 
        Note: The caller is expected to take a read-lock before calling this.
499
 
        """
500
 
        if not self._supports_executable():
 
483
            Note: The caller is expected to take a read-lock before calling this.
 
484
            """
501
485
            entry = self._get_entry(file_id=file_id, path=path)
502
486
            if entry == (None, None):
503
487
                return False
504
488
            return entry[1][0][3]
505
 
        else:
 
489
 
 
490
        _is_executable_from_path_and_stat = \
 
491
            _is_executable_from_path_and_stat_from_basis
 
492
    else:
 
493
        def is_executable(self, file_id, path=None):
 
494
            """Test if a file is executable or not.
 
495
 
 
496
            Note: The caller is expected to take a read-lock before calling this.
 
497
            """
506
498
            self._must_be_locked()
507
499
            if not path:
508
500
                path = self.id2path(file_id)
509
 
            mode = osutils.lstat(self.abspath(path)).st_mode
 
501
            mode = os.lstat(self.abspath(path)).st_mode
510
502
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
511
503
 
512
504
    def all_file_ids(self):
556
548
                # path is missing on disk.
557
549
                continue
558
550
 
559
 
    def _observed_sha1(self, file_id, path, (sha1, statvalue)):
560
 
        """See MutableTree._observed_sha1."""
561
 
        state = self.current_dirstate()
562
 
        entry = self._get_entry(file_id=file_id, path=path)
563
 
        state._observed_sha1(entry, sha1, statvalue)
564
 
 
565
551
    def kind(self, file_id):
566
552
        """Return the kind of a file.
567
553
 
579
565
    def _kind(self, relpath):
580
566
        abspath = self.abspath(relpath)
581
567
        kind = file_kind(abspath)
582
 
        if (self._repo_supports_tree_reference and kind == 'directory'):
583
 
            entry = self._get_entry(path=relpath)
584
 
            if entry[1] is not None:
585
 
                if entry[1][0][0] == 't':
586
 
                    kind = 'tree-reference'
 
568
        if (self._repo_supports_tree_reference and
 
569
            kind == 'directory' and
 
570
            self._directory_is_tree_reference(relpath)):
 
571
            kind = 'tree-reference'
587
572
        return kind
588
573
 
589
574
    @needs_read_lock
596
581
            return _mod_revision.NULL_REVISION
597
582
 
598
583
    def lock_read(self):
599
 
        """See Branch.lock_read, and WorkingTree.unlock.
600
 
 
601
 
        :return: A bzrlib.lock.LogicalLockResult.
602
 
        """
 
584
        """See Branch.lock_read, and WorkingTree.unlock."""
603
585
        self.branch.lock_read()
604
586
        try:
605
587
            self._control_files.lock_read()
618
600
        except:
619
601
            self.branch.unlock()
620
602
            raise
621
 
        return LogicalLockResult(self.unlock)
622
603
 
623
604
    def _lock_self_write(self):
624
605
        """This should be called after the branch is locked."""
639
620
        except:
640
621
            self.branch.unlock()
641
622
            raise
642
 
        return LogicalLockResult(self.unlock)
643
623
 
644
624
    def lock_tree_write(self):
645
 
        """See MutableTree.lock_tree_write, and WorkingTree.unlock.
646
 
 
647
 
        :return: A bzrlib.lock.LogicalLockResult.
648
 
        """
 
625
        """See MutableTree.lock_tree_write, and WorkingTree.unlock."""
649
626
        self.branch.lock_read()
650
 
        return self._lock_self_write()
 
627
        self._lock_self_write()
651
628
 
652
629
    def lock_write(self):
653
 
        """See MutableTree.lock_write, and WorkingTree.unlock.
654
 
 
655
 
        :return: A bzrlib.lock.LogicalLockResult.
656
 
        """
 
630
        """See MutableTree.lock_write, and WorkingTree.unlock."""
657
631
        self.branch.lock_write()
658
 
        return self._lock_self_write()
 
632
        self._lock_self_write()
659
633
 
660
634
    @needs_tree_write_lock
661
635
    def move(self, from_paths, to_dir, after=False):
692
666
 
693
667
        if self._inventory is not None:
694
668
            update_inventory = True
695
 
            inv = self.root_inventory
 
669
            inv = self.inventory
696
670
            to_dir_id = to_entry[0][2]
697
671
            to_dir_ie = inv[to_dir_id]
698
672
        else:
731
705
            from_entry = self._get_entry(path=from_rel)
732
706
            if from_entry == (None, None):
733
707
                raise errors.BzrMoveFailedError(from_rel,to_dir,
734
 
                    errors.NotVersionedError(path=from_rel))
 
708
                    errors.NotVersionedError(path=str(from_rel)))
735
709
 
736
710
            from_id = from_entry[0][2]
737
711
            to_rel = pathjoin(to_dir, from_tail)
878
852
                rollback_rename()
879
853
                raise
880
854
            result.append((from_rel, to_rel))
881
 
            state._mark_modified()
 
855
            state._dirblock_state = dirstate.DirState.IN_MEMORY_MODIFIED
882
856
            self._make_dirty(reset_inventory=False)
883
857
 
884
858
        return result
894
868
    @needs_read_lock
895
869
    def path2id(self, path):
896
870
        """Return the id for path in this tree."""
897
 
        if isinstance(path, list):
898
 
            if path == []:
899
 
                path = [""]
900
 
            path = osutils.pathjoin(*path)
901
871
        path = path.strip('/')
902
872
        entry = self._get_entry(path=path)
903
873
        if entry == (None, None):
916
886
        for tree in trees:
917
887
            if not (isinstance(tree, DirStateRevisionTree) and tree._revision_id in
918
888
                parents):
919
 
                return super(DirStateWorkingTree, self).paths2ids(paths,
920
 
                    trees, require_versioned)
 
889
                return super(WorkingTree4, self).paths2ids(paths, trees, require_versioned)
921
890
        search_indexes = [0] + [1 + parents.index(tree._revision_id) for tree in trees]
922
891
        # -- make all paths utf8 --
923
892
        paths_utf8 = set()
981
950
                    all_versioned = False
982
951
                    break
983
952
            if not all_versioned:
984
 
                raise errors.PathsNotVersionedError(
985
 
                    [p.decode('utf-8') for p in paths])
 
953
                raise errors.PathsNotVersionedError(paths)
986
954
        # -- remove redundancy in supplied paths to prevent over-scanning --
987
955
        search_paths = osutils.minimum_path_selection(paths)
988
 
        # sketch:
 
956
        # sketch: 
989
957
        # for all search_indexs in each path at or under each element of
990
958
        # search_paths, if the detail is relocated: add the id, and add the
991
959
        # relocated path as one to search if its not searched already. If the
1037
1005
            found_dir_names = set(dir_name_id[:2] for dir_name_id in found)
1038
1006
            for dir_name in split_paths:
1039
1007
                if dir_name not in found_dir_names:
1040
 
                    raise errors.PathsNotVersionedError(
1041
 
                        [p.decode('utf-8') for p in paths])
 
1008
                    raise errors.PathsNotVersionedError(paths)
1042
1009
 
1043
1010
        for dir_name_id, trees_info in found.iteritems():
1044
1011
            for index in search_indexes:
1048
1015
 
1049
1016
    def read_working_inventory(self):
1050
1017
        """Read the working inventory.
1051
 
 
 
1018
        
1052
1019
        This is a meaningless operation for dirstate, but we obey it anyhow.
1053
1020
        """
1054
 
        return self.root_inventory
 
1021
        return self.inventory
1055
1022
 
1056
1023
    @needs_read_lock
1057
1024
    def revision_tree(self, revision_id):
1072
1039
    def set_last_revision(self, new_revision):
1073
1040
        """Change the last revision in the working tree."""
1074
1041
        parents = self.get_parent_ids()
1075
 
        if new_revision in (_mod_revision.NULL_REVISION, None):
 
1042
        if new_revision in (NULL_REVISION, None):
1076
1043
            if len(parents) >= 2:
1077
1044
                raise AssertionError(
1078
1045
                    "setting the last parent to none with a pending merge is "
1085
1052
    @needs_tree_write_lock
1086
1053
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
1087
1054
        """Set the parent ids to revision_ids.
1088
 
 
 
1055
        
1089
1056
        See also set_parent_trees. This api will try to retrieve the tree data
1090
1057
        for each element of revision_ids from the trees repository. If you have
1091
1058
        tree data already available, it is more efficient to use
1143
1110
                real_trees.append((rev_id, tree))
1144
1111
            else:
1145
1112
                real_trees.append((rev_id,
1146
 
                    self.branch.repository.revision_tree(
1147
 
                        _mod_revision.NULL_REVISION)))
 
1113
                    self.branch.repository.revision_tree(None)))
1148
1114
                ghosts.append(rev_id)
1149
1115
            accepted_revisions.add(rev_id)
1150
 
        updated = False
1151
 
        if (len(real_trees) == 1
1152
 
            and not ghosts
1153
 
            and self.branch.repository._format.fast_deltas
1154
 
            and isinstance(real_trees[0][1],
1155
 
                revisiontree.InventoryRevisionTree)
1156
 
            and self.get_parent_ids()):
1157
 
            rev_id, rev_tree = real_trees[0]
1158
 
            basis_id = self.get_parent_ids()[0]
1159
 
            # There are times when basis_tree won't be in
1160
 
            # self.branch.repository, (switch, for example)
1161
 
            try:
1162
 
                basis_tree = self.branch.repository.revision_tree(basis_id)
1163
 
            except errors.NoSuchRevision:
1164
 
                # Fall back to the set_parent_trees(), since we can't use
1165
 
                # _make_delta if we can't get the RevisionTree
1166
 
                pass
1167
 
            else:
1168
 
                delta = rev_tree.root_inventory._make_delta(
1169
 
                    basis_tree.root_inventory)
1170
 
                dirstate.update_basis_by_delta(delta, rev_id)
1171
 
                updated = True
1172
 
        if not updated:
1173
 
            dirstate.set_parent_trees(real_trees, ghosts=ghosts)
 
1116
        dirstate.set_parent_trees(real_trees, ghosts=ghosts)
1174
1117
        self._make_dirty(reset_inventory=False)
1175
1118
 
1176
1119
    def _set_root_id(self, file_id):
1196
1139
 
1197
1140
    def unlock(self):
1198
1141
        """Unlock in format 4 trees needs to write the entire dirstate."""
 
1142
        # do non-implementation specific cleanup
 
1143
        self._cleanup()
 
1144
 
1199
1145
        if self._control_files._lock_count == 1:
1200
 
            # do non-implementation specific cleanup
1201
 
            self._cleanup()
1202
 
 
1203
1146
            # eventually we should do signature checking during read locks for
1204
1147
            # dirstate updates.
1205
1148
            if self._control_files._lock_mode == 'w':
1268
1211
                # just forget the whole block.
1269
1212
                entry_index = 0
1270
1213
                while entry_index < len(block[1]):
 
1214
                    # Mark this file id as having been removed
1271
1215
                    entry = block[1][entry_index]
1272
 
                    if entry[1][0][0] in 'ar':
1273
 
                        # don't remove absent or renamed entries
 
1216
                    ids_to_unversion.discard(entry[0][2])
 
1217
                    if (entry[1][0][0] in 'ar' # don't remove absent or renamed
 
1218
                                               # entries
 
1219
                        or not state._make_absent(entry)):
1274
1220
                        entry_index += 1
1275
 
                    else:
1276
 
                        # Mark this file id as having been removed
1277
 
                        ids_to_unversion.discard(entry[0][2])
1278
 
                        if not state._make_absent(entry):
1279
 
                            # The block has not shrunk.
1280
 
                            entry_index += 1
1281
1221
                # go to the next block. (At the moment we dont delete empty
1282
1222
                # dirblocks)
1283
1223
                block_index += 1
1304
1244
        # have to change the legacy inventory too.
1305
1245
        if self._inventory is not None:
1306
1246
            for file_id in file_ids:
1307
 
                if self._inventory.has_id(file_id):
1308
 
                    self._inventory.remove_recursive_id(file_id)
 
1247
                self._inventory.remove_recursive_id(file_id)
1309
1248
 
1310
1249
    @needs_tree_write_lock
1311
1250
    def rename_one(self, from_rel, to_rel, after=False):
1312
1251
        """See WorkingTree.rename_one"""
1313
1252
        self.flush()
1314
 
        super(DirStateWorkingTree, self).rename_one(from_rel, to_rel, after)
 
1253
        WorkingTree.rename_one(self, from_rel, to_rel, after)
1315
1254
 
1316
1255
    @needs_tree_write_lock
1317
1256
    def apply_inventory_delta(self, changes):
1336
1275
        if self._dirty:
1337
1276
            raise AssertionError("attempting to write an inventory when the "
1338
1277
                "dirstate is dirty will lose pending changes")
1339
 
        had_inventory = self._inventory is not None
1340
 
        # Setting self._inventory = None forces the dirstate to regenerate the
1341
 
        # working inventory. We do this because self.inventory may be inv, or
1342
 
        # may have been modified, and either case would prevent a clean delta
1343
 
        # being created.
1344
 
        self._inventory = None
1345
 
        # generate a delta,
1346
 
        delta = inv._make_delta(self.root_inventory)
1347
 
        # and apply it.
1348
 
        self.apply_inventory_delta(delta)
1349
 
        if had_inventory:
 
1278
        self.current_dirstate().set_state_from_inventory(inv)
 
1279
        self._make_dirty(reset_inventory=False)
 
1280
        if self._inventory is not None:
1350
1281
            self._inventory = inv
1351
1282
        self.flush()
1352
1283
 
1353
 
    @needs_tree_write_lock
1354
 
    def reset_state(self, revision_ids=None):
1355
 
        """Reset the state of the working tree.
1356
 
 
1357
 
        This does a hard-reset to a last-known-good state. This is a way to
1358
 
        fix if something got corrupted (like the .bzr/checkout/dirstate file)
1359
 
        """
1360
 
        if revision_ids is None:
1361
 
            revision_ids = self.get_parent_ids()
1362
 
        if not revision_ids:
1363
 
            base_tree = self.branch.repository.revision_tree(
1364
 
                _mod_revision.NULL_REVISION)
1365
 
            trees = []
1366
 
        else:
1367
 
            trees = zip(revision_ids,
1368
 
                        self.branch.repository.revision_trees(revision_ids))
1369
 
            base_tree = trees[0][1]
1370
 
        state = self.current_dirstate()
1371
 
        # We don't support ghosts yet
1372
 
        state.set_state_from_scratch(base_tree.root_inventory, trees, [])
1373
 
 
1374
 
 
1375
 
class ContentFilterAwareSHA1Provider(dirstate.SHA1Provider):
1376
 
 
1377
 
    def __init__(self, tree):
1378
 
        self.tree = tree
1379
 
 
1380
 
    def sha1(self, abspath):
1381
 
        """See dirstate.SHA1Provider.sha1()."""
1382
 
        filters = self.tree._content_filter_stack(
1383
 
            self.tree.relpath(osutils.safe_unicode(abspath)))
1384
 
        return _mod_filters.internal_size_sha_file_byname(abspath, filters)[1]
1385
 
 
1386
 
    def stat_and_sha1(self, abspath):
1387
 
        """See dirstate.SHA1Provider.stat_and_sha1()."""
1388
 
        filters = self.tree._content_filter_stack(
1389
 
            self.tree.relpath(osutils.safe_unicode(abspath)))
1390
 
        file_obj = file(abspath, 'rb', 65000)
1391
 
        try:
1392
 
            statvalue = os.fstat(file_obj.fileno())
1393
 
            if filters:
1394
 
                file_obj = _mod_filters.filtered_input_file(file_obj, filters)
1395
 
            sha1 = osutils.size_sha_file(file_obj)[1]
1396
 
        finally:
1397
 
            file_obj.close()
1398
 
        return statvalue, sha1
1399
 
 
1400
 
 
1401
 
class ContentFilteringDirStateWorkingTree(DirStateWorkingTree):
1402
 
    """Dirstate working tree that supports content filtering.
1403
 
 
1404
 
    The dirstate holds the hash and size of the canonical form of the file, 
1405
 
    and most methods must return that.
1406
 
    """
1407
 
 
1408
 
    def _file_content_summary(self, path, stat_result):
1409
 
        # This is to support the somewhat obsolete path_content_summary method
1410
 
        # with content filtering: see
1411
 
        # <https://bugs.launchpad.net/bzr/+bug/415508>.
1412
 
        #
1413
 
        # If the dirstate cache is up to date and knows the hash and size,
1414
 
        # return that.
1415
 
        # Otherwise if there are no content filters, return the on-disk size
1416
 
        # and leave the hash blank.
1417
 
        # Otherwise, read and filter the on-disk file and use its size and
1418
 
        # hash.
1419
 
        #
1420
 
        # The dirstate doesn't store the size of the canonical form so we
1421
 
        # can't trust it for content-filtered trees.  We just return None.
1422
 
        dirstate_sha1 = self._dirstate.sha1_from_stat(path, stat_result)
1423
 
        executable = self._is_executable_from_path_and_stat(path, stat_result)
1424
 
        return ('file', None, executable, dirstate_sha1)
1425
 
 
1426
 
 
1427
 
class WorkingTree4(DirStateWorkingTree):
1428
 
    """This is the Format 4 working tree.
1429
 
 
1430
 
    This differs from WorkingTree by:
1431
 
     - Having a consolidated internal dirstate, stored in a
1432
 
       randomly-accessible sorted file on disk.
1433
 
     - Not having a regular inventory attribute.  One can be synthesized
1434
 
       on demand but this is expensive and should be avoided.
1435
 
 
1436
 
    This is new in bzr 0.15.
1437
 
    """
1438
 
 
1439
 
 
1440
 
class WorkingTree5(ContentFilteringDirStateWorkingTree):
1441
 
    """This is the Format 5 working tree.
1442
 
 
1443
 
    This differs from WorkingTree4 by:
1444
 
     - Supporting content filtering.
1445
 
 
1446
 
    This is new in bzr 1.11.
1447
 
    """
1448
 
 
1449
 
 
1450
 
class WorkingTree6(ContentFilteringDirStateWorkingTree):
1451
 
    """This is the Format 6 working tree.
1452
 
 
1453
 
    This differs from WorkingTree5 by:
1454
 
     - Supporting a current view that may mask the set of files in a tree
1455
 
       impacted by most user operations.
1456
 
 
1457
 
    This is new in bzr 1.14.
1458
 
    """
1459
 
 
1460
 
    def _make_views(self):
1461
 
        return views.PathBasedViews(self)
1462
 
 
1463
 
 
1464
 
class DirStateWorkingTreeFormat(WorkingTreeFormatMetaDir):
1465
 
 
1466
 
    missing_parent_conflicts = True
1467
 
 
1468
 
    supports_versioned_directories = True
1469
 
 
1470
 
    _lock_class = LockDir
1471
 
    _lock_file_name = 'lock'
1472
 
 
1473
 
    def _open_control_files(self, a_bzrdir):
1474
 
        transport = a_bzrdir.get_workingtree_transport(None)
1475
 
        return LockableFiles(transport, self._lock_file_name,
1476
 
                             self._lock_class)
 
1284
 
 
1285
class WorkingTreeFormat4(WorkingTreeFormat3):
 
1286
    """The first consolidated dirstate working tree format.
 
1287
 
 
1288
    This format:
 
1289
        - exists within a metadir controlling .bzr
 
1290
        - includes an explicit version marker for the workingtree control
 
1291
          files, separate from the BzrDir format
 
1292
        - modifies the hash cache format
 
1293
        - is new in bzr 0.15
 
1294
        - uses a LockDir to guard access to it.
 
1295
    """
 
1296
 
 
1297
    upgrade_recommended = False
 
1298
 
 
1299
    def get_format_string(self):
 
1300
        """See WorkingTreeFormat.get_format_string()."""
 
1301
        return "Bazaar Working Tree Format 4 (bzr 0.15)\n"
 
1302
 
 
1303
    def get_format_description(self):
 
1304
        """See WorkingTreeFormat.get_format_description()."""
 
1305
        return "Working tree format 4"
1477
1306
 
1478
1307
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
1479
1308
                   accelerator_tree=None, hardlink=False):
1480
1309
        """See WorkingTreeFormat.initialize().
1481
1310
 
1482
1311
        :param revision_id: allows creating a working tree at a different
1483
 
            revision than the branch is at.
 
1312
        revision than the branch is at.
1484
1313
        :param accelerator_tree: A tree which can be used for retrieving file
1485
1314
            contents more quickly than the revision tree, i.e. a workingtree.
1486
1315
            The revision tree will be used for cases where accelerator_tree's
1497
1326
        control_files = self._open_control_files(a_bzrdir)
1498
1327
        control_files.create_lock()
1499
1328
        control_files.lock_write()
1500
 
        transport.put_bytes('format', self.as_string(),
 
1329
        transport.put_bytes('format', self.get_format_string(),
1501
1330
            mode=a_bzrdir._get_file_mode())
1502
1331
        if from_branch is not None:
1503
1332
            branch = from_branch
1510
1339
        state = dirstate.DirState.initialize(local_path)
1511
1340
        state.unlock()
1512
1341
        del state
1513
 
        wt = self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
 
1342
        wt = WorkingTree4(a_bzrdir.root_transport.local_abspath('.'),
1514
1343
                         branch,
1515
1344
                         _format=self,
1516
1345
                         _bzrdir=a_bzrdir,
1518
1347
        wt._new_tree()
1519
1348
        wt.lock_tree_write()
1520
1349
        try:
1521
 
            self._init_custom_control_files(wt)
1522
 
            if revision_id in (None, _mod_revision.NULL_REVISION):
 
1350
            if revision_id in (None, NULL_REVISION):
1523
1351
                if branch.repository.supports_rich_root():
1524
1352
                    wt._set_root_id(generate_ids.gen_root_id())
1525
1353
                else:
1536
1364
                    pass
1537
1365
            if basis is None:
1538
1366
                basis = branch.repository.revision_tree(revision_id)
1539
 
            if revision_id == _mod_revision.NULL_REVISION:
 
1367
            if revision_id == NULL_REVISION:
1540
1368
                parents_list = []
1541
1369
            else:
1542
1370
                parents_list = [(revision_id, basis)]
1550
1378
                if basis_root_id is not None:
1551
1379
                    wt._set_root_id(basis_root_id)
1552
1380
                    wt.flush()
1553
 
                if wt.supports_content_filtering():
1554
 
                    # The original tree may not have the same content filters
1555
 
                    # applied so we can't safely build the inventory delta from
1556
 
                    # the source tree.
1557
 
                    delta_from_tree = False
1558
 
                else:
1559
 
                    delta_from_tree = True
1560
1381
                # delta_from_tree is safe even for DirStateRevisionTrees,
1561
1382
                # because wt4.apply_inventory_delta does not mutate the input
1562
1383
                # inventory entries.
1563
1384
                transform.build_tree(basis, wt, accelerator_tree,
1564
 
                                     hardlink=hardlink,
1565
 
                                     delta_from_tree=delta_from_tree)
1566
 
                for hook in MutableTree.hooks['post_build_tree']:
1567
 
                    hook(wt)
 
1385
                                     hardlink=hardlink, delta_from_tree=True)
1568
1386
            finally:
1569
1387
                basis.unlock()
1570
1388
        finally:
1572
1390
            wt.unlock()
1573
1391
        return wt
1574
1392
 
1575
 
    def _init_custom_control_files(self, wt):
1576
 
        """Subclasses with custom control files should override this method.
1577
 
 
1578
 
        The working tree and control files are locked for writing when this
1579
 
        method is called.
1580
 
 
1581
 
        :param wt: the WorkingTree object
1582
 
        """
1583
 
 
1584
 
    def open(self, a_bzrdir, _found=False):
1585
 
        """Return the WorkingTree object for a_bzrdir
1586
 
 
1587
 
        _found is a private parameter, do not use it. It is used to indicate
1588
 
               if format probing has already been done.
1589
 
        """
1590
 
        if not _found:
1591
 
            # we are being called directly and must probe.
1592
 
            raise NotImplementedError
1593
 
        if not isinstance(a_bzrdir.transport, LocalTransport):
1594
 
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
1595
 
        wt = self._open(a_bzrdir, self._open_control_files(a_bzrdir))
1596
 
        return wt
1597
 
 
1598
1393
    def _open(self, a_bzrdir, control_files):
1599
1394
        """Open the tree itself.
1600
1395
 
1601
1396
        :param a_bzrdir: the dir for the tree.
1602
1397
        :param control_files: the control files for the tree.
1603
1398
        """
1604
 
        return self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
 
1399
        return WorkingTree4(a_bzrdir.root_transport.local_abspath('.'),
1605
1400
                           branch=a_bzrdir.open_branch(),
1606
1401
                           _format=self,
1607
1402
                           _bzrdir=a_bzrdir,
1608
1403
                           _control_files=control_files)
1609
1404
 
1610
1405
    def __get_matchingbzrdir(self):
1611
 
        return self._get_matchingbzrdir()
1612
 
 
1613
 
    def _get_matchingbzrdir(self):
1614
 
        """Overrideable method to get a bzrdir for testing."""
1615
1406
        # please test against something that will let us do tree references
1616
 
        return controldir.format_registry.make_bzrdir(
1617
 
            'development-subtree')
 
1407
        return bzrdir.format_registry.make_bzrdir(
 
1408
            'dirstate-with-subtree')
1618
1409
 
1619
1410
    _matchingbzrdir = property(__get_matchingbzrdir)
1620
1411
 
1621
1412
 
1622
 
class WorkingTreeFormat4(DirStateWorkingTreeFormat):
1623
 
    """The first consolidated dirstate working tree format.
1624
 
 
1625
 
    This format:
1626
 
        - exists within a metadir controlling .bzr
1627
 
        - includes an explicit version marker for the workingtree control
1628
 
          files, separate from the ControlDir format
1629
 
        - modifies the hash cache format
1630
 
        - is new in bzr 0.15
1631
 
        - uses a LockDir to guard access to it.
1632
 
    """
1633
 
 
1634
 
    upgrade_recommended = False
1635
 
 
1636
 
    _tree_class = WorkingTree4
1637
 
 
1638
 
    @classmethod
1639
 
    def get_format_string(cls):
1640
 
        """See WorkingTreeFormat.get_format_string()."""
1641
 
        return "Bazaar Working Tree Format 4 (bzr 0.15)\n"
1642
 
 
1643
 
    def get_format_description(self):
1644
 
        """See WorkingTreeFormat.get_format_description()."""
1645
 
        return "Working tree format 4"
1646
 
 
1647
 
 
1648
 
class WorkingTreeFormat5(DirStateWorkingTreeFormat):
1649
 
    """WorkingTree format supporting content filtering.
1650
 
    """
1651
 
 
1652
 
    upgrade_recommended = False
1653
 
 
1654
 
    _tree_class = WorkingTree5
1655
 
 
1656
 
    @classmethod
1657
 
    def get_format_string(cls):
1658
 
        """See WorkingTreeFormat.get_format_string()."""
1659
 
        return "Bazaar Working Tree Format 5 (bzr 1.11)\n"
1660
 
 
1661
 
    def get_format_description(self):
1662
 
        """See WorkingTreeFormat.get_format_description()."""
1663
 
        return "Working tree format 5"
1664
 
 
1665
 
    def supports_content_filtering(self):
1666
 
        return True
1667
 
 
1668
 
 
1669
 
class WorkingTreeFormat6(DirStateWorkingTreeFormat):
1670
 
    """WorkingTree format supporting views.
1671
 
    """
1672
 
 
1673
 
    upgrade_recommended = False
1674
 
 
1675
 
    _tree_class = WorkingTree6
1676
 
 
1677
 
    @classmethod
1678
 
    def get_format_string(cls):
1679
 
        """See WorkingTreeFormat.get_format_string()."""
1680
 
        return "Bazaar Working Tree Format 6 (bzr 1.14)\n"
1681
 
 
1682
 
    def get_format_description(self):
1683
 
        """See WorkingTreeFormat.get_format_description()."""
1684
 
        return "Working tree format 6"
1685
 
 
1686
 
    def _init_custom_control_files(self, wt):
1687
 
        """Subclasses with custom control files should override this method."""
1688
 
        wt._transport.put_bytes('views', '', mode=wt.bzrdir._get_file_mode())
1689
 
 
1690
 
    def supports_content_filtering(self):
1691
 
        return True
1692
 
 
1693
 
    def supports_views(self):
1694
 
        return True
1695
 
 
1696
 
    def _get_matchingbzrdir(self):
1697
 
        """Overrideable method to get a bzrdir for testing."""
1698
 
        # We use 'development-subtree' instead of '2a', because we have a
1699
 
        # few tests that want to test tree references
1700
 
        return bzrdir.format_registry.make_bzrdir('development-subtree')
1701
 
 
1702
 
 
1703
 
class DirStateRevisionTree(InventoryTree):
1704
 
    """A revision tree pulling the inventory from a dirstate.
1705
 
    
1706
 
    Note that this is one of the historical (ie revision) trees cached in the
1707
 
    dirstate for easy access, not the workingtree.
1708
 
    """
 
1413
class DirStateRevisionTree(Tree):
 
1414
    """A revision tree pulling the inventory from a dirstate."""
1709
1415
 
1710
1416
    def __init__(self, dirstate, revision_id, repository):
1711
1417
        self._dirstate = dirstate
1725
1431
    def annotate_iter(self, file_id,
1726
1432
                      default_revision=_mod_revision.CURRENT_REVISION):
1727
1433
        """See Tree.annotate_iter"""
1728
 
        text_key = (file_id, self.get_file_revision(file_id))
 
1434
        text_key = (file_id, self.inventory[file_id].revision)
1729
1435
        annotations = self._repository.texts.annotate(text_key)
1730
1436
        return [(key[-1], line) for (key, line) in annotations]
1731
1437
 
 
1438
    def _get_ancestors(self, default_revision):
 
1439
        return set(self._repository.get_ancestry(self._revision_id,
 
1440
                                                 topo_sorted=False))
1732
1441
    def _comparison_data(self, entry, path):
1733
1442
        """See Tree._comparison_data."""
1734
1443
        if entry is None:
1777
1486
        If either file_id or path is supplied, it is used as the key to lookup.
1778
1487
        If both are supplied, the fastest lookup is used, and an error is
1779
1488
        raised if they do not both point at the same row.
1780
 
 
 
1489
        
1781
1490
        :param file_id: An optional unicode file_id to be looked up.
1782
1491
        :param path: An optional unicode path to be looked up.
1783
1492
        :return: The dirstate row tuple for path/file_id, or (None, None)
1787
1496
        if path is not None:
1788
1497
            path = path.encode('utf8')
1789
1498
        parent_index = self._get_parent_index()
1790
 
        return self._dirstate._get_entry(parent_index, fileid_utf8=file_id,
1791
 
            path_utf8=path)
 
1499
        return self._dirstate._get_entry(parent_index, fileid_utf8=file_id, path_utf8=path)
1792
1500
 
1793
1501
    def _generate_inventory(self):
1794
1502
        """Create and set self.inventory from the dirstate object.
1851
1559
                elif kind == 'directory':
1852
1560
                    parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
1853
1561
                elif kind == 'symlink':
 
1562
                    inv_entry.executable = False
 
1563
                    inv_entry.text_size = None
1854
1564
                    inv_entry.symlink_target = utf8_decode(fingerprint)[0]
1855
1565
                elif kind == 'tree-reference':
1856
1566
                    inv_entry.reference_revision = fingerprint or None
1876
1586
        # Make sure the file exists
1877
1587
        entry = self._get_entry(file_id, path=path)
1878
1588
        if entry == (None, None): # do we raise?
1879
 
            raise errors.NoSuchId(self, file_id)
 
1589
            return None
1880
1590
        parent_index = self._get_parent_index()
1881
1591
        last_changed_revision = entry[1][parent_index][4]
1882
 
        try:
1883
 
            rev = self._repository.get_revision(last_changed_revision)
1884
 
        except errors.NoSuchRevision:
1885
 
            raise errors.FileTimestampUnavailable(self.id2path(file_id))
1886
 
        return rev.timestamp
 
1592
        return self._repository.get_revision(last_changed_revision).timestamp
1887
1593
 
1888
1594
    def get_file_sha1(self, file_id, path=None, stat_value=None):
1889
1595
        entry = self._get_entry(file_id=file_id, path=path)
1893
1599
            return parent_details[1]
1894
1600
        return None
1895
1601
 
1896
 
    @needs_read_lock
1897
 
    def get_file_revision(self, file_id):
1898
 
        inv, inv_file_id = self._unpack_file_id(file_id)
1899
 
        return inv[inv_file_id].revision
1900
 
 
1901
1602
    def get_file(self, file_id, path=None):
1902
1603
        return StringIO(self.get_file_text(file_id))
1903
1604
 
 
1605
    def get_file_lines(self, file_id):
 
1606
        return osutils.split_lines(self.get_file_text(file_id))
 
1607
 
1904
1608
    def get_file_size(self, file_id):
1905
1609
        """See Tree.get_file_size"""
1906
 
        inv, inv_file_id = self._unpack_file_id(file_id)
1907
 
        return inv[inv_file_id].text_size
 
1610
        return self.inventory[file_id].text_size
1908
1611
 
1909
 
    def get_file_text(self, file_id, path=None):
1910
 
        content = None
1911
 
        for _, content_iter in self.iter_files_bytes([(file_id, None)]):
1912
 
            if content is not None:
1913
 
                raise AssertionError('iter_files_bytes returned'
1914
 
                    ' too many entries')
1915
 
            # For each entry returned by iter_files_bytes, we must consume the
1916
 
            # content_iter before we step the files iterator.
1917
 
            content = ''.join(content_iter)
1918
 
        if content is None:
1919
 
            raise AssertionError('iter_files_bytes did not return'
1920
 
                ' the requested data')
1921
 
        return content
 
1612
    def get_file_text(self, file_id):
 
1613
        return list(self.iter_files_bytes([(file_id, None)]))[0][1]
1922
1614
 
1923
1615
    def get_reference_revision(self, file_id, path=None):
1924
 
        inv, inv_file_id = self._unpack_file_id(file_id)
1925
 
        return inv[inv_file_id].reference_revision
 
1616
        return self.inventory[file_id].reference_revision
1926
1617
 
1927
1618
    def iter_files_bytes(self, desired_files):
1928
1619
        """See Tree.iter_files_bytes.
1938
1629
                                       identifier))
1939
1630
        return self._repository.iter_files_bytes(repo_desired_files)
1940
1631
 
1941
 
    def get_symlink_target(self, file_id, path=None):
 
1632
    def get_symlink_target(self, file_id):
1942
1633
        entry = self._get_entry(file_id=file_id)
1943
1634
        parent_index = self._get_parent_index()
1944
1635
        if entry[1][parent_index][0] != 'l':
1945
1636
            return None
1946
1637
        else:
1947
 
            target = entry[1][parent_index][1]
1948
 
            target = target.decode('utf8')
1949
 
            return target
 
1638
            # At present, none of the tree implementations supports non-ascii
 
1639
            # symlink targets. So we will just assume that the dirstate path is
 
1640
            # correct.
 
1641
            return entry[1][parent_index][1]
1950
1642
 
1951
1643
    def get_revision_id(self):
1952
1644
        """Return the revision id for this tree."""
1953
1645
        return self._revision_id
1954
1646
 
1955
 
    def _get_root_inventory(self):
 
1647
    def _get_inventory(self):
1956
1648
        if self._inventory is not None:
1957
1649
            return self._inventory
1958
1650
        self._must_be_locked()
1959
1651
        self._generate_inventory()
1960
1652
        return self._inventory
1961
1653
 
1962
 
    root_inventory = property(_get_root_inventory,
1963
 
                         doc="Inventory of this Tree")
1964
 
 
1965
 
    @deprecated_method(deprecated_in((2, 5, 0)))
1966
 
    def _get_inventory(self):
1967
 
        return self.root_inventory
1968
 
 
1969
1654
    inventory = property(_get_inventory,
1970
1655
                         doc="Inventory of this Tree")
1971
1656
 
1980
1665
        entry = self._get_entry(file_id=file_id)[1]
1981
1666
        if entry is None:
1982
1667
            raise errors.NoSuchId(tree=self, file_id=file_id)
1983
 
        parent_index = self._get_parent_index()
1984
 
        return dirstate.DirState._minikind_to_kind[entry[parent_index][0]]
 
1668
        return dirstate.DirState._minikind_to_kind[entry[1][0]]
1985
1669
 
1986
1670
    def stored_kind(self, file_id):
1987
1671
        """See Tree.stored_kind"""
1989
1673
 
1990
1674
    def path_content_summary(self, path):
1991
1675
        """See Tree.path_content_summary."""
1992
 
        inv, inv_file_id = self._path2inv_file_id(path)
1993
 
        if inv_file_id is None:
 
1676
        id = self.inventory.path2id(path)
 
1677
        if id is None:
1994
1678
            return ('missing', None, None, None)
1995
 
        entry = inv[inv_file_id]
 
1679
        entry = self._inventory[id]
1996
1680
        kind = entry.kind
1997
1681
        if kind == 'file':
1998
1682
            return (kind, entry.text_size, entry.executable, entry.text_sha1)
2002
1686
            return (kind, None, None, None)
2003
1687
 
2004
1688
    def is_executable(self, file_id, path=None):
2005
 
        inv, inv_file_id = self._unpack_file_id(file_id)
2006
 
        ie = inv[inv_file_id]
 
1689
        ie = self.inventory[file_id]
2007
1690
        if ie.kind != "file":
2008
 
            return False
 
1691
            return None
2009
1692
        return ie.executable
2010
1693
 
2011
 
    def is_locked(self):
2012
 
        return self._locked
2013
 
 
2014
 
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
1694
    def list_files(self, include_root=False):
2015
1695
        # We use a standard implementation, because DirStateRevisionTree is
2016
1696
        # dealing with one of the parents of the current state
2017
 
        if from_dir is None:
2018
 
            inv = self.root_inventory
2019
 
            from_dir_id = None
2020
 
        else:
2021
 
            inv, from_dir_id = self._path2inv_file_id(from_dir)
2022
 
            if from_dir_id is None:
2023
 
                # Directory not versioned
2024
 
                return
2025
 
        # FIXME: Support nested trees
2026
 
        entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
2027
 
        if inv.root is not None and not include_root and from_dir is None:
 
1697
        inv = self._get_inventory()
 
1698
        entries = inv.iter_entries()
 
1699
        if self.inventory.root is not None and not include_root:
2028
1700
            entries.next()
2029
1701
        for path, entry in entries:
2030
1702
            yield path, 'V', entry.kind, entry.file_id, entry
2031
1703
 
2032
1704
    def lock_read(self):
2033
 
        """Lock the tree for a set of operations.
2034
 
 
2035
 
        :return: A bzrlib.lock.LogicalLockResult.
2036
 
        """
 
1705
        """Lock the tree for a set of operations."""
2037
1706
        if not self._locked:
2038
1707
            self._repository.lock_read()
2039
1708
            if self._dirstate._lock_token is None:
2040
1709
                self._dirstate.lock_read()
2041
1710
                self._dirstate_locked = True
2042
1711
        self._locked += 1
2043
 
        return LogicalLockResult(self.unlock)
2044
1712
 
2045
1713
    def _must_be_locked(self):
2046
1714
        if not self._locked:
2050
1718
    def path2id(self, path):
2051
1719
        """Return the id for path in this tree."""
2052
1720
        # lookup by path: faster than splitting and walking the ivnentory.
2053
 
        if isinstance(path, list):
2054
 
            if path == []:
2055
 
                path = [""]
2056
 
            path = osutils.pathjoin(*path)
2057
1721
        entry = self._get_entry(path=path)
2058
1722
        if entry == (None, None):
2059
1723
            return None
2077
1741
 
2078
1742
    def walkdirs(self, prefix=""):
2079
1743
        # TODO: jam 20070215 This is the lazy way by using the RevisionTree
2080
 
        # implementation based on an inventory.
 
1744
        # implementation based on an inventory.  
2081
1745
        # This should be cleaned up to use the much faster Dirstate code
2082
1746
        # So for now, we just build up the parent inventory, and extract
2083
1747
        # it the same way RevisionTree does.
2084
1748
        _directory = 'directory'
2085
 
        inv = self._get_root_inventory()
 
1749
        inv = self._get_inventory()
2086
1750
        top_id = inv.path2id(prefix)
2087
1751
        if top_id is None:
2088
1752
            pending = []
2112
1776
 
2113
1777
class InterDirStateTree(InterTree):
2114
1778
    """Fast path optimiser for changes_from with dirstate trees.
2115
 
 
2116
 
    This is used only when both trees are in the dirstate working file, and
2117
 
    the source is any parent within the dirstate, and the destination is
 
1779
    
 
1780
    This is used only when both trees are in the dirstate working file, and 
 
1781
    the source is any parent within the dirstate, and the destination is 
2118
1782
    the current working tree of the same dirstate.
2119
1783
    """
2120
1784
    # this could be generalized to allow comparisons between any trees in the
2129
1793
    def make_source_parent_tree(source, target):
2130
1794
        """Change the source tree into a parent of the target."""
2131
1795
        revid = source.commit('record tree')
2132
 
        target.branch.fetch(source.branch, revid)
 
1796
        target.branch.repository.fetch(source.branch.repository, revid)
2133
1797
        target.set_parent_ids([revid])
2134
1798
        return target.basis_tree(), target
2135
1799
 
2136
 
    @classmethod
2137
 
    def make_source_parent_tree_python_dirstate(klass, test_case, source, target):
2138
 
        result = klass.make_source_parent_tree(source, target)
2139
 
        result[1]._iter_changes = dirstate.ProcessEntryPython
2140
 
        return result
2141
 
 
2142
 
    @classmethod
2143
 
    def make_source_parent_tree_compiled_dirstate(klass, test_case, source,
2144
 
                                                  target):
2145
 
        from bzrlib.tests.test__dirstate_helpers import \
2146
 
            compiled_dirstate_helpers_feature
2147
 
        test_case.requireFeature(compiled_dirstate_helpers_feature)
2148
 
        from bzrlib._dirstate_helpers_pyx import ProcessEntryC
2149
 
        result = klass.make_source_parent_tree(source, target)
2150
 
        result[1]._iter_changes = ProcessEntryC
2151
 
        return result
2152
 
 
2153
1800
    _matching_from_tree_format = WorkingTreeFormat4()
2154
1801
    _matching_to_tree_format = WorkingTreeFormat4()
2155
 
 
2156
 
    @classmethod
2157
 
    def _test_mutable_trees_to_test_trees(klass, test_case, source, target):
2158
 
        # This method shouldn't be called, because we have python and C
2159
 
        # specific flavours.
2160
 
        raise NotImplementedError
 
1802
    _test_mutable_trees_to_test_trees = make_source_parent_tree
2161
1803
 
2162
1804
    def iter_changes(self, include_unchanged=False,
2163
1805
                      specific_files=None, pb=None, extra_trees=[],
2181
1823
            output. An unversioned file is defined as one with (False, False)
2182
1824
            for the versioned pair.
2183
1825
        """
 
1826
        utf8_decode = cache_utf8._utf8_decode
 
1827
        _minikind_to_kind = dirstate.DirState._minikind_to_kind
 
1828
        cmp_by_dirs = dirstate.cmp_by_dirs
 
1829
        # NB: show_status depends on being able to pass in non-versioned files
 
1830
        # and report them as unknown
2184
1831
        # TODO: handle extra trees in the dirstate.
2185
1832
        if (extra_trees or specific_files == []):
2186
1833
            # we can't fast-path these cases (yet)
2187
 
            return super(InterDirStateTree, self).iter_changes(
 
1834
            for f in super(InterDirStateTree, self).iter_changes(
2188
1835
                include_unchanged, specific_files, pb, extra_trees,
2189
 
                require_versioned, want_unversioned=want_unversioned)
 
1836
                require_versioned, want_unversioned=want_unversioned):
 
1837
                yield f
 
1838
            return
2190
1839
        parent_ids = self.target.get_parent_ids()
2191
1840
        if not (self.source._revision_id in parent_ids
2192
 
                or self.source._revision_id == _mod_revision.NULL_REVISION):
 
1841
                or self.source._revision_id == NULL_REVISION):
2193
1842
            raise AssertionError(
2194
1843
                "revision {%s} is not stored in {%s}, but %s "
2195
1844
                "can only be used for trees stored in the dirstate"
2196
1845
                % (self.source._revision_id, self.target, self.iter_changes))
2197
1846
        target_index = 0
2198
 
        if self.source._revision_id == _mod_revision.NULL_REVISION:
 
1847
        if self.source._revision_id == NULL_REVISION:
2199
1848
            source_index = None
2200
1849
            indices = (target_index,)
2201
1850
        else:
2209
1858
        if specific_files:
2210
1859
            specific_files_utf8 = set()
2211
1860
            for path in specific_files:
2212
 
                # Note, if there are many specific files, using cache_utf8
2213
 
                # would be good here.
2214
1861
                specific_files_utf8.add(path.encode('utf8'))
2215
1862
            specific_files = specific_files_utf8
2216
1863
        else:
2217
1864
            specific_files = set([''])
2218
1865
        # -- specific_files is now a utf8 path set --
2219
 
 
2220
1866
        # -- get the state object and prepare it.
2221
1867
        state = self.target.current_dirstate()
2222
1868
        state._read_dirblocks_if_needed()
 
1869
        def _entries_for_path(path):
 
1870
            """Return a list with all the entries that match path for all ids.
 
1871
            """
 
1872
            dirname, basename = os.path.split(path)
 
1873
            key = (dirname, basename, '')
 
1874
            block_index, present = state._find_block_index_from_key(key)
 
1875
            if not present:
 
1876
                # the block which should contain path is absent.
 
1877
                return []
 
1878
            result = []
 
1879
            block = state._dirblocks[block_index][1]
 
1880
            entry_index, _ = state._find_entry_index(key, block)
 
1881
            # we may need to look at multiple entries at this path: walk while the specific_files match.
 
1882
            while (entry_index < len(block) and
 
1883
                block[entry_index][0][0:2] == key[0:2]):
 
1884
                result.append(block[entry_index])
 
1885
                entry_index += 1
 
1886
            return result
2223
1887
        if require_versioned:
2224
1888
            # -- check all supplied paths are versioned in a search tree. --
2225
 
            not_versioned = []
 
1889
            all_versioned = True
2226
1890
            for path in specific_files:
2227
 
                path_entries = state._entries_for_path(path)
 
1891
                path_entries = _entries_for_path(path)
2228
1892
                if not path_entries:
2229
1893
                    # this specified path is not present at all: error
2230
 
                    not_versioned.append(path.decode('utf-8'))
2231
 
                    continue
 
1894
                    all_versioned = False
 
1895
                    break
2232
1896
                found_versioned = False
2233
1897
                # for each id at this path
2234
1898
                for entry in path_entries:
2241
1905
                if not found_versioned:
2242
1906
                    # none of the indexes was not 'absent' at all ids for this
2243
1907
                    # path.
2244
 
                    not_versioned.append(path.decode('utf-8'))
2245
 
            if len(not_versioned) > 0:
2246
 
                raise errors.PathsNotVersionedError(not_versioned)
 
1908
                    all_versioned = False
 
1909
                    break
 
1910
            if not all_versioned:
 
1911
                raise errors.PathsNotVersionedError(specific_files)
2247
1912
        # -- remove redundancy in supplied specific_files to prevent over-scanning --
2248
 
        search_specific_files = osutils.minimum_path_selection(specific_files)
 
1913
        search_specific_files = set()
 
1914
        for path in specific_files:
 
1915
            other_specific_files = specific_files.difference(set([path]))
 
1916
            if not osutils.is_inside_any(other_specific_files, path):
 
1917
                # this is a top level path, we must check it.
 
1918
                search_specific_files.add(path)
 
1919
        # sketch: 
 
1920
        # compare source_index and target_index at or under each element of search_specific_files.
 
1921
        # follow the following comparison table. Note that we only want to do diff operations when
 
1922
        # the target is fdl because thats when the walkdirs logic will have exposed the pathinfo 
 
1923
        # for the target.
 
1924
        # cases:
 
1925
        # 
 
1926
        # Source | Target | disk | action
 
1927
        #   r    | fdlt   |      | add source to search, add id path move and perform
 
1928
        #        |        |      | diff check on source-target
 
1929
        #   r    | fdlt   |  a   | dangling file that was present in the basis. 
 
1930
        #        |        |      | ???
 
1931
        #   r    |  a     |      | add source to search
 
1932
        #   r    |  a     |  a   | 
 
1933
        #   r    |  r     |      | this path is present in a non-examined tree, skip.
 
1934
        #   r    |  r     |  a   | this path is present in a non-examined tree, skip.
 
1935
        #   a    | fdlt   |      | add new id
 
1936
        #   a    | fdlt   |  a   | dangling locally added file, skip
 
1937
        #   a    |  a     |      | not present in either tree, skip
 
1938
        #   a    |  a     |  a   | not present in any tree, skip
 
1939
        #   a    |  r     |      | not present in either tree at this path, skip as it
 
1940
        #        |        |      | may not be selected by the users list of paths.
 
1941
        #   a    |  r     |  a   | not present in either tree at this path, skip as it
 
1942
        #        |        |      | may not be selected by the users list of paths.
 
1943
        #  fdlt  | fdlt   |      | content in both: diff them
 
1944
        #  fdlt  | fdlt   |  a   | deleted locally, but not unversioned - show as deleted ?
 
1945
        #  fdlt  |  a     |      | unversioned: output deleted id for now
 
1946
        #  fdlt  |  a     |  a   | unversioned and deleted: output deleted id
 
1947
        #  fdlt  |  r     |      | relocated in this tree, so add target to search.
 
1948
        #        |        |      | Dont diff, we will see an r,fd; pair when we reach
 
1949
        #        |        |      | this id at the other path.
 
1950
        #  fdlt  |  r     |  a   | relocated in this tree, so add target to search.
 
1951
        #        |        |      | Dont diff, we will see an r,fd; pair when we reach
 
1952
        #        |        |      | this id at the other path.
 
1953
 
 
1954
        # for all search_indexs in each path at or under each element of
 
1955
        # search_specific_files, if the detail is relocated: add the id, and add the
 
1956
        # relocated path as one to search if its not searched already. If the
 
1957
        # detail is not relocated, add the id.
 
1958
        searched_specific_files = set()
 
1959
        NULL_PARENT_DETAILS = dirstate.DirState.NULL_PARENT_DETAILS
 
1960
        # Using a list so that we can access the values and change them in
 
1961
        # nested scope. Each one is [path, file_id, entry]
 
1962
        last_source_parent = [None, None]
 
1963
        last_target_parent = [None, None]
2249
1964
 
2250
1965
        use_filesystem_for_exec = (sys.platform != 'win32')
2251
 
        iter_changes = self.target._iter_changes(include_unchanged,
2252
 
            use_filesystem_for_exec, search_specific_files, state,
2253
 
            source_index, target_index, want_unversioned, self.target)
2254
 
        return iter_changes.iter_changes()
 
1966
 
 
1967
        # Just a sentry, so that _process_entry can say that this
 
1968
        # record is handled, but isn't interesting to process (unchanged)
 
1969
        uninteresting = object()
 
1970
 
 
1971
 
 
1972
        old_dirname_to_file_id = {}
 
1973
        new_dirname_to_file_id = {}
 
1974
        # TODO: jam 20070516 - Avoid the _get_entry lookup overhead by
 
1975
        #       keeping a cache of directories that we have seen.
 
1976
 
 
1977
        def _process_entry(entry, path_info):
 
1978
            """Compare an entry and real disk to generate delta information.
 
1979
 
 
1980
            :param path_info: top_relpath, basename, kind, lstat, abspath for
 
1981
                the path of entry. If None, then the path is considered absent.
 
1982
                (Perhaps we should pass in a concrete entry for this ?)
 
1983
                Basename is returned as a utf8 string because we expect this
 
1984
                tuple will be ignored, and don't want to take the time to
 
1985
                decode.
 
1986
            :return: None if these don't match
 
1987
                     A tuple of information about the change, or
 
1988
                     the object 'uninteresting' if these match, but are
 
1989
                     basically identical.
 
1990
            """
 
1991
            if source_index is None:
 
1992
                source_details = NULL_PARENT_DETAILS
 
1993
            else:
 
1994
                source_details = entry[1][source_index]
 
1995
            target_details = entry[1][target_index]
 
1996
            target_minikind = target_details[0]
 
1997
            if path_info is not None and target_minikind in 'fdlt':
 
1998
                if not (target_index == 0):
 
1999
                    raise AssertionError()
 
2000
                link_or_sha1 = state.update_entry(entry, abspath=path_info[4],
 
2001
                                                  stat_value=path_info[3])
 
2002
                # The entry may have been modified by update_entry
 
2003
                target_details = entry[1][target_index]
 
2004
                target_minikind = target_details[0]
 
2005
            else:
 
2006
                link_or_sha1 = None
 
2007
            file_id = entry[0][2]
 
2008
            source_minikind = source_details[0]
 
2009
            if source_minikind in 'fdltr' and target_minikind in 'fdlt':
 
2010
                # claimed content in both: diff
 
2011
                #   r    | fdlt   |      | add source to search, add id path move and perform
 
2012
                #        |        |      | diff check on source-target
 
2013
                #   r    | fdlt   |  a   | dangling file that was present in the basis.
 
2014
                #        |        |      | ???
 
2015
                if source_minikind in 'r':
 
2016
                    # add the source to the search path to find any children it
 
2017
                    # has.  TODO ? : only add if it is a container ?
 
2018
                    if not osutils.is_inside_any(searched_specific_files,
 
2019
                                                 source_details[1]):
 
2020
                        search_specific_files.add(source_details[1])
 
2021
                    # generate the old path; this is needed for stating later
 
2022
                    # as well.
 
2023
                    old_path = source_details[1]
 
2024
                    old_dirname, old_basename = os.path.split(old_path)
 
2025
                    path = pathjoin(entry[0][0], entry[0][1])
 
2026
                    old_entry = state._get_entry(source_index,
 
2027
                                                 path_utf8=old_path)
 
2028
                    # update the source details variable to be the real
 
2029
                    # location.
 
2030
                    if old_entry == (None, None):
 
2031
                        raise errors.CorruptDirstate(state._filename,
 
2032
                            "entry '%s/%s' is considered renamed from %r"
 
2033
                            " but source does not exist\n"
 
2034
                            "entry: %s" % (entry[0][0], entry[0][1], old_path, entry))
 
2035
                    source_details = old_entry[1][source_index]
 
2036
                    source_minikind = source_details[0]
 
2037
                else:
 
2038
                    old_dirname = entry[0][0]
 
2039
                    old_basename = entry[0][1]
 
2040
                    old_path = path = None
 
2041
                if path_info is None:
 
2042
                    # the file is missing on disk, show as removed.
 
2043
                    content_change = True
 
2044
                    target_kind = None
 
2045
                    target_exec = False
 
2046
                else:
 
2047
                    # source and target are both versioned and disk file is present.
 
2048
                    target_kind = path_info[2]
 
2049
                    if target_kind == 'directory':
 
2050
                        if path is None:
 
2051
                            old_path = path = pathjoin(old_dirname, old_basename)
 
2052
                        new_dirname_to_file_id[path] = file_id
 
2053
                        if source_minikind != 'd':
 
2054
                            content_change = True
 
2055
                        else:
 
2056
                            # directories have no fingerprint
 
2057
                            content_change = False
 
2058
                        target_exec = False
 
2059
                    elif target_kind == 'file':
 
2060
                        if source_minikind != 'f':
 
2061
                            content_change = True
 
2062
                        else:
 
2063
                            # We could check the size, but we already have the
 
2064
                            # sha1 hash.
 
2065
                            content_change = (link_or_sha1 != source_details[1])
 
2066
                        # Target details is updated at update_entry time
 
2067
                        if use_filesystem_for_exec:
 
2068
                            # We don't need S_ISREG here, because we are sure
 
2069
                            # we are dealing with a file.
 
2070
                            target_exec = bool(stat.S_IEXEC & path_info[3].st_mode)
 
2071
                        else:
 
2072
                            target_exec = target_details[3]
 
2073
                    elif target_kind == 'symlink':
 
2074
                        if source_minikind != 'l':
 
2075
                            content_change = True
 
2076
                        else:
 
2077
                            content_change = (link_or_sha1 != source_details[1])
 
2078
                        target_exec = False
 
2079
                    elif target_kind == 'tree-reference':
 
2080
                        if source_minikind != 't':
 
2081
                            content_change = True
 
2082
                        else:
 
2083
                            content_change = False
 
2084
                        target_exec = False
 
2085
                    else:
 
2086
                        raise Exception, "unknown kind %s" % path_info[2]
 
2087
                if source_minikind == 'd':
 
2088
                    if path is None:
 
2089
                        old_path = path = pathjoin(old_dirname, old_basename)
 
2090
                    old_dirname_to_file_id[old_path] = file_id
 
2091
                # parent id is the entry for the path in the target tree
 
2092
                if old_dirname == last_source_parent[0]:
 
2093
                    source_parent_id = last_source_parent[1]
 
2094
                else:
 
2095
                    try:
 
2096
                        source_parent_id = old_dirname_to_file_id[old_dirname]
 
2097
                    except KeyError:
 
2098
                        source_parent_entry = state._get_entry(source_index,
 
2099
                                                               path_utf8=old_dirname)
 
2100
                        source_parent_id = source_parent_entry[0][2]
 
2101
                    if source_parent_id == entry[0][2]:
 
2102
                        # This is the root, so the parent is None
 
2103
                        source_parent_id = None
 
2104
                    else:
 
2105
                        last_source_parent[0] = old_dirname
 
2106
                        last_source_parent[1] = source_parent_id
 
2107
                new_dirname = entry[0][0]
 
2108
                if new_dirname == last_target_parent[0]:
 
2109
                    target_parent_id = last_target_parent[1]
 
2110
                else:
 
2111
                    try:
 
2112
                        target_parent_id = new_dirname_to_file_id[new_dirname]
 
2113
                    except KeyError:
 
2114
                        # TODO: We don't always need to do the lookup, because the
 
2115
                        #       parent entry will be the same as the source entry.
 
2116
                        target_parent_entry = state._get_entry(target_index,
 
2117
                                                               path_utf8=new_dirname)
 
2118
                        if target_parent_entry == (None, None):
 
2119
                            raise AssertionError(
 
2120
                                "Could not find target parent in wt: %s\nparent of: %s"
 
2121
                                % (new_dirname, entry))
 
2122
                        target_parent_id = target_parent_entry[0][2]
 
2123
                    if target_parent_id == entry[0][2]:
 
2124
                        # This is the root, so the parent is None
 
2125
                        target_parent_id = None
 
2126
                    else:
 
2127
                        last_target_parent[0] = new_dirname
 
2128
                        last_target_parent[1] = target_parent_id
 
2129
 
 
2130
                source_exec = source_details[3]
 
2131
                if (include_unchanged
 
2132
                    or content_change
 
2133
                    or source_parent_id != target_parent_id
 
2134
                    or old_basename != entry[0][1]
 
2135
                    or source_exec != target_exec
 
2136
                    ):
 
2137
                    if old_path is None:
 
2138
                        old_path = path = pathjoin(old_dirname, old_basename)
 
2139
                        old_path_u = utf8_decode(old_path)[0]
 
2140
                        path_u = old_path_u
 
2141
                    else:
 
2142
                        old_path_u = utf8_decode(old_path)[0]
 
2143
                        if old_path == path:
 
2144
                            path_u = old_path_u
 
2145
                        else:
 
2146
                            path_u = utf8_decode(path)[0]
 
2147
                    source_kind = _minikind_to_kind[source_minikind]
 
2148
                    return (entry[0][2],
 
2149
                           (old_path_u, path_u),
 
2150
                           content_change,
 
2151
                           (True, True),
 
2152
                           (source_parent_id, target_parent_id),
 
2153
                           (utf8_decode(old_basename)[0], utf8_decode(entry[0][1])[0]),
 
2154
                           (source_kind, target_kind),
 
2155
                           (source_exec, target_exec))
 
2156
                else:
 
2157
                    return uninteresting
 
2158
            elif source_minikind in 'a' and target_minikind in 'fdlt':
 
2159
                # looks like a new file
 
2160
                if path_info is not None:
 
2161
                    path = pathjoin(entry[0][0], entry[0][1])
 
2162
                    # parent id is the entry for the path in the target tree
 
2163
                    # TODO: these are the same for an entire directory: cache em.
 
2164
                    parent_id = state._get_entry(target_index,
 
2165
                                                 path_utf8=entry[0][0])[0][2]
 
2166
                    if parent_id == entry[0][2]:
 
2167
                        parent_id = None
 
2168
                    if use_filesystem_for_exec:
 
2169
                        # We need S_ISREG here, because we aren't sure if this
 
2170
                        # is a file or not.
 
2171
                        target_exec = bool(
 
2172
                            stat.S_ISREG(path_info[3].st_mode)
 
2173
                            and stat.S_IEXEC & path_info[3].st_mode)
 
2174
                    else:
 
2175
                        target_exec = target_details[3]
 
2176
                    return (entry[0][2],
 
2177
                           (None, utf8_decode(path)[0]),
 
2178
                           True,
 
2179
                           (False, True),
 
2180
                           (None, parent_id),
 
2181
                           (None, utf8_decode(entry[0][1])[0]),
 
2182
                           (None, path_info[2]),
 
2183
                           (None, target_exec))
 
2184
                else:
 
2185
                    # but its not on disk: we deliberately treat this as just
 
2186
                    # never-present. (Why ?! - RBC 20070224)
 
2187
                    pass
 
2188
            elif source_minikind in 'fdlt' and target_minikind in 'a':
 
2189
                # unversioned, possibly, or possibly not deleted: we dont care.
 
2190
                # if its still on disk, *and* theres no other entry at this
 
2191
                # path [we dont know this in this routine at the moment -
 
2192
                # perhaps we should change this - then it would be an unknown.
 
2193
                old_path = pathjoin(entry[0][0], entry[0][1])
 
2194
                # parent id is the entry for the path in the target tree
 
2195
                parent_id = state._get_entry(source_index, path_utf8=entry[0][0])[0][2]
 
2196
                if parent_id == entry[0][2]:
 
2197
                    parent_id = None
 
2198
                return (entry[0][2],
 
2199
                       (utf8_decode(old_path)[0], None),
 
2200
                       True,
 
2201
                       (True, False),
 
2202
                       (parent_id, None),
 
2203
                       (utf8_decode(entry[0][1])[0], None),
 
2204
                       (_minikind_to_kind[source_minikind], None),
 
2205
                       (source_details[3], None))
 
2206
            elif source_minikind in 'fdlt' and target_minikind in 'r':
 
2207
                # a rename; could be a true rename, or a rename inherited from
 
2208
                # a renamed parent. TODO: handle this efficiently. Its not
 
2209
                # common case to rename dirs though, so a correct but slow
 
2210
                # implementation will do.
 
2211
                if not osutils.is_inside_any(searched_specific_files, target_details[1]):
 
2212
                    search_specific_files.add(target_details[1])
 
2213
            elif source_minikind in 'ra' and target_minikind in 'ra':
 
2214
                # neither of the selected trees contain this file,
 
2215
                # so skip over it. This is not currently directly tested, but
 
2216
                # is indirectly via test_too_much.TestCommands.test_conflicts.
 
2217
                pass
 
2218
            else:
 
2219
                raise AssertionError("don't know how to compare "
 
2220
                    "source_minikind=%r, target_minikind=%r"
 
2221
                    % (source_minikind, target_minikind))
 
2222
                ## import pdb;pdb.set_trace()
 
2223
            return None
 
2224
 
 
2225
        while search_specific_files:
 
2226
            # TODO: the pending list should be lexically sorted?  the
 
2227
            # interface doesn't require it.
 
2228
            current_root = search_specific_files.pop()
 
2229
            current_root_unicode = current_root.decode('utf8')
 
2230
            searched_specific_files.add(current_root)
 
2231
            # process the entries for this containing directory: the rest will be
 
2232
            # found by their parents recursively.
 
2233
            root_entries = _entries_for_path(current_root)
 
2234
            root_abspath = self.target.abspath(current_root_unicode)
 
2235
            try:
 
2236
                root_stat = os.lstat(root_abspath)
 
2237
            except OSError, e:
 
2238
                if e.errno == errno.ENOENT:
 
2239
                    # the path does not exist: let _process_entry know that.
 
2240
                    root_dir_info = None
 
2241
                else:
 
2242
                    # some other random error: hand it up.
 
2243
                    raise
 
2244
            else:
 
2245
                root_dir_info = ('', current_root,
 
2246
                    osutils.file_kind_from_stat_mode(root_stat.st_mode), root_stat,
 
2247
                    root_abspath)
 
2248
                if root_dir_info[2] == 'directory':
 
2249
                    if self.target._directory_is_tree_reference(
 
2250
                        current_root.decode('utf8')):
 
2251
                        root_dir_info = root_dir_info[:2] + \
 
2252
                            ('tree-reference',) + root_dir_info[3:]
 
2253
 
 
2254
            if not root_entries and not root_dir_info:
 
2255
                # this specified path is not present at all, skip it.
 
2256
                continue
 
2257
            path_handled = False
 
2258
            for entry in root_entries:
 
2259
                result = _process_entry(entry, root_dir_info)
 
2260
                if result is not None:
 
2261
                    path_handled = True
 
2262
                    if result is not uninteresting:
 
2263
                        yield result
 
2264
            if want_unversioned and not path_handled and root_dir_info:
 
2265
                new_executable = bool(
 
2266
                    stat.S_ISREG(root_dir_info[3].st_mode)
 
2267
                    and stat.S_IEXEC & root_dir_info[3].st_mode)
 
2268
                yield (None,
 
2269
                       (None, current_root_unicode),
 
2270
                       True,
 
2271
                       (False, False),
 
2272
                       (None, None),
 
2273
                       (None, splitpath(current_root_unicode)[-1]),
 
2274
                       (None, root_dir_info[2]),
 
2275
                       (None, new_executable)
 
2276
                      )
 
2277
            initial_key = (current_root, '', '')
 
2278
            block_index, _ = state._find_block_index_from_key(initial_key)
 
2279
            if block_index == 0:
 
2280
                # we have processed the total root already, but because the
 
2281
                # initial key matched it we should skip it here.
 
2282
                block_index +=1
 
2283
            if root_dir_info and root_dir_info[2] == 'tree-reference':
 
2284
                current_dir_info = None
 
2285
            else:
 
2286
                dir_iterator = osutils._walkdirs_utf8(root_abspath, prefix=current_root)
 
2287
                try:
 
2288
                    current_dir_info = dir_iterator.next()
 
2289
                except OSError, e:
 
2290
                    # on win32, python2.4 has e.errno == ERROR_DIRECTORY, but
 
2291
                    # python 2.5 has e.errno == EINVAL,
 
2292
                    #            and e.winerror == ERROR_DIRECTORY
 
2293
                    e_winerror = getattr(e, 'winerror', None)
 
2294
                    win_errors = (ERROR_DIRECTORY, ERROR_PATH_NOT_FOUND)
 
2295
                    # there may be directories in the inventory even though
 
2296
                    # this path is not a file on disk: so mark it as end of
 
2297
                    # iterator
 
2298
                    if e.errno in (errno.ENOENT, errno.ENOTDIR, errno.EINVAL):
 
2299
                        current_dir_info = None
 
2300
                    elif (sys.platform == 'win32'
 
2301
                          and (e.errno in win_errors
 
2302
                               or e_winerror in win_errors)):
 
2303
                        current_dir_info = None
 
2304
                    else:
 
2305
                        raise
 
2306
                else:
 
2307
                    if current_dir_info[0][0] == '':
 
2308
                        # remove .bzr from iteration
 
2309
                        bzr_index = bisect_left(current_dir_info[1], ('.bzr',))
 
2310
                        if current_dir_info[1][bzr_index][0] != '.bzr':
 
2311
                            raise AssertionError()
 
2312
                        del current_dir_info[1][bzr_index]
 
2313
            # walk until both the directory listing and the versioned metadata
 
2314
            # are exhausted. 
 
2315
            if (block_index < len(state._dirblocks) and
 
2316
                osutils.is_inside(current_root, state._dirblocks[block_index][0])):
 
2317
                current_block = state._dirblocks[block_index]
 
2318
            else:
 
2319
                current_block = None
 
2320
            while (current_dir_info is not None or
 
2321
                   current_block is not None):
 
2322
                if (current_dir_info and current_block
 
2323
                    and current_dir_info[0][0] != current_block[0]):
 
2324
                    if cmp_by_dirs(current_dir_info[0][0], current_block[0]) < 0:
 
2325
                        # filesystem data refers to paths not covered by the dirblock.
 
2326
                        # this has two possibilities:
 
2327
                        # A) it is versioned but empty, so there is no block for it
 
2328
                        # B) it is not versioned.
 
2329
 
 
2330
                        # if (A) then we need to recurse into it to check for
 
2331
                        # new unknown files or directories.
 
2332
                        # if (B) then we should ignore it, because we don't
 
2333
                        # recurse into unknown directories.
 
2334
                        path_index = 0
 
2335
                        while path_index < len(current_dir_info[1]):
 
2336
                                current_path_info = current_dir_info[1][path_index]
 
2337
                                if want_unversioned:
 
2338
                                    if current_path_info[2] == 'directory':
 
2339
                                        if self.target._directory_is_tree_reference(
 
2340
                                            current_path_info[0].decode('utf8')):
 
2341
                                            current_path_info = current_path_info[:2] + \
 
2342
                                                ('tree-reference',) + current_path_info[3:]
 
2343
                                    new_executable = bool(
 
2344
                                        stat.S_ISREG(current_path_info[3].st_mode)
 
2345
                                        and stat.S_IEXEC & current_path_info[3].st_mode)
 
2346
                                    yield (None,
 
2347
                                        (None, utf8_decode(current_path_info[0])[0]),
 
2348
                                        True,
 
2349
                                        (False, False),
 
2350
                                        (None, None),
 
2351
                                        (None, utf8_decode(current_path_info[1])[0]),
 
2352
                                        (None, current_path_info[2]),
 
2353
                                        (None, new_executable))
 
2354
                                # dont descend into this unversioned path if it is
 
2355
                                # a dir
 
2356
                                if current_path_info[2] in ('directory',
 
2357
                                                            'tree-reference'):
 
2358
                                    del current_dir_info[1][path_index]
 
2359
                                    path_index -= 1
 
2360
                                path_index += 1
 
2361
 
 
2362
                        # This dir info has been handled, go to the next
 
2363
                        try:
 
2364
                            current_dir_info = dir_iterator.next()
 
2365
                        except StopIteration:
 
2366
                            current_dir_info = None
 
2367
                    else:
 
2368
                        # We have a dirblock entry for this location, but there
 
2369
                        # is no filesystem path for this. This is most likely
 
2370
                        # because a directory was removed from the disk.
 
2371
                        # We don't have to report the missing directory,
 
2372
                        # because that should have already been handled, but we
 
2373
                        # need to handle all of the files that are contained
 
2374
                        # within.
 
2375
                        for current_entry in current_block[1]:
 
2376
                            # entry referring to file not present on disk.
 
2377
                            # advance the entry only, after processing.
 
2378
                            result = _process_entry(current_entry, None)
 
2379
                            if result is not None:
 
2380
                                if result is not uninteresting:
 
2381
                                    yield result
 
2382
                        block_index +=1
 
2383
                        if (block_index < len(state._dirblocks) and
 
2384
                            osutils.is_inside(current_root,
 
2385
                                              state._dirblocks[block_index][0])):
 
2386
                            current_block = state._dirblocks[block_index]
 
2387
                        else:
 
2388
                            current_block = None
 
2389
                    continue
 
2390
                entry_index = 0
 
2391
                if current_block and entry_index < len(current_block[1]):
 
2392
                    current_entry = current_block[1][entry_index]
 
2393
                else:
 
2394
                    current_entry = None
 
2395
                advance_entry = True
 
2396
                path_index = 0
 
2397
                if current_dir_info and path_index < len(current_dir_info[1]):
 
2398
                    current_path_info = current_dir_info[1][path_index]
 
2399
                    if current_path_info[2] == 'directory':
 
2400
                        if self.target._directory_is_tree_reference(
 
2401
                            current_path_info[0].decode('utf8')):
 
2402
                            current_path_info = current_path_info[:2] + \
 
2403
                                ('tree-reference',) + current_path_info[3:]
 
2404
                else:
 
2405
                    current_path_info = None
 
2406
                advance_path = True
 
2407
                path_handled = False
 
2408
                while (current_entry is not None or
 
2409
                    current_path_info is not None):
 
2410
                    if current_entry is None:
 
2411
                        # the check for path_handled when the path is adnvaced
 
2412
                        # will yield this path if needed.
 
2413
                        pass
 
2414
                    elif current_path_info is None:
 
2415
                        # no path is fine: the per entry code will handle it.
 
2416
                        result = _process_entry(current_entry, current_path_info)
 
2417
                        if result is not None:
 
2418
                            if result is not uninteresting:
 
2419
                                yield result
 
2420
                    elif (current_entry[0][1] != current_path_info[1]
 
2421
                          or current_entry[1][target_index][0] in 'ar'):
 
2422
                        # The current path on disk doesn't match the dirblock
 
2423
                        # record. Either the dirblock is marked as absent, or
 
2424
                        # the file on disk is not present at all in the
 
2425
                        # dirblock. Either way, report about the dirblock
 
2426
                        # entry, and let other code handle the filesystem one.
 
2427
 
 
2428
                        # Compare the basename for these files to determine
 
2429
                        # which comes first
 
2430
                        if current_path_info[1] < current_entry[0][1]:
 
2431
                            # extra file on disk: pass for now, but only
 
2432
                            # increment the path, not the entry
 
2433
                            advance_entry = False
 
2434
                        else:
 
2435
                            # entry referring to file not present on disk.
 
2436
                            # advance the entry only, after processing.
 
2437
                            result = _process_entry(current_entry, None)
 
2438
                            if result is not None:
 
2439
                                if result is not uninteresting:
 
2440
                                    yield result
 
2441
                            advance_path = False
 
2442
                    else:
 
2443
                        result = _process_entry(current_entry, current_path_info)
 
2444
                        if result is not None:
 
2445
                            path_handled = True
 
2446
                            if result is not uninteresting:
 
2447
                                yield result
 
2448
                    if advance_entry and current_entry is not None:
 
2449
                        entry_index += 1
 
2450
                        if entry_index < len(current_block[1]):
 
2451
                            current_entry = current_block[1][entry_index]
 
2452
                        else:
 
2453
                            current_entry = None
 
2454
                    else:
 
2455
                        advance_entry = True # reset the advance flaga
 
2456
                    if advance_path and current_path_info is not None:
 
2457
                        if not path_handled:
 
2458
                            # unversioned in all regards
 
2459
                            if want_unversioned:
 
2460
                                new_executable = bool(
 
2461
                                    stat.S_ISREG(current_path_info[3].st_mode)
 
2462
                                    and stat.S_IEXEC & current_path_info[3].st_mode)
 
2463
                                try:
 
2464
                                    relpath_unicode = utf8_decode(current_path_info[0])[0]
 
2465
                                except UnicodeDecodeError:
 
2466
                                    raise errors.BadFilenameEncoding(
 
2467
                                        current_path_info[0], osutils._fs_enc)
 
2468
                                yield (None,
 
2469
                                    (None, relpath_unicode),
 
2470
                                    True,
 
2471
                                    (False, False),
 
2472
                                    (None, None),
 
2473
                                    (None, utf8_decode(current_path_info[1])[0]),
 
2474
                                    (None, current_path_info[2]),
 
2475
                                    (None, new_executable))
 
2476
                            # dont descend into this unversioned path if it is
 
2477
                            # a dir
 
2478
                            if current_path_info[2] in ('directory'):
 
2479
                                del current_dir_info[1][path_index]
 
2480
                                path_index -= 1
 
2481
                        # dont descend the disk iterator into any tree 
 
2482
                        # paths.
 
2483
                        if current_path_info[2] == 'tree-reference':
 
2484
                            del current_dir_info[1][path_index]
 
2485
                            path_index -= 1
 
2486
                        path_index += 1
 
2487
                        if path_index < len(current_dir_info[1]):
 
2488
                            current_path_info = current_dir_info[1][path_index]
 
2489
                            if current_path_info[2] == 'directory':
 
2490
                                if self.target._directory_is_tree_reference(
 
2491
                                    current_path_info[0].decode('utf8')):
 
2492
                                    current_path_info = current_path_info[:2] + \
 
2493
                                        ('tree-reference',) + current_path_info[3:]
 
2494
                        else:
 
2495
                            current_path_info = None
 
2496
                        path_handled = False
 
2497
                    else:
 
2498
                        advance_path = True # reset the advance flagg.
 
2499
                if current_block is not None:
 
2500
                    block_index += 1
 
2501
                    if (block_index < len(state._dirblocks) and
 
2502
                        osutils.is_inside(current_root, state._dirblocks[block_index][0])):
 
2503
                        current_block = state._dirblocks[block_index]
 
2504
                    else:
 
2505
                        current_block = None
 
2506
                if current_dir_info is not None:
 
2507
                    try:
 
2508
                        current_dir_info = dir_iterator.next()
 
2509
                    except StopIteration:
 
2510
                        current_dir_info = None
 
2511
 
2255
2512
 
2256
2513
    @staticmethod
2257
2514
    def is_compatible(source, target):
2258
2515
        # the target must be a dirstate working tree
2259
 
        if not isinstance(target, DirStateWorkingTree):
 
2516
        if not isinstance(target, WorkingTree4):
2260
2517
            return False
2261
 
        # the source must be a revtree or dirstate rev tree.
 
2518
        # the source must be a revtreee or dirstate rev tree.
2262
2519
        if not isinstance(source,
2263
2520
            (revisiontree.RevisionTree, DirStateRevisionTree)):
2264
2521
            return False
2265
2522
        # the source revid must be in the target dirstate
2266
 
        if not (source._revision_id == _mod_revision.NULL_REVISION or
 
2523
        if not (source._revision_id == NULL_REVISION or
2267
2524
            source._revision_id in target.get_parent_ids()):
2268
 
            # TODO: what about ghosts? it may well need to
 
2525
            # TODO: what about ghosts? it may well need to 
2269
2526
            # check for them explicitly.
2270
2527
            return False
2271
2528
        return True
2281
2538
 
2282
2539
    def convert(self, tree):
2283
2540
        # lock the control files not the tree, so that we dont get tree
2284
 
        # on-unlock behaviours, and so that noone else diddles with the
 
2541
        # on-unlock behaviours, and so that noone else diddles with the 
2285
2542
        # tree during upgrade.
2286
2543
        tree._control_files.lock_write()
2287
2544
        try:
2314
2571
    def update_format(self, tree):
2315
2572
        """Change the format marker."""
2316
2573
        tree._transport.put_bytes('format',
2317
 
            self.target_format.as_string(),
2318
 
            mode=tree.bzrdir._get_file_mode())
2319
 
 
2320
 
 
2321
 
class Converter4to5(object):
2322
 
    """Perform an in-place upgrade of format 4 to format 5 trees."""
2323
 
 
2324
 
    def __init__(self):
2325
 
        self.target_format = WorkingTreeFormat5()
2326
 
 
2327
 
    def convert(self, tree):
2328
 
        # lock the control files not the tree, so that we don't get tree
2329
 
        # on-unlock behaviours, and so that no-one else diddles with the
2330
 
        # tree during upgrade.
2331
 
        tree._control_files.lock_write()
2332
 
        try:
2333
 
            self.update_format(tree)
2334
 
        finally:
2335
 
            tree._control_files.unlock()
2336
 
 
2337
 
    def update_format(self, tree):
2338
 
        """Change the format marker."""
2339
 
        tree._transport.put_bytes('format',
2340
 
            self.target_format.as_string(),
2341
 
            mode=tree.bzrdir._get_file_mode())
2342
 
 
2343
 
 
2344
 
class Converter4or5to6(object):
2345
 
    """Perform an in-place upgrade of format 4 or 5 to format 6 trees."""
2346
 
 
2347
 
    def __init__(self):
2348
 
        self.target_format = WorkingTreeFormat6()
2349
 
 
2350
 
    def convert(self, tree):
2351
 
        # lock the control files not the tree, so that we don't get tree
2352
 
        # on-unlock behaviours, and so that no-one else diddles with the
2353
 
        # tree during upgrade.
2354
 
        tree._control_files.lock_write()
2355
 
        try:
2356
 
            self.init_custom_control_files(tree)
2357
 
            self.update_format(tree)
2358
 
        finally:
2359
 
            tree._control_files.unlock()
2360
 
 
2361
 
    def init_custom_control_files(self, tree):
2362
 
        """Initialize custom control files."""
2363
 
        tree._transport.put_bytes('views', '',
2364
 
            mode=tree.bzrdir._get_file_mode())
2365
 
 
2366
 
    def update_format(self, tree):
2367
 
        """Change the format marker."""
2368
 
        tree._transport.put_bytes('format',
2369
 
            self.target_format.as_string(),
 
2574
            self.target_format.get_format_string(),
2370
2575
            mode=tree.bzrdir._get_file_mode())