← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Vincent Ladeuil
  • Date: 2010-04-22 14:18:17 UTC
  • mto: (5190.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5191.
  • Revision ID: v.ladeuil+lp@free.fr-20100422141817-izoao20264ivkauo
Explain that the uncommitted changes are not processed when
issuing the warning.

* bzrlib/mutabletree.py:
(MutableTree.check_changed_or_out_of_date): Use diferent 'more'
arguments depending on whether we issue a warning or an error.

* bzrlib/send.py:
(send): Add the more_warnings argument when calling
check_changed_or_out_of_date.

* bzrlib/foreign.py:
(cmd_dpush.run): Add the more_warnings argument when calling
check_changed_or_out_of_date.

* bzrlib/builtins.py:
(cmd_push.run): Add the more_warnings argument when calling
check_changed_or_out_of_date.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
48
48
import itertools
49
49
import operator
50
50
import stat
51
 
from time import time
52
 
import warnings
53
51
import re
54
52
 
55
53
import bzrlib
57
55
    branch,
58
56
    bzrdir,
59
57
    conflicts as _mod_conflicts,
60
 
    dirstate,
61
58
    errors,
62
59
    generate_ids,
63
60
    globbing,
 
61
    graph as _mod_graph,
64
62
    hashcache,
65
63
    ignores,
 
64
    inventory,
66
65
    merge,
67
66
    revision as _mod_revision,
68
67
    revisiontree,
69
 
    repository,
70
 
    textui,
71
68
    trace,
72
69
    transform,
73
70
    ui,
74
 
    urlutils,
75
71
    views,
76
72
    xml5,
77
 
    xml6,
78
73
    xml7,
79
74
    )
80
75
import bzrlib.branch
81
76
from bzrlib.transport import get_transport
82
 
import bzrlib.ui
83
 
from bzrlib.workingtree_4 import WorkingTreeFormat4, WorkingTreeFormat5
 
77
from bzrlib.workingtree_4 import (
 
78
    WorkingTreeFormat4,
 
79
    WorkingTreeFormat5,
 
80
    WorkingTreeFormat6,
 
81
    )
84
82
""")
85
83
 
86
84
from bzrlib import symbol_versioning
87
85
from bzrlib.decorators import needs_read_lock, needs_write_lock
88
 
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, TreeReference
89
86
from bzrlib.lockable_files import LockableFiles
90
87
from bzrlib.lockdir import LockDir
91
88
import bzrlib.mutabletree
92
89
from bzrlib.mutabletree import needs_tree_write_lock
93
90
from bzrlib import osutils
94
91
from bzrlib.osutils import (
95
 
    compact_date,
96
92
    file_kind,
97
93
    isdir,
98
94
    normpath,
99
95
    pathjoin,
100
 
    rand_chars,
101
96
    realpath,
102
97
    safe_unicode,
103
98
    splitpath,
106
101
from bzrlib.filters import filtered_input_file
107
102
from bzrlib.trace import mutter, note
108
103
from bzrlib.transport.local import LocalTransport
109
 
from bzrlib.progress import DummyProgress, ProgressPhase
110
 
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
 
104
from bzrlib.progress import ProgressPhase
 
105
from bzrlib.revision import CURRENT_REVISION
111
106
from bzrlib.rio import RioReader, rio_file, Stanza
112
 
from bzrlib.symbol_versioning import (deprecated_passed,
113
 
        deprecated_method,
114
 
        deprecated_function,
115
 
        DEPRECATED_PARAMETER,
116
 
        )
 
107
from bzrlib.symbol_versioning import (
 
108
    deprecated_passed,
 
109
    DEPRECATED_PARAMETER,
 
110
    )
117
111
 
118
112
 
119
113
MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"
 
114
# TODO: Modifying the conflict objects or their type is currently nearly
 
115
# impossible as there is no clear relationship between the working tree format
 
116
# and the conflict list file format.
120
117
CONFLICT_HEADER_1 = "BZR conflict list format 1"
121
118
 
122
119
ERROR_PATH_NOT_FOUND = 3    # WindowsError errno code, equivalent to ENOENT
286
283
        self._control_files.break_lock()
287
284
        self.branch.break_lock()
288
285
 
 
286
    def _get_check_refs(self):
 
287
        """Return the references needed to perform a check of this tree.
 
288
        
 
289
        The default implementation returns no refs, and is only suitable for
 
290
        trees that have no local caching and can commit on ghosts at any time.
 
291
 
 
292
        :seealso: bzrlib.check for details about check_refs.
 
293
        """
 
294
        return []
 
295
 
289
296
    def requires_rich_root(self):
290
297
        return self._format.requires_rich_root
291
298
 
415
422
            return self.branch.repository.revision_tree(revision_id)
416
423
        except (errors.RevisionNotPresent, errors.NoSuchRevision):
417
424
            # the basis tree *may* be a ghost or a low level error may have
418
 
            # occured. If the revision is present, its a problem, if its not
 
425
            # occurred. If the revision is present, its a problem, if its not
419
426
            # its a ghost.
420
427
            if self.branch.repository.has_revision(revision_id):
421
428
                raise
442
449
 
443
450
    def get_file_with_stat(self, file_id, path=None, filtered=True,
444
451
        _fstat=os.fstat):
445
 
        """See MutableTree.get_file_with_stat."""
 
452
        """See Tree.get_file_with_stat."""
446
453
        if path is None:
447
454
            path = self.id2path(file_id)
448
455
        file_obj = self.get_file_byname(path, filtered=False)
449
456
        stat_value = _fstat(file_obj.fileno())
450
 
        if self.supports_content_filtering() and filtered:
 
457
        if filtered and self.supports_content_filtering():
451
458
            filters = self._content_filter_stack(path)
452
459
            file_obj = filtered_input_file(file_obj, filters)
453
460
        return (file_obj, stat_value)
458
465
    def get_file_byname(self, filename, filtered=True):
459
466
        path = self.abspath(filename)
460
467
        f = file(path, 'rb')
461
 
        if self.supports_content_filtering() and filtered:
 
468
        if filtered and self.supports_content_filtering():
462
469
            filters = self._content_filter_stack(filename)
463
470
            return filtered_input_file(f, filters)
464
471
        else:
483
490
        incorrectly attributed to CURRENT_REVISION (but after committing, the
484
491
        attribution will be correct).
485
492
        """
