← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: John Ferlito
  • Date: 2009-05-25 10:59:42 UTC
  • mto: (4665.4.1 ppa-doc)
  • mto: This revision was merged to the branch mainline in revision 4693.
  • Revision ID: johnf@inodes.org-20090525105942-5xkcbe37m1u5lp5z
Update packaging scripts to make deployment a bit easier
Update documentation for deploying to PPA

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
1
 
# Copyright (C) 2005-2010 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
48
48
import itertools
49
49
import operator
50
50
import stat
 
51
from time import time
 
52
import warnings
51
53
import re
52
54
 
53
55
import bzrlib
55
57
    branch,
56
58
    bzrdir,
57
59
    conflicts as _mod_conflicts,
 
60
    dirstate,
58
61
    errors,
59
62
    generate_ids,
60
63
    globbing,
61
 
    graph as _mod_graph,
62
64
    hashcache,
63
65
    ignores,
64
 
    inventory,
65
66
    merge,
66
67
    revision as _mod_revision,
67
68
    revisiontree,
 
69
    repository,
 
70
    textui,
68
71
    trace,
69
72
    transform,
70
73
    ui,
 
74
    urlutils,
71
75
    views,
72
76
    xml5,
 
77
    xml6,
73
78
    xml7,
74
79
    )
75
80
import bzrlib.branch
76
81
from bzrlib.transport import get_transport
 