486
 
        basis = self.basis_tree()
487
 
        basis.lock_read()
488
 
        try:
489
 
            changes = self.iter_changes(basis, True, [self.id2path(file_id)],
490
 
                require_versioned=True).next()
491
 
            changed_content, kind = changes[2], changes[6]
492
 
            if not changed_content:
493
 
                return basis.annotate_iter(file_id)
494
 
            if kind[1] is None:
495
 
                return None
496
 
            import annotate
497
 
            if kind[0] != 'file':
498
 
                old_lines = []
499
 
            else:
500
 
                old_lines = list(basis.annotate_iter(file_id))
501
 
            old = [old_lines]
502
 
            for tree in self.branch.repository.revision_trees(
503
 
                self.get_parent_ids()[1:]):
504
 
                if file_id not in tree:
505
 
                    continue
506
 
                old.append(list(tree.annotate_iter(file_id)))
507
 
            return annotate.reannotate(old, self.get_file(file_id).readlines(),
508
 
                                       default_revision)
509
 
        finally:
510
 
            basis.unlock()
 
493
        maybe_file_parent_keys = []
 
494
        for parent_id in self.get_parent_ids():
 
495
            try:
 
496
                parent_tree = self.revision_tree(parent_id)
 
497
            except errors.NoSuchRevisionInTree:
 
498
                parent_tree = self.branch.repository.revision_tree(parent_id)
 
499
            parent_tree.lock_read()
 
500
            try:
 
501
                if file_id not in parent_tree:
 
502
                    continue
 
503
                ie = parent_tree.inventory[file_id]
 
504
                if ie.kind != 'file':
 
505
                    # Note: this is slightly unnecessary, because symlinks and
 
506
                    # directories have a "text" which is the empty text, and we
 
507
                    # know that won't mess up annotations. But it seems cleaner
 
508
                    continue
 
509
                parent_text_key = (file_id, ie.revision)
 
510
                if parent_text_key not in maybe_file_parent_keys:
 
511
                    maybe_file_parent_keys.append(parent_text_key)
 
512
            finally:
 
513
                parent_tree.unlock()
 
514
        graph = _mod_graph.Graph(self.branch.repository.texts)
 
515
        heads = graph.heads(maybe_file_parent_keys)
 
516
        file_parent_keys = []
 
517
        for key in maybe_file_parent_keys:
 
518
            if key in heads:
 
519
                file_parent_keys.append(key)
 
520
 
 
521
        # Now we have the parents of this content
 
522
        annotator = self.branch.repository.texts.get_annotator()
 
523
        text = self.get_file(file_id).read()
 
524
        this_key =(file_id, default_revision)
 
525
        annotator.add_special_text(this_key, file_parent_keys, text)
 
526
        annotations = [(key[-1], line)
 
527
                       for key, line in annotator.annotate_flat(this_key)]
 
528
        return annotations
511
529
 
512
530
    def _get_ancestors(self, default_revision):
513
531
        ancestors = set([default_revision])
528
546
        else:
529
547
            parents = [last_rev]
530
548
        try:
531
 
            merges_file = self._transport.get('pending-merges')
 
549
            merges_bytes = self._transport.get_bytes('pending-merges')
532
550
        except errors.NoSuchFile:
533
551
            pass
534
552
        else:
535
 
            for l in merges_file.readlines():
 
553
            for l in osutils.split_lines(merges_bytes):
536
554
                revision_id = l.rstrip('\n')
537
555
                parents.append(revision_id)
538
556
        return parents
557
575
 
558
576
        revision
559
577
            If not None, the cloned tree will have its last revision set to
560
 
            revision, and and difference between the source trees last revision
 
578
            revision, and difference between the source trees last revision
561
579
            and this one merged in.
562
580
        """
563
581
        # assumes the target bzr dir format is compatible.
597
615
 
598
616
    def get_file_size(self, file_id):
599
617
        """See Tree.get_file_size"""
 
618
        # XXX: this returns the on-disk size; it should probably return the
 
619
        # canonical size
600
620
        try:
601
621
            return os.path.getsize(self.id2abspath(file_id))
602
622
        except OSError, e:
618
638
 
619
639
    def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
620
640
        file_id = self.path2id(path)
 
641
        if file_id is None:
 
642
            # For unversioned files on win32, we just assume they are not
 
643
            # executable
 
644
            return False
621
645
        return self._inventory[file_id].executable
622
646
 
623
647
    def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
733
757
            raise
734
758
        kind = _mapper(stat_result.st_mode)
735
759
        if kind == 'file':
736
 
            size = stat_result.st_size
737
 
            # try for a stat cache lookup
738
 
            executable = self._is_executable_from_path_and_stat(path, stat_result)
739
 
            return (kind, size, executable, self._sha_from_stat(
740
 
                path, stat_result))
 
760
            return self._file_content_summary(path, stat_result)
741
761
        elif kind == 'directory':
742
762
            # perhaps it looks like a plain directory, but it's really a
743
763
            # reference.
745
765
                kind = 'tree-reference'
746
766
            return kind, None, None, None
747
767
        elif kind == 'symlink':
748
 
            return ('symlink', None, None,
749
 
                    os.readlink(abspath.encode(osutils._fs_enc)
750
 
                                ).decode(osutils._fs_enc))
 
768
            target = osutils.readlink(abspath)
 
769
            return ('symlink', None, None, target)
751
770
        else:
752
771
            return (kind, None, None, None)
753
772
 
 
773
    def _file_content_summary(self, path, stat_result):
 
774
        size = stat_result.st_size
 
775
        executable = self._is_executable_from_path_and_stat(path, stat_result)
 
776
        # try for a stat cache lookup
 
777
        return ('file', size, executable, self._sha_from_stat(
 
778
            path, stat_result))
 
779
 
754
780
    def _check_parents_for_ghosts(self, revision_ids, allow_leftmost_as_ghost):
755
781
        """Common ghost checking functionality from set_parent_*.
756
782
 
876
902
 
877
903
    @needs_write_lock # because merge pulls data into the branch.
878
904
    def merge_from_branch(self, branch, to_revision=None, from_revision=None,
879
 
        merge_type=None):
 
905
                          merge_type=None, force=False):
880
906
        """Merge from a branch into this working tree.
881
907
 
882
908
        :param branch: The branch to merge from.
886
912
            branch.last_revision().
887
913
        """
888
914
        from bzrlib.merge import Merger, Merge3Merger
889
 
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
890
 
        try:
891
 
            merger = Merger(self.branch, this_tree=self, pb=pb)
892
 
            merger.pp = ProgressPhase("Merge phase", 5, pb)
893
 
            merger.pp.next_phase()
894
 
            # check that there are no
895
 
            # local alterations
896
 
            merger.check_basis(check_clean=True, require_commits=False)
897
 
            if to_revision is None:
898
 
                to_revision = _mod_revision.ensure_null(branch.last_revision())
899
 
            merger.other_rev_id = to_revision
900
 
            if _mod_revision.is_null(merger.other_rev_id):
901
 
                raise errors.NoCommits(branch)
902
 
            self.branch.fetch(branch, last_revision=merger.other_rev_id)
903
 
            merger.other_basis = merger.other_rev_id
904
 
            merger.other_tree = self.branch.repository.revision_tree(
905
 
                merger.other_rev_id)
906
 
            merger.other_branch = branch
907
 
            merger.pp.next_phase()
908
 
            if from_revision is None:
909
 
                merger.find_base()
910
 
            else:
911
 
                merger.set_base_revision(from_revision, branch)
912
 
            if merger.base_rev_id == merger.other_rev_id:
913
 
                raise errors.PointlessMerge
914
 
            merger.backup_files = False
915
 
            if merge_type is None:
916
 
                merger.merge_type = Merge3Merger
917
 
            else:
918
 
                merger.merge_type = merge_type
919
 
            merger.set_interesting_files(None)
920
 
            merger.show_base = False
921
 
            merger.reprocess = False
922
 
            conflicts = merger.do_merge()
923
 
            merger.set_pending()
924
 
        finally:
925
 
            pb.finished()
 
915
        merger = Merger(self.branch, this_tree=self)
 
916
        # check that there are no local alterations
 
917
        if not force and self.has_changes():
 
918
            raise errors.UncommittedChanges(self)
 
919
        if to_revision is None:
 
920
            to_revision = _mod_revision.ensure_null(branch.last_revision())
 
921
        merger.other_rev_id = to_revision
 
922
        if _mod_revision.is_null(merger.other_rev_id):
 
923
            raise errors.NoCommits(branch)
 
924
        self.branch.fetch(branch, last_revision=merger.other_rev_id)
 
925
        merger.other_basis = merger.other_rev_id
 
926
        merger.other_tree = self.branch.repository.revision_tree(
 
927
            merger.other_rev_id)
 
928
        merger.other_branch = branch
 
929
        if from_revision is None:
 
930
            merger.find_base()
 
931
        else:
 
932
            merger.set_base_revision(from_revision, branch)
 
933
        if merger.base_rev_id == merger.other_rev_id:
 
934
            raise errors.PointlessMerge
 
935
        merger.backup_files = False
 
936
        if merge_type is None:
 
937
            merger.merge_type = Merge3Merger
 
938
        else:
 
939
            merger.merge_type = merge_type
 
940
        merger.set_interesting_files(None)
 
941
        merger.show_base = False
 
942
        merger.reprocess = False
 
943
        conflicts = merger.do_merge()
 
944
        merger.set_pending()
926
945
        return conflicts
927
946
 
928
947
    @needs_read_lock
969
988
        return file_id
970
989
 
971
990
    def get_symlink_target(self, file_id):
972
 
        return os.readlink(self.id2abspath(file_id).encode(osutils._fs_enc))
 
991
        abspath = self.id2abspath(file_id)
 
992
        target = osutils.readlink(abspath)
 
993
        return target
973
994
 
974
995
    @needs_write_lock
975
996
    def subsume(self, other_tree):
1073
1094
        tree_transport = self.bzrdir.root_transport.clone(sub_path)
1074
1095
        if tree_transport.base != branch_transport.base:
1075
1096
            tree_bzrdir = format.initialize_on_transport(tree_transport)
1076
 
            branch.BranchReferenceFormat().initialize(tree_bzrdir, new_branch)
 
1097
            branch.BranchReferenceFormat().initialize(tree_bzrdir,
 
1098
                target_branch=new_branch)
1077
1099
        else:
1078
1100
            tree_bzrdir = branch_bzrdir
1079
 
        wt = tree_bzrdir.create_workingtree(NULL_REVISION)
 
1101
        wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
1080
1102
        wt.set_parent_ids(self.get_parent_ids())
1081
1103
        my_inv = self.inventory
1082
 
        child_inv = Inventory(root_id=None)
 