82
import bzrlib.ui
77
83
from bzrlib.workingtree_4 import (
78
84
    WorkingTreeFormat4,
79
85
    WorkingTreeFormat5,
83
89
 
84
90
from bzrlib import symbol_versioning
85
91
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
92
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, TreeReference
86
93
from bzrlib.lockable_files import LockableFiles
87
94
from bzrlib.lockdir import LockDir
88
95
import bzrlib.mutabletree
89
96
from bzrlib.mutabletree import needs_tree_write_lock
90
97
from bzrlib import osutils
91
98
from bzrlib.osutils import (
 
99
    compact_date,
92
100
    file_kind,
93
101
    isdir,
94
102
    normpath,
95
103
    pathjoin,
 
104
    rand_chars,
96
105
    realpath,
97
106
    safe_unicode,
98
107
    splitpath,
102
111
from bzrlib.trace import mutter, note
103
112
from bzrlib.transport.local import LocalTransport
104
113
from bzrlib.progress import DummyProgress, ProgressPhase
105
 
from bzrlib.revision import CURRENT_REVISION
 
114
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
106
115
from bzrlib.rio import RioReader, rio_file, Stanza
107
 
from bzrlib.symbol_versioning import (
108
 
    deprecated_passed,
109
 
    DEPRECATED_PARAMETER,
110
 
    )
 
116
from bzrlib.symbol_versioning import (deprecated_passed,
 
117
        deprecated_method,
 
118
        deprecated_function,
 
119
        DEPRECATED_PARAMETER,
 
120
        )
111
121
 
112
122
 
113
123
MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"
280
290
        self._control_files.break_lock()
281
291
        self.branch.break_lock()
282
292
 
283
 
    def _get_check_refs(self):
284
 
        """Return the references needed to perform a check of this tree.
285
 
        
286
 
        The default implementation returns no refs, and is only suitable for
287
 
        trees that have no local caching and can commit on ghosts at any time.
288
 
 
289
 
        :seealso: bzrlib.check for details about check_refs.
290
 
        """
291
 
        return []
292
 
 
293
293
    def requires_rich_root(self):
294
294
        return self._format.requires_rich_root
295
295
 
446
446
 
447
447
    def get_file_with_stat(self, file_id, path=None, filtered=True,
448
448
        _fstat=os.fstat):
449
 
        """See Tree.get_file_with_stat."""
 
449
        """See MutableTree.get_file_with_stat."""
450
450
        if path is None:
451
451
            path = self.id2path(file_id)
452
452
        file_obj = self.get_file_byname(path, filtered=False)
453
453
        stat_value = _fstat(file_obj.fileno())
454
 
        if filtered and self.supports_content_filtering():
 
454
        if self.supports_content_filtering() and filtered:
455
455
            filters = self._content_filter_stack(path)
456
456
            file_obj = filtered_input_file(file_obj, filters)
457
457
        return (file_obj, stat_value)
462
462
    def get_file_byname(self, filename, filtered=True):
463
463
        path = self.abspath(filename)
464
464
        f = file(path, 'rb')
465
 
        if filtered and self.supports_content_filtering():
 
465
        if self.supports_content_filtering() and filtered:
466
466
            filters = self._content_filter_stack(filename)
467
467
            return filtered_input_file(f, filters)
468
468
        else:
487
487
        incorrectly attributed to CURRENT_REVISION (but after committing, the
488
488
        attribution will be correct).
489
489
        """
490
 
        maybe_file_parent_keys = []
491
 
        for parent_id in self.get_parent_ids():
492
 
            try:
493
 
                parent_tree = self.revision_tree(parent_id)
494
 
            except errors.NoSuchRevisionInTree:
495
 
                parent_tree = self.branch.repository.revision_tree(parent_id)
496
 
            parent_tree.lock_read()
497
 
            try:
498
 
                if file_id not in parent_tree:
499
 
                    continue
500
 
                ie = parent_tree.inventory[file_id]
501
 
                if ie.kind != 'file':
502
 
                    # Note: this is slightly unnecessary, because symlinks and
503
 
                    # directories have a "text" which is the empty text, and we
504
 
                    # know that won't mess up annotations. But it seems cleaner
505
 
                    continue
506
 
                parent_text_key = (file_id, ie.revision)
507
 
                if parent_text_key not in maybe_file_parent_keys:
508
 
                    maybe_file_parent_keys.append(parent_text_key)
509
 
            finally:
510
 
                parent_tree.unlock()
511
 
        graph = _mod_graph.Graph(self.branch.repository.texts)
512
 
        heads = graph.heads(maybe_file_parent_keys)
513
 
        file_parent_keys = []
514
 
        for key in maybe_file_parent_keys:
515
 
            if key in heads:
516
 
                file_parent_keys.append(key)
517
 
 
518
 
        # Now we have the parents of this content
519
 
        annotator = self.branch.repository.texts.get_annotator()
520
 
        text = self.get_file(file_id).read()
521
 
        this_key =(file_id, default_revision)
522
 
        annotator.add_special_text(this_key, file_parent_keys, text)
523
 
        annotations = [(key[-1], line)
524
 
                       for key, line in annotator.annotate_flat(this_key)]
525
 
        return annotations
 
490
        basis = self.basis_tree()
 
491
        basis.lock_read()
 
492
        try:
 
493
            changes = self.iter_changes(basis, True, [self.id2path(file_id)],
 
494
                require_versioned=True).next()
 
495
            changed_content, kind = changes[2], changes[6]
 
496
            if not changed_content:
 
497
                return basis.annotate_iter(file_id)
 
498
            if kind[1] is None:
 
499
                return None
 
500
            import annotate
 
501
            if kind[0] != 'file':
 
502
                old_lines = []
 
503
            else:
 
504
                old_lines = list(basis.annotate_iter(file_id))
 
505
            old = [old_lines]
 
506
            for tree in self.branch.repository.revision_trees(
 
507
                self.get_parent_ids()[1:]):
 
508
                if file_id not in tree:
 
509
                    continue
 
510
                old.append(list(tree.annotate_iter(file_id)))
 
511
            return annotate.reannotate(old, self.get_file(file_id).readlines(),
 
512
                                       default_revision)
 
513
        finally:
 
514
            basis.unlock()
526
515
 
527
516
    def _get_ancestors(self, default_revision):
528
517
        ancestors = set([default_revision])
543
532
        else:
544
533
            parents = [last_rev]
545
534
        try:
546
 
            merges_bytes = self._transport.get_bytes('pending-merges')
 
535
            merges_file = self._transport.get('pending-merges')
547
536
        except errors.NoSuchFile:
548
537
            pass
549
538
        else:
550
 
            for l in osutils.split_lines(merges_bytes):
 
539
            for l in merges_file.readlines():
551
540
                revision_id = l.rstrip('\n')
552
541
                parents.append(revision_id)
553
542
        return parents
612
601
 
613
602
    def get_file_size(self, file_id):
614
603
        """See Tree.get_file_size"""
615
 
        # XXX: this returns the on-disk size; it should probably return the
616
 
        # canonical size
617
604
        try:
618
605
            return os.path.getsize(self.id2abspath(file_id))
619
606
        except OSError, e:
635
622
 
636
623
    def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
637
624
        file_id = self.path2id(path)
638
 
        if file_id is None:
639
 
            # For unversioned files on win32, we just assume they are not
640
 
            # executable
641
 
            return False
642
625
        return self._inventory[file_id].executable
643
626
 
644
627
    def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
754
737
            raise
755
738
        kind = _mapper(stat_result.st_mode)
756
739
        if kind == 'file':
757
 
            return self._file_content_summary(path, stat_result)
 
740
            size = stat_result.st_size
 
741
            # try for a stat cache lookup
 
742
            executable = self._is_executable_from_path_and_stat(path, stat_result)
 
743
            return (kind, size, executable, self._sha_from_stat(
 
744
                path, stat_result))
758
745
        elif kind == 'directory':
759
746
            # perhaps it looks like a plain directory, but it's really a
760
747
            # reference.
767
754
        else:
768
755
            return (kind, None, None, None)
769
756
 
770
 
    def _file_content_summary(self, path, stat_result):
771
 
        size = stat_result.st_size
772
 
        executable = self._is_executable_from_path_and_stat(path, stat_result)
773
 
        # try for a stat cache lookup
774
 
        return ('file', size, executable, self._sha_from_stat(
775
 
            path, stat_result))
776
 
 
777
757
    def _check_parents_for_ghosts(self, revision_ids, allow_leftmost_as_ghost):
778
758
        """Common ghost checking functionality from set_parent_*.
779
759
 
899
879
 
900
880
    @needs_write_lock # because merge pulls data into the branch.
901
881
    def merge_from_branch(self, branch, to_revision=None, from_revision=None,
902
 
                          merge_type=None, force=False):
 
882
        merge_type=None):
903
883
        """Merge from a branch into this working tree.
904
884
 
905
885
        :param branch: The branch to merge from.
909
889
            branch.last_revision().
910
890
        """
911
891
        from bzrlib.merge import Merger, Merge3Merger
912
 
        pb = ui.ui_factory.nested_progress_bar()
 
892
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
913
893
        try:
914
894
            merger = Merger(self.branch, this_tree=self, pb=pb)
915
895
            merger.pp = ProgressPhase("Merge phase", 5, pb)
916
896
            merger.pp.next_phase()
917
 
            # check that there are no local alterations
918
 
            if not force and self.has_changes():
919
 
                raise errors.UncommittedChanges(self)
 
897
            # check that there are no
 
898
            # local alterations
 
899
            merger.check_basis(check_clean=True, require_commits=False)
920
900
            if to_revision is None:
921
901
                to_revision = _mod_revision.ensure_null(branch.last_revision())
922
902
            merger.other_rev_id = to_revision
1101
1081
            branch.BranchReferenceFormat().initialize(tree_bzrdir, new_branch)
1102
1082
        else:
1103
1083
            tree_bzrdir = branch_bzrdir
1104
 
        wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
 
1084
        wt = tree_bzrdir.create_workingtree(NULL_REVISION)
1105
1085
        wt.set_parent_ids(self.get_parent_ids())
1106
1086
        my_inv = self.inventory
1107
 
        child_inv = inventory.Inventory(root_id=None)
 
1087
        child_inv = Inventory(root_id=None)
1108
1088
        new_root = my_inv[file_id]
1109
1089
        my_inv.remove_recursive_id(file_id)
1110
1090
        new_root.parent_id = None
1135
1115
    def _kind(self, relpath):
1136
1116
        return osutils.file_kind(self.abspath(relpath))
1137
1117
 
1138
 
    def list_files(self, include_root=False, from_dir=None, recursive=True):
1139
 
        """List all files as (path, class, kind, id, entry).
 
1118
    def list_files(self, include_root=False):
 
1119
        """Recursively list all files as (path, class, kind, id, entry).
1140
1120
 
1141
1121
        Lists, but does not descend into unversioned directories.
 
1122
 
1142
1123
        This does not include files that have been deleted in this
1143
 
        tree. Skips the control directory.
 
1124
        tree.
1144
1125
 
1145
 
        :param include_root: if True, do not return an entry for the root
1146
 
        :param from_dir: start from this directory or None for the root
1147
 
        :param recursive: whether to recurse into subdirectories or not
 
1126
        Skips the control directory.
1148
1127
        """
1149
1128
        # list_files is an iterator, so @needs_read_lock doesn't work properly
1150
1129
        # with it. So callers should be careful to always read_lock the tree.
1152
1131
            raise errors.ObjectNotLocked(self)
1153
1132
 
1154
1133
        inv = self.inventory
1155
 
        if from_dir is None and include_root is True:
 
1134
        if include_root is True:
1156
1135
            yield ('', 'V', 'directory', inv.root.file_id, inv.root)
1157
1136
        # Convert these into local objects to save lookup times
1158
1137
        pathjoin = osutils.pathjoin
1165
1144
        fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
1166
1145
 
1167
1146
        # directory file_id, relative path, absolute path, reverse sorted children
1168
 
        if from_dir is not None:
1169
 
            from_dir_id = inv.path2id(from_dir)
1170
 
            if from_dir_id is None:
1171
 
                # Directory not versioned
1172
 
                return
1173
 
            from_dir_abspath = pathjoin(self.basedir, from_dir)
1174
 
        else:
1175
 
            from_dir_id = inv.root.file_id
1176
 
            from_dir_abspath = self.basedir
1177
 
        children = os.listdir(from_dir_abspath)
 
1147
        children = os.listdir(self.basedir)
1178
1148
        children.sort()
1179
1149
        # jam 20060527 The kernel sized tree seems equivalent whether we
1180
1150
        # use a deque and popleft to keep them sorted, or if we use a plain
1181
1151
        # list and just reverse() them.
1182
1152
        children = collections.deque(children)
1183
 
        stack = [(from_dir_id, u'', from_dir_abspath, children)]
 
1153
        stack = [(inv.root.file_id, u'', self.basedir, children)]
1184
1154
        while stack:
1185
1155
            from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
1186
1156
 
1244
1214
                if fk != 'directory':
1245
1215
                    continue
1246
1216
 
1247
 
                # But do this child first if recursing down
1248
 
                if recursive:
1249
 
                    new_children = os.listdir(fap)
1250
 
                    new_children.sort()
1251
 
                    new_children = collections.deque(new_children)
1252
 
                    stack.append((f_ie.file_id, fp, fap, new_children))
1253
 
                    # Break out of inner loop,
1254
 
                    # so that we start outer loop with child
1255
 
                    break
 
1217
                # But do this child first
 
1218
                new_children = os.listdir(fap)
 
1219
                new_children.sort()
 
1220
                new_children = collections.deque(new_children)
 
1221
                stack.append((f_ie.file_id, fp, fap, new_children))
 
1222
                # Break out of inner loop,
 
1223
                # so that we start outer loop with child
 
1224
                break
1256
1225
            else:
1257
1226
                # if we finished all children, pop it off the stack
1258
1227
                stack.pop()
1436
1405
        inv = self.inventory
1437
1406
        for entry in moved:
1438
1407
            try:
1439
 
                self._move_entry(WorkingTree._RenameEntry(
1440
 
                    entry.to_rel, entry.from_id,
 
1408
                self._move_entry(_RenameEntry(entry.to_rel, entry.from_id,
1441
1409
                    entry.to_tail, entry.to_parent_id, entry.from_rel,
1442
1410
                    entry.from_tail, entry.from_parent_id,
1443
1411
                    entry.only_change_inv))
1494
1462
        from_tail = splitpath(from_rel)[-1]
1495
1463
        from_id = inv.path2id(from_rel)
1496
1464
        if from_id is None:
1497
 
            # if file is missing in the inventory maybe it's in the basis_tree
1498
 
            basis_tree = self.branch.basis_tree()
1499
 
            from_id = basis_tree.path2id(from_rel)
1500
 
            if from_id is None:
1501
 
                raise errors.BzrRenameFailedError(from_rel,to_rel,
1502
 
                    errors.NotVersionedError(path=str(from_rel)))
1503
 
            # put entry back in the inventory so we can rename it
1504
 
            from_entry = basis_tree.inventory[from_id].copy()
1505
 
            inv.add(from_entry)
1506
 
        else:
1507
 
            from_entry = inv[from_id]
 
1465
            raise errors.BzrRenameFailedError(from_rel,to_rel,
 
1466
                errors.NotVersionedError(path=str(from_rel)))
 
1467
        from_entry = inv[from_id]
1508
1468
        from_parent_id = from_entry.parent_id
1509
1469
        to_dir, to_tail = os.path.split(to_rel)
1510
1470
        to_dir_id = inv.path2id(to_dir)
1602
1562
    @needs_write_lock
1603
1563
    def pull(self, source, overwrite=False, stop_revision=None,
1604
1564
             change_reporter=None, possible_transports=None, local=False):
1605
 
        top_pb = ui.ui_factory.nested_progress_bar()
 
1565
        top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1606
1566
        source.lock_read()
1607
1567
        try:
1608
1568
            pp = ProgressPhase("Pull phase", 2, top_pb)
1616
1576
            if new_revision_info != old_revision_info:
1617
1577
                pp.next_phase()
1618
1578
                repository = self.branch.repository
1619
 
                pb = ui.ui_factory.nested_progress_bar()
 
1579
                pb = bzrlib.ui.ui_factory.nested_progress_bar()
1620
1580
                basis_tree.lock_read()
1621
1581
                try:
1622
1582
                    new_basis_tree = self.branch.basis_tree()
1627
1587
                                this_tree=self,
1628
1588
                                pb=pb,
1629
1589
                                change_reporter=change_reporter)
1630
 
                    basis_root_id = basis_tree.get_root_id()
1631
 
                    new_root_id = new_basis_tree.get_root_id()
1632
 
                    if basis_root_id != new_root_id:
1633
 
                        self.set_root_id(new_root_id)
 
1590
                    if (basis_tree.inventory.root is None and
 
1591
                        new_basis_tree.inventory.root is not None):
 
1592
                        self.set_root_id(new_basis_tree.get_root_id())
1634
1593
                finally:
1635
1594
                    pb.finished()
1636
1595
                    basis_tree.unlock()
1742
1701
        r"""Check whether the filename matches an ignore pattern.
1743
1702
 
1744
1703
        Patterns containing '/' or '\' need to match the whole path;
1745
 
        others match against only the last component.  Patterns starting
1746
 
        with '!' are ignore exceptions.  Exceptions take precedence
1747
 
        over regular patterns and cause the filename to not be ignored.
 
1704
        others match against only the last component.
1748
1705
 
1749
1706
        If the file is ignored, returns the pattern which caused it to
1750
1707
        be ignored, otherwise None.  So this can simply be used as a
1751
1708
        boolean if desired."""
1752
1709
        if getattr(self, '_ignoreglobster', None) is None:
1753
 
            self._ignoreglobster = globbing.ExceptionGlobster(self.get_ignore_list())
 
1710
            self._ignoreglobster = globbing.Globster(self.get_ignore_list())
1754
1711
        return self._ignoreglobster.match(filename)
1755
1712
 
1756
1713
    def kind(self, file_id):
1847
1804
    def _reset_data(self):
1848
1805
        """Reset transient data that cannot be revalidated."""
1849
1806
        self._inventory_is_modified = False
1850
 
        f = self._transport.get('inventory')
1851
 
        try:
1852
 
            result = self._deserialize(f)
1853
 
        finally:
1854
 
            f.close()
 
1807
        result = self._deserialize(self._transport.get('inventory'))
1855
1808
        self._set_inventory(result, dirty=False)
1856
1809
 
1857
1810
    @needs_tree_write_lock
1904
1857
            # revision_id is set. We must check for this full string, because a
1905
1858
            # root node id can legitimately look like 'revision_id' but cannot
1906
1859
            # contain a '"'.
1907
 
            xml = self.branch.repository._get_inventory_xml(new_revision)
 
1860
            xml = self.branch.repository.get_inventory_xml(new_revision)
1908
1861
            firstline = xml.split('\n', 1)[0]
1909
1862
            if (not 'revision_id="' in firstline or
1910
1863
                'format="7"' not in firstline):
1911
 
                inv = self.branch.repository._serializer.read_inventory_from_string(
1912
 
                    xml, new_revision)
 
1864
                inv = self.branch.repository.deserialise_inventory(
 
1865
                    new_revision, xml)
1913
1866
                xml = self._create_basis_xml_from_inventory(new_revision, inv)
1914
1867
            self._write_basis_inventory(xml)
1915
1868
        except (errors.NoSuchRevision, errors.RevisionNotPresent):
1933
1886
        # binary.
1934
1887
        if self._inventory_is_modified:
1935
1888
            raise errors.InventoryModified(self)
1936
 
        f = self._transport.get('inventory')
1937
 
        try:
1938
 
            result = self._deserialize(f)
1939
 
        finally:
1940
 
            f.close()
 
1889
        result = self._deserialize(self._transport.get('inventory'))
1941
1890
        self._set_inventory(result, dirty=False)
1942
1891
        return result
1943
1892
 
1958
1907
 
1959
1908
        new_files=set()
1960
1909
        unknown_nested_files=set()
1961
 
        if to_file is None:
1962
 
            to_file = sys.stdout
1963
1910
 
1964
1911
        def recurse_directory_to_add_files(directory):
1965
1912
            # Recurse directory and add all files
2035
1982
                        new_status = 'I'
2036
1983
                    else:
2037
1984
                        new_status = '?'
2038
 
                    # XXX: Really should be a more abstract reporter interface
2039
 
                    kind_ch = osutils.kind_marker(self.kind(fid))
2040
 
                    to_file.write(new_status + '       ' + f + kind_ch + '\n')
 
1985
                    textui.show_status(new_status, self.kind(fid), f,
 
1986
                                       to_file=to_file)
2041
1987
                # Unversion file
2042
1988
                inv_delta.append((f, None, fid, None))
2043
1989
                message = "removed %s" % (f,)
2085
2031
            if filenames is None and len(self.get_parent_ids()) > 1:
2086
2032
                parent_trees = []
2087
2033
                last_revision = self.last_revision()
2088
 
                if last_revision != _mod_revision.NULL_REVISION:
 
2034
                if last_revision != NULL_REVISION:
2089
2035
                    if basis_tree is None:
2090
2036
                        basis_tree = self.basis_tree()
2091
2037
                        basis_tree.lock_read()
2129
2075
    def set_inventory(self, new_inventory_list):
2130
2076
        from bzrlib.inventory import (Inventory,
2131
2077
                                      InventoryDirectory,
 
2078
                                      InventoryEntry,
2132
2079
                                      InventoryFile,
2133
2080
                                      InventoryLink)
2134
2081
        inv = Inventory(self.get_root_id())
2194
2141
        """
2195
2142
        raise NotImplementedError(self.unlock)
2196
2143
 
2197
 
    _marker = object()
2198
 
 
2199
 
    def update(self, change_reporter=None, possible_transports=None,
2200
 
               revision=None, old_tip=_marker):
 
2144
    def update(self, change_reporter=None, possible_transports=None):
2201
2145
        """Update a working tree along its branch.
2202
2146
 
2203
2147
        This will update the branch if its bound too, which means we have
2221
2165
        - Merge current state -> basis tree of the master w.r.t. the old tree
2222
2166
          basis.
2223
2167
        - Do a 'normal' merge of the old branch basis if it is relevant.
2224
 
 
2225
 
        :param revision: The target revision to update to. Must be in the
2226
 
            revision history.
2227
 
        :param old_tip: If branch.update() has already been run, the value it
2228
 
            returned (old tip of the branch or None). _marker is used
2229
 
            otherwise.
2230
2168
        """
2231
2169
        if self.branch.get_bound_location() is not None:
2232
2170
            self.lock_write()
2233
 
            update_branch = (old_tip is self._marker)
 
2171
            update_branch = True
2234
2172
        else:
2235
2173
            self.lock_tree_write()
2236
2174
            update_branch = False
2238
2176
            if update_branch:
2239
2177
                old_tip = self.branch.update(possible_transports)
2240
2178
            else:
2241
 
                if old_tip is self._marker:
2242
 
                    old_tip = None
2243
 
            return self._update_tree(old_tip, change_reporter, revision)
 
2179
                old_tip = None
 
2180
            return self._update_tree(old_tip, change_reporter)
2244
2181
        finally:
2245
2182
            self.unlock()
2246
2183
 
2247
2184
    @needs_tree_write_lock
2248
 
    def _update_tree(self, old_tip=None, change_reporter=None, revision=None):
 
2185
    def _update_tree(self, old_tip=None, change_reporter=None):
2249
2186
        """Update a tree to the master branch.
2250
2187
 
2251
2188
        :param old_tip: if supplied, the previous tip revision the branch,
2266
2203
            last_rev = self.get_parent_ids()[0]
2267
2204
        except IndexError:
2268
2205
            last_rev = _mod_revision.NULL_REVISION
2269
 
        if revision is None:
2270
 
            revision = self.branch.last_revision()
2271
 
        else:
2272
 
            if revision not in self.branch.revision_history():
2273
 
                raise errors.NoSuchRevision(self.branch, revision)
2274
 
        if last_rev != _mod_revision.ensure_null(revision):
2275
 
            # merge tree state up to specified revision.
 
2206
        if last_rev != _mod_revision.ensure_null(self.branch.last_revision()):
 
2207
            # merge tree state up to new branch tip.
2276
2208
            basis = self.basis_tree()
2277
2209
            basis.lock_read()
2278
2210
            try:
2279
 
                to_tree = self.branch.repository.revision_tree(revision)
2280
 
                to_root_id = to_tree.get_root_id()
2281
 
                if (basis.inventory.root is None
2282
 
                    or basis.inventory.root.file_id != to_root_id):
2283
 
                    self.set_root_id(to_root_id)
 
2211
                to_tree = self.branch.basis_tree()
 
2212
                if basis.inventory.root is None:
 
2213
                    self.set_root_id(to_tree.get_root_id())
2284
2214
                    self.flush()
2285
2215
                result += merge.merge_inner(
2286
2216
                                      self.branch,
2288
2218
                                      basis,
2289
2219
                                      this_tree=self,
2290
2220
                                      change_reporter=change_reporter)
2291
 
                self.set_last_revision(revision)
2292
2221
            finally:
2293
2222
                basis.unlock()
2294
2223
            # TODO - dedup parents list with things merged by pull ?
2295
2224
            # reuse the tree we've updated to to set the basis:
2296
 
            parent_trees = [(revision, to_tree)]
 
2225
            parent_trees = [(self.branch.last_revision(), to_tree)]
2297
2226
            merges = self.get_parent_ids()[1:]
2298
2227
            # Ideally we ask the tree for the trees here, that way the working
2299
2228
            # tree can decide whether to give us the entire tree or give us a
2329
2258
            #       should be able to remove this extra flush.
2330
2259
            self.flush()
2331
2260
            graph = self.branch.repository.get_graph()
2332
 
            base_rev_id = graph.find_unique_lca(revision, old_tip)
 
2261
            base_rev_id = graph.find_unique_lca(self.branch.last_revision(),
 
2262
                                                old_tip)
2333
2263
            base_tree = self.branch.repository.revision_tree(base_rev_id)
2334
2264
            other_tree = self.branch.repository.revision_tree(old_tip)
2335
2265
            result += merge.merge_inner(
2585
2515
        return un_resolved, resolved
2586
2516
 
2587
2517
    @needs_read_lock
2588
 
    def _check(self, references):
2589
 
        """Check the tree for consistency.
2590
 
 
2591
 
        :param references: A dict with keys matching the items returned by
2592
 
            self._get_check_refs(), and values from looking those keys up in
2593
 
            the repository.
2594
 
        """
 
2518
    def _check(self):
2595
2519
        tree_basis = self.basis_tree()
2596
2520
        tree_basis.lock_read()
2597
2521
        try:
2598
 
            repo_basis = references[('trees', self.last_revision())]
 
2522
            repo_basis = self.branch.repository.revision_tree(
 
2523
                self.last_revision())
2599
2524
            if len(list(repo_basis.iter_changes(tree_basis))) > 0:
2600
2525
                raise errors.BzrCheckError(
2601
2526
                    "Mismatched basis inventory content.")
2614
2539
        """
2615
2540
        return
2616
2541
 
 
2542
    @needs_read_lock
2617
2543
    def _get_rules_searcher(self, default_searcher):
2618
2544
        """See Tree._get_rules_searcher."""
2619
2545
        if self._rules_searcher is None:
2646
2572
        if self._inventory is None:
2647
2573
            self.read_working_inventory()
2648
2574
 
2649
 
    def _get_check_refs(self):
2650
 
        """Return the references needed to perform a check of this tree."""
2651
 
        return [('trees', self.last_revision())]
2652
 
 
2653
2575
    def lock_tree_write(self):
2654
2576
        """See WorkingTree.lock_tree_write().
2655
2577
 
2701
2623
 
2702
2624
    def _change_last_revision(self, revision_id):
2703
2625
        """See WorkingTree._change_last_revision."""
2704
 
        if revision_id is None or revision_id == _mod_revision.NULL_REVISION:
 
2626
        if revision_id is None or revision_id == NULL_REVISION:
2705
2627
            try:
2706
2628
                self._transport.delete('last-revision')
2707
2629
            except errors.NoSuchFile:
2712
2634
                mode=self.bzrdir._get_file_mode())
2713
2635
            return True
2714
2636
 
2715
 
    def _get_check_refs(self):
2716
 
        """Return the references needed to perform a check of this tree."""
2717
 
        return [('trees', self.last_revision())]
2718
 
 
2719
2637
    @needs_tree_write_lock
2720
2638
    def set_conflicts(self, conflicts):
2721
2639
        self._put_rio('conflicts', conflicts.to_stanzas(),
2798
2716
        """Return the format for the working tree object in a_bzrdir."""
2799
2717
        try:
2800
2718
            transport = a_bzrdir.get_workingtree_transport(None)
2801
 
            format_string = transport.get_bytes("format")
 
2719
            format_string = transport.get("format").read()
2802
2720
            return klass._formats[format_string]
2803
2721
        except errors.NoSuchFile:
2804
2722
            raise errors.NoWorkingTree(base=transport.base)
2875
2793
        no working tree.  (See bug #43064).
2876
2794
        """
2877
2795
        sio = StringIO()
2878
 
        inv = inventory.Inventory()
 
2796
        inv = Inventory()
2879
2797
        xml5.serializer_v5.write_inventory(inv, sio, working=True)
2880
2798
        sio.seek(0)
2881
2799
        transport.put_file('inventory', sio, file_mode)
2897
2815
            branch.generate_revision_history(revision_id)
2898
2816
        finally:
2899
2817
            branch.unlock()
2900
 
        inv = inventory.Inventory()
 
2818
        inv = Inventory()
2901
2819
        wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
2902
2820
                         branch,
2903
2821
                         inv,
3020
2938
            # only set an explicit root id if there is one to set.
3021
2939
            if basis_tree.inventory.root is not None:
3022
2940
                wt.set_root_id(basis_tree.get_root_id())
3023
 
            if revision_id == _mod_revision.NULL_REVISION:
 
2941
            if revision_id == NULL_REVISION:
3024
2942
                wt.set_parent_trees([])
3025
2943
            else:
3026
2944
                wt.set_parent_trees([(revision_id, basis_tree)])
3033
2951
        return wt
3034
2952
 
3035
2953
    def _initial_inventory(self):
3036
 
        return inventory.Inventory()
 
2954
        return Inventory()
3037
2955
 
3038
2956
    def __init__(self):
3039
2957
        super(WorkingTreeFormat3, self).__init__()
3068
2986
        return self.get_format_string()
3069
2987
 
3070
2988
 
3071
 
__default_format = WorkingTreeFormat6()
 
2989
__default_format = WorkingTreeFormat4()
3072
2990
WorkingTreeFormat.register_format(__default_format)
 
2991
WorkingTreeFormat.register_format(WorkingTreeFormat6())
3073
2992
WorkingTreeFormat.register_format(WorkingTreeFormat5())
3074
 
WorkingTreeFormat.register_format(WorkingTreeFormat4())
3075
2993
WorkingTreeFormat.register_format(WorkingTreeFormat3())
3076
2994
WorkingTreeFormat.set_default_format(__default_format)
3077
2995
# formats which have no format string are not discoverable