1104
        child_inv = inventory.Inventory(root_id=None)
1083
1105
        new_root = my_inv[file_id]
1084
1106
        my_inv.remove_recursive_id(file_id)
1085
1107
        new_root.parent_id = None
1110
1132
    def _kind(self, relpath):
1111
1133
        return osutils.file_kind(self.abspath(relpath))
1112
1134
 
1113
 
    def list_files(self, include_root=False):
1114
 
        """Recursively list all files as (path, class, kind, id, entry).
 
1135
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
1136
        """List all files as (path, class, kind, id, entry).
1115
1137
 
1116
1138
        Lists, but does not descend into unversioned directories.
1117
 
 
1118
1139
        This does not include files that have been deleted in this
1119
 
        tree.
 
1140
        tree. Skips the control directory.
1120
1141
 
1121
 
        Skips the control directory.
 
1142
        :param include_root: if True, return an entry for the root
 
1143
        :param from_dir: start from this directory or None for the root
 
1144
        :param recursive: whether to recurse into subdirectories or not
1122
1145
        """
1123
1146
        # list_files is an iterator, so @needs_read_lock doesn't work properly
1124
1147
        # with it. So callers should be careful to always read_lock the tree.
1126
1149
            raise errors.ObjectNotLocked(self)
1127
1150
 
1128
1151
        inv = self.inventory
1129
 
        if include_root is True:
 
1152
        if from_dir is None and include_root is True:
1130
1153
            yield ('', 'V', 'directory', inv.root.file_id, inv.root)
1131
1154
        # Convert these into local objects to save lookup times
1132
1155
        pathjoin = osutils.pathjoin
1139
1162
        fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
1140
1163
 
1141
1164
        # directory file_id, relative path, absolute path, reverse sorted children
1142
 
        children = os.listdir(self.basedir)
 
1165
        if from_dir is not None:
 
1166
            from_dir_id = inv.path2id(from_dir)
 
1167
            if from_dir_id is None:
 
1168
                # Directory not versioned
 
1169
                return
 
1170
            from_dir_abspath = pathjoin(self.basedir, from_dir)
 
1171
        else:
 
1172
            from_dir_id = inv.root.file_id
 
1173
            from_dir_abspath = self.basedir
 
1174
        children = os.listdir(from_dir_abspath)
1143
1175
        children.sort()
1144
1176
        # jam 20060527 The kernel sized tree seems equivalent whether we
1145
1177
        # use a deque and popleft to keep them sorted, or if we use a plain
1146
1178
        # list and just reverse() them.
1147
1179
        children = collections.deque(children)
1148
 
        stack = [(inv.root.file_id, u'', self.basedir, children)]
 
1180
        stack = [(from_dir_id, u'', from_dir_abspath, children)]
1149
1181
        while stack:
1150
1182
            from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
1151
1183
 
1209
1241
                if fk != 'directory':
1210
1242
                    continue
1211
1243
 
1212
 
                # But do this child first
1213
 
                new_children = os.listdir(fap)
1214
 
                new_children.sort()
1215
 
                new_children = collections.deque(new_children)
1216
 
                stack.append((f_ie.file_id, fp, fap, new_children))
1217
 
                # Break out of inner loop,
1218
 
                # so that we start outer loop with child
1219
 
                break
 
1244
                # But do this child first if recursing down
 
1245
                if recursive:
 
1246
                    new_children = os.listdir(fap)
 
1247
                    new_children.sort()
 
1248
                    new_children = collections.deque(new_children)
 
1249
                    stack.append((f_ie.file_id, fp, fap, new_children))
 
1250
                    # Break out of inner loop,
 
1251
                    # so that we start outer loop with child
 
1252
                    break
1220
1253
            else:
1221
1254
                # if we finished all children, pop it off the stack
1222
1255
                stack.pop()
1400
1433
        inv = self.inventory
1401
1434
        for entry in moved:
1402
1435
            try:
1403
 
                self._move_entry(_RenameEntry(entry.to_rel, entry.from_id,
 
1436
                self._move_entry(WorkingTree._RenameEntry(
 
1437
                    entry.to_rel, entry.from_id,
1404
1438
                    entry.to_tail, entry.to_parent_id, entry.from_rel,
1405
1439
                    entry.from_tail, entry.from_parent_id,
1406
1440
                    entry.only_change_inv))
1457
1491
        from_tail = splitpath(from_rel)[-1]
1458
1492
        from_id = inv.path2id(from_rel)
1459
1493
        if from_id is None:
1460
 
            raise errors.BzrRenameFailedError(from_rel,to_rel,
1461
 
                errors.NotVersionedError(path=str(from_rel)))
1462
 
        from_entry = inv[from_id]
 
1494
            # if file is missing in the inventory maybe it's in the basis_tree
 
1495
            basis_tree = self.branch.basis_tree()
 
1496
            from_id = basis_tree.path2id(from_rel)
 
1497
            if from_id is None:
 
1498
                raise errors.BzrRenameFailedError(from_rel,to_rel,
 
1499
                    errors.NotVersionedError(path=str(from_rel)))
 
1500
            # put entry back in the inventory so we can rename it
 
1501
            from_entry = basis_tree.inventory[from_id].copy()
 
1502
            inv.add(from_entry)
 
1503
        else:
 
1504
            from_entry = inv[from_id]
1463
1505
        from_parent_id = from_entry.parent_id
1464
1506
        to_dir, to_tail = os.path.split(to_rel)
1465
1507
        to_dir_id = inv.path2id(to_dir)
1527
1569
        :raises: NoSuchId if any fileid is not currently versioned.
1528
1570
        """
1529
1571
        for file_id in file_ids:
 
1572
            if file_id not in self._inventory:
 
1573
                raise errors.NoSuchId(self, file_id)
 
1574
        for file_id in file_ids:
1530
1575
            if self._inventory.has_id(file_id):
1531
1576
                self._inventory.remove_recursive_id(file_id)
1532
 
            else:
1533
 
                raise errors.NoSuchId(self, file_id)
1534
1577
        if len(file_ids):
1535
1578
            # in the future this should just set a dirty bit to wait for the
1536
1579
            # final unlock. However, until all methods of workingtree start
1555
1598
 
1556
1599
    @needs_write_lock
1557
1600
    def pull(self, source, overwrite=False, stop_revision=None,
1558
 
             change_reporter=None, possible_transports=None):
1559
 
        top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1601
             change_reporter=None, possible_transports=None, local=False):
1560
1602
        source.lock_read()
1561
1603
        try:
1562
 
            pp = ProgressPhase("Pull phase", 2, top_pb)
1563
 
            pp.next_phase()
1564
1604
            old_revision_info = self.branch.last_revision_info()
1565
1605
            basis_tree = self.basis_tree()
1566
1606
            count = self.branch.pull(source, overwrite, stop_revision,
1567
 
                                     possible_transports=possible_transports)
 
1607
                                     possible_transports=possible_transports,
 
1608
                                     local=local)
1568
1609
            new_revision_info = self.branch.last_revision_info()
1569
1610
            if new_revision_info != old_revision_info:
1570
 
                pp.next_phase()
1571
1611
                repository = self.branch.repository
1572
 
                pb = bzrlib.ui.ui_factory.nested_progress_bar()
1573
1612
                basis_tree.lock_read()
1574
1613
                try:
1575
1614
                    new_basis_tree = self.branch.basis_tree()
1578
1617
                                new_basis_tree,
1579
1618
                                basis_tree,
1580
1619
                                this_tree=self,
1581
 
                                pb=pb,
 
1620
                                pb=None,
1582
1621
                                change_reporter=change_reporter)
1583
 
                    if (basis_tree.inventory.root is None and
1584
 
                        new_basis_tree.inventory.root is not None):
1585
 
                        self.set_root_id(new_basis_tree.get_root_id())
 
1622
                    basis_root_id = basis_tree.get_root_id()
 
1623
                    new_root_id = new_basis_tree.get_root_id()
 
1624
                    if basis_root_id != new_root_id:
 
1625
                        self.set_root_id(new_root_id)
1586
1626
                finally:
1587
 
                    pb.finished()
1588
1627
                    basis_tree.unlock()
1589
1628
                # TODO - dedup parents list with things merged by pull ?
1590
1629
                # reuse the revisiontree we merged against to set the new
1603
1642
            return count
1604
1643
        finally:
1605
1644
            source.unlock()
1606
 
            top_pb.finished()
1607
1645
 
1608
1646
    @needs_write_lock
1609
1647
    def put_file_bytes_non_atomic(self, file_id, bytes):
1635
1673
 
1636
1674
            fl = []
1637
1675
            for subf in os.listdir(dirabs):
1638
 
                if subf == '.bzr':
 
1676
                if self.bzrdir.is_control_filename(subf):
1639
1677
                    continue
1640
1678
                if subf not in dir_entry.children:
1641
1679
                    try:
1694
1732
        r"""Check whether the filename matches an ignore pattern.
1695
1733
 
1696
1734
        Patterns containing '/' or '\' need to match the whole path;
1697
 
        others match against only the last component.
 
1735
        others match against only the last component.  Patterns starting
 
1736
        with '!' are ignore exceptions.  Exceptions take precedence
 
1737
        over regular patterns and cause the filename to not be ignored.
1698
1738
 
1699
1739
        If the file is ignored, returns the pattern which caused it to
1700
1740
        be ignored, otherwise None.  So this can simply be used as a
1701
1741
        boolean if desired."""
1702
1742
        if getattr(self, '_ignoreglobster', None) is None:
1703
 
            self._ignoreglobster = globbing.Globster(self.get_ignore_list())
 
1743
            self._ignoreglobster = globbing.ExceptionGlobster(self.get_ignore_list())
1704
1744
        return self._ignoreglobster.match(filename)
1705
1745
 
1706
1746
    def kind(self, file_id):
1797
1837
    def _reset_data(self):
1798
1838
        """Reset transient data that cannot be revalidated."""
1799
1839
        self._inventory_is_modified = False
1800
 
        result = self._deserialize(self._transport.get('inventory'))
 
1840
        f = self._transport.get('inventory')
 
1841
        try:
 
1842
            result = self._deserialize(f)
 
1843
        finally:
 
1844
            f.close()
1801
1845
        self._set_inventory(result, dirty=False)
1802
1846
 
1803
1847
    @needs_tree_write_lock
1850
1894
            # revision_id is set. We must check for this full string, because a
1851
1895
            # root node id can legitimately look like 'revision_id' but cannot
1852
1896
            # contain a '"'.
1853
 
            xml = self.branch.repository.get_inventory_xml(new_revision)
 
1897
            xml = self.branch.repository._get_inventory_xml(new_revision)
1854
1898
            firstline = xml.split('\n', 1)[0]
1855
1899
            if (not 'revision_id="' in firstline or
1856
1900
                'format="7"' not in firstline):
1857
 
                inv = self.branch.repository.deserialise_inventory(
1858
 
                    new_revision, xml)
 
1901
                inv = self.branch.repository._serializer.read_inventory_from_string(
 
1902
                    xml, new_revision)
1859
1903
                xml = self._create_basis_xml_from_inventory(new_revision, inv)
1860
1904
            self._write_basis_inventory(xml)
1861
1905
        except (errors.NoSuchRevision, errors.RevisionNotPresent):
1879
1923
        # binary.
1880
1924
        if self._inventory_is_modified:
1881
1925
            raise errors.InventoryModified(self)
1882
 
        result = self._deserialize(self._transport.get('inventory'))
 
1926
        f = self._transport.get('inventory')
 
1927
        try:
 
1928
            result = self._deserialize(f)
 
1929
        finally:
 
1930
            f.close()
1883
1931
        self._set_inventory(result, dirty=False)
1884
1932
        return result
1885
1933
 
1900
1948
 
1901
1949
        new_files=set()
1902
1950
        unknown_nested_files=set()
 
1951
        if to_file is None:
 
1952
            to_file = sys.stdout
1903
1953
 
1904
1954
        def recurse_directory_to_add_files(directory):
1905
1955
            # Recurse directory and add all files
1961
2011
                        tree_delta.unversioned.extend((unknown_file,))
1962
2012
                raise errors.BzrRemoveChangedFilesError(tree_delta)
1963
2013
 
1964
 
        # Build inv_delta and delete files where applicaple,
 
2014
        # Build inv_delta and delete files where applicable,
1965
2015
        # do this before any modifications to inventory.
1966
2016
        for f in files:
1967
2017
            fid = self.path2id(f)
1975
2025
                        new_status = 'I'
1976
2026
                    else:
1977
2027
                        new_status = '?'
1978
 
                    textui.show_status(new_status, self.kind(fid), f,
1979
 
                                       to_file=to_file)
 
2028
                    # XXX: Really should be a more abstract reporter interface
 
2029
                    kind_ch = osutils.kind_marker(self.kind(fid))
 
2030
                    to_file.write(new_status + '       ' + f + kind_ch + '\n')
1980
2031
                # Unversion file
1981
2032
                inv_delta.append((f, None, fid, None))
1982
2033
                message = "removed %s" % (f,)
2005
2056
 
2006
2057
    @needs_tree_write_lock
2007
2058
    def revert(self, filenames=None, old_tree=None, backups=True,
2008
 
               pb=DummyProgress(), report_changes=False):
 
2059
               pb=None, report_changes=False):
2009
2060
        from bzrlib.conflicts import resolve
2010
2061
        if filenames == []:
2011
2062
            filenames = None
2024
2075
            if filenames is None and len(self.get_parent_ids()) > 1:
2025
2076
                parent_trees = []
2026
2077
                last_revision = self.last_revision()
2027
 
                if last_revision != NULL_REVISION:
 
2078
                if last_revision != _mod_revision.NULL_REVISION:
2028
2079
                    if basis_tree is None:
2029
2080
                        basis_tree = self.basis_tree()
2030
2081
                        basis_tree.lock_read()
2068
2119
    def set_inventory(self, new_inventory_list):
2069
2120
        from bzrlib.inventory import (Inventory,
2070
2121
                                      InventoryDirectory,
2071
 
                                      InventoryEntry,
2072
2122
                                      InventoryFile,
2073
2123
                                      InventoryLink)
2074
2124
        inv = Inventory(self.get_root_id())
2134
2184
        """
2135
2185
        raise NotImplementedError(self.unlock)
2136
2186
 
2137
 
    def update(self, change_reporter=None, possible_transports=None):
 
2187
    _marker = object()
 
2188
 
 
2189
    def update(self, change_reporter=None, possible_transports=None,
 
2190
               revision=None, old_tip=_marker):
2138
2191
        """Update a working tree along its branch.
2139
2192
 
2140
2193
        This will update the branch if its bound too, which means we have
2158
2211
        - Merge current state -> basis tree of the master w.r.t. the old tree
2159
2212
          basis.
2160
2213
        - Do a 'normal' merge of the old branch basis if it is relevant.
 
2214
 
 
2215
        :param revision: The target revision to update to. Must be in the
 
2216
            revision history.
 
2217
        :param old_tip: If branch.update() has already been run, the value it
 
2218
            returned (old tip of the branch or None). _marker is used
 
2219
            otherwise.
2161
2220
        """
2162
2221
        if self.branch.get_bound_location() is not None:
2163
2222
            self.lock_write()
2164
 
            update_branch = True
 
2223
            update_branch = (old_tip is self._marker)
2165
2224
        else:
2166
2225
            self.lock_tree_write()
2167
2226
            update_branch = False
2169
2228
            if update_branch:
2170
2229
                old_tip = self.branch.update(possible_transports)
2171
2230
            else:
2172
 
                old_tip = None
2173
 
            return self._update_tree(old_tip, change_reporter)
 
2231
                if old_tip is self._marker:
 
2232
                    old_tip = None
 
2233
            return self._update_tree(old_tip, change_reporter, revision)
2174
2234
        finally:
2175
2235
            self.unlock()
2176
2236
 
2177
2237
    @needs_tree_write_lock
2178
 
    def _update_tree(self, old_tip=None, change_reporter=None):
 
2238
    def _update_tree(self, old_tip=None, change_reporter=None, revision=None):
2179
2239
        """Update a tree to the master branch.
2180
2240
 
2181
2241
        :param old_tip: if supplied, the previous tip revision the branch,
2191
2251
        # We MUST save it even if an error occurs, because otherwise the users
2192
2252
        # local work is unreferenced and will appear to have been lost.
2193
2253
        #
2194
 
        result = 0
 
2254
        nb_conflicts = 0
2195
2255
        try:
2196
2256
            last_rev = self.get_parent_ids()[0]
2197
2257
        except IndexError:
2198
2258
            last_rev = _mod_revision.NULL_REVISION
2199
 
        if last_rev != _mod_revision.ensure_null(self.branch.last_revision()):
2200
 
            # merge tree state up to new branch tip.
 
2259
        if revision is None:
 
2260
            revision = self.branch.last_revision()
 
2261
 
 
2262
        old_tip = old_tip or _mod_revision.NULL_REVISION
 
2263
 
 
2264
        if not _mod_revision.is_null(old_tip) and old_tip != last_rev:
 
2265
            # the branch we are bound to was updated
 
2266
            # merge those changes in first
 
2267
            base_tree  = self.basis_tree()
 
2268
            other_tree = self.branch.repository.revision_tree(old_tip)
 
2269
            nb_conflicts = merge.merge_inner(self.branch, other_tree,
 
2270
                                             base_tree, this_tree=self,
 
2271
                                             change_reporter=change_reporter)
 
2272
            if nb_conflicts:
 
2273
                self.add_parent_tree((old_tip, other_tree))
 
2274
                trace.note('Rerun update after fixing the conflicts.')
 
2275
                return nb_conflicts
 
2276
 
 
2277
        if last_rev != _mod_revision.ensure_null(revision):
 
2278
            # the working tree is up to date with the branch
 
2279
            # we can merge the specified revision from master
 
2280
            to_tree = self.branch.repository.revision_tree(revision)
 
2281
            to_root_id = to_tree.get_root_id()
 
2282
 
2201
2283
            basis = self.basis_tree()
2202
2284
            basis.lock_read()
2203
2285
            try:
2204
 
                to_tree = self.branch.basis_tree()
2205
 
                if basis.inventory.root is None:
2206
 
                    self.set_root_id(to_tree.get_root_id())
 
2286
                if (basis.inventory.root is None
 
2287
                    or basis.inventory.root.file_id != to_root_id):
 
2288
                    self.set_root_id(to_root_id)
2207
2289
                    self.flush()
2208
 
                result += merge.merge_inner(
2209
 
                                      self.branch,
2210
 
                                      to_tree,
2211
 
                                      basis,
2212
 
                                      this_tree=self,
2213
 
                                      change_reporter=change_reporter)
2214
2290
            finally:
2215
2291
                basis.unlock()
 
2292
 
 
2293
            # determine the branch point
 
2294
            graph = self.branch.repository.get_graph()
 
2295
            base_rev_id = graph.find_unique_lca(self.branch.last_revision(),
 
2296
                                                last_rev)
 
2297
            base_tree = self.branch.repository.revision_tree(base_rev_id)
 
2298
 
 
2299
            nb_conflicts = merge.merge_inner(self.branch, to_tree, base_tree,
 
2300
                                             this_tree=self,
 
2301
                                             change_reporter=change_reporter)
 
2302
            self.set_last_revision(revision)
2216
2303
            # TODO - dedup parents list with things merged by pull ?
2217
2304
            # reuse the tree we've updated to to set the basis:
2218
 
            parent_trees = [(self.branch.last_revision(), to_tree)]
 
2305
            parent_trees = [(revision, to_tree)]
2219
2306
            merges = self.get_parent_ids()[1:]
2220
2307
            # Ideally we ask the tree for the trees here, that way the working
2221
 
            # tree can decide whether to give us teh entire tree or give us a
 
2308
            # tree can decide whether to give us the entire tree or give us a
2222
2309
            # lazy initialised tree. dirstate for instance will have the trees
2223
2310
            # in ram already, whereas a last-revision + basis-inventory tree
2224
2311
            # will not, but also does not need them when setting parents.
2225
2312
            for parent in merges:
2226
2313
                parent_trees.append(
2227
2314
                    (parent, self.branch.repository.revision_tree(parent)))
2228
 
            if (old_tip is not None and not _mod_revision.is_null(old_tip)):
 
2315
            if not _mod_revision.is_null(old_tip):
2229
2316
                parent_trees.append(
2230
2317
                    (old_tip, self.branch.repository.revision_tree(old_tip)))
2231
2318
            self.set_parent_trees(parent_trees)
2232
2319
            last_rev = parent_trees[0][0]
2233
 
        else:
2234
 
            # the working tree had the same last-revision as the master
2235
 
            # branch did. We may still have pivot local work from the local
2236
 
            # branch into old_tip:
2237
 
            if (old_tip is not None and not _mod_revision.is_null(old_tip)):
2238
 
                self.add_parent_tree_id(old_tip)
2239
 
        if (old_tip is not None and not _mod_revision.is_null(old_tip)
2240
 
            and old_tip != last_rev):
2241
 
            # our last revision was not the prior branch last revision
2242
 
            # and we have converted that last revision to a pending merge.
2243
 
            # base is somewhere between the branch tip now
2244
 
            # and the now pending merge
2245
 
 
2246
 
            # Since we just modified the working tree and inventory, flush out
2247
 
            # the current state, before we modify it again.
2248
 
            # TODO: jam 20070214 WorkingTree3 doesn't require this, dirstate
2249
 
            #       requires it only because TreeTransform directly munges the
2250
 
            #       inventory and calls tree._write_inventory(). Ultimately we
2251
 
            #       should be able to remove this extra flush.
2252
 
            self.flush()
2253
 
            graph = self.branch.repository.get_graph()
2254
 
            base_rev_id = graph.find_unique_lca(self.branch.last_revision(),
2255
 
                                                old_tip)
2256
 
            base_tree = self.branch.repository.revision_tree(base_rev_id)
2257
 
            other_tree = self.branch.repository.revision_tree(old_tip)
2258
 
            result += merge.merge_inner(
2259
 
                                  self.branch,
2260
 
                                  other_tree,
2261
 
                                  base_tree,
2262
 
                                  this_tree=self,
2263
 
                                  change_reporter=change_reporter)
2264
 
        return result
 
2320
        return nb_conflicts
2265
2321
 
2266
2322
    def _write_hashcache_if_dirty(self):
2267
2323
        """Write out the hashcache if it is dirty."""
2367
2423
                    bzrdir_loc = bisect_left(cur_disk_dir_content,
2368
2424
                        ('.bzr', '.bzr'))
2369
2425
                    if (bzrdir_loc < len(cur_disk_dir_content)
2370
 
                        and cur_disk_dir_content[bzrdir_loc][0] == '.bzr'):
 
2426
                        and self.bzrdir.is_control_filename(
 
2427
                            cur_disk_dir_content[bzrdir_loc][0])):
2371
2428
                        # we dont yield the contents of, or, .bzr itself.
2372
2429
                        del cur_disk_dir_content[bzrdir_loc]
2373
2430
            if inv_finished:
2507
2564
        return un_resolved, resolved
2508
2565
 
2509
2566
    @needs_read_lock
2510
 
    def _check(self):
 
2567
    def _check(self, references):
 
2568
        """Check the tree for consistency.
 
2569
 
 
2570
        :param references: A dict with keys matching the items returned by
 
2571
            self._get_check_refs(), and values from looking those keys up in
 
2572
            the repository.
 
2573
        """
2511
2574
        tree_basis = self.basis_tree()
2512
2575
        tree_basis.lock_read()
2513
2576
        try:
2514
 
            repo_basis = self.branch.repository.revision_tree(
2515
 
                self.last_revision())
 
2577
            repo_basis = references[('trees', self.last_revision())]
2516
2578
            if len(list(repo_basis.iter_changes(tree_basis))) > 0:
2517
2579
                raise errors.BzrCheckError(
2518
2580
                    "Mismatched basis inventory content.")
2531
2593
        """
2532
2594
        return
2533
2595
 
2534
 
    @needs_read_lock
2535
2596
    def _get_rules_searcher(self, default_searcher):
2536
2597
        """See Tree._get_rules_searcher."""
2537
2598
        if self._rules_searcher is None:
2564
2625
        if self._inventory is None:
2565
2626
            self.read_working_inventory()
2566
2627
 
 
2628
    def _get_check_refs(self):
 
2629
        """Return the references needed to perform a check of this tree."""
 
2630
        return [('trees', self.last_revision())]
 
2631
 
2567
2632
    def lock_tree_write(self):
2568
2633
        """See WorkingTree.lock_tree_write().
2569
2634
 
2615
2680
 
2616
2681
    def _change_last_revision(self, revision_id):
2617
2682
        """See WorkingTree._change_last_revision."""
2618
 
        if revision_id is None or revision_id == NULL_REVISION:
 
2683
        if revision_id is None or revision_id == _mod_revision.NULL_REVISION:
2619
2684
            try:
2620
2685
                self._transport.delete('last-revision')
2621
2686
            except errors.NoSuchFile:
2626
2691
                mode=self.bzrdir._get_file_mode())
2627
2692
            return True
2628
2693
 
 
2694
    def _get_check_refs(self):
 
2695
        """Return the references needed to perform a check of this tree."""
 
2696
        return [('trees', self.last_revision())]
 
2697
 
2629
2698
    @needs_tree_write_lock
2630
2699
    def set_conflicts(self, conflicts):
2631
2700
        self._put_rio('conflicts', conflicts.to_stanzas(),
2708
2777
        """Return the format for the working tree object in a_bzrdir."""
2709
2778
        try:
2710
2779
            transport = a_bzrdir.get_workingtree_transport(None)
2711
 
            format_string = transport.get("format").read()
 
2780
            format_string = transport.get_bytes("format")
2712
2781
            return klass._formats[format_string]
2713
2782
        except errors.NoSuchFile:
2714
2783
            raise errors.NoWorkingTree(base=transport.base)
2785
2854
        no working tree.  (See bug #43064).
2786
2855
        """
2787
2856
        sio = StringIO()
2788
 
        inv = Inventory()
 
2857
        inv = inventory.Inventory()
2789
2858
        xml5.serializer_v5.write_inventory(inv, sio, working=True)
2790
2859
        sio.seek(0)
2791
2860
        transport.put_file('inventory', sio, file_mode)
2807
2876
            branch.generate_revision_history(revision_id)
2808
2877
        finally:
2809
2878
            branch.unlock()
2810
 
        inv = Inventory()
 
2879
        inv = inventory.Inventory()
2811
2880
        wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
2812
2881
                         branch,
2813
2882
                         inv,
2930
2999
            # only set an explicit root id if there is one to set.
2931
3000
            if basis_tree.inventory.root is not None:
2932
3001
                wt.set_root_id(basis_tree.get_root_id())
2933
 
            if revision_id == NULL_REVISION:
 
3002
            if revision_id == _mod_revision.NULL_REVISION:
2934
3003
                wt.set_parent_trees([])
2935
3004
            else:
2936
3005
                wt.set_parent_trees([(revision_id, basis_tree)])
2943
3012
        return wt
2944
3013
 
2945
3014
    def _initial_inventory(self):
2946
 
        return Inventory()
 
3015
        return inventory.Inventory()
2947
3016
 
2948
3017
    def __init__(self):
2949
3018
        super(WorkingTreeFormat3, self).__init__()
2978
3047
        return self.get_format_string()
2979
3048
 
2980
3049
 
2981
 
__default_format = WorkingTreeFormat4()
 
3050
__default_format = WorkingTreeFormat6()
2982
3051
WorkingTreeFormat.register_format(__default_format)
2983
3052
WorkingTreeFormat.register_format(WorkingTreeFormat5())
 
3053
WorkingTreeFormat.register_format(WorkingTreeFormat4())
2984
3054
WorkingTreeFormat.register_format(WorkingTreeFormat3())
2985
3055
WorkingTreeFormat.set_default_format(__default_format)
2986
3056
# formats which have no format string are not discoverable