← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-08-20 05:20:56 UTC
  • mfrom: (5380.3.3 doc)
  • Revision ID: pqm@pqm.ubuntu.com-20100820052056-gwad7dz2otckrjax
(mbp) Start whatsnew for 2.3; update ppa developer docs (Martin Pool)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008, 2009 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
29
29
WorkingTree.open(dir).
30
30
"""
31
31
 
32
 
# TODO: Give the workingtree sole responsibility for the working inventory;
33
 
# remove the variable and references to it from the branch.  This may require
34
 
# updating the commit code so as to update the inventory within the working
35
 
# copy, and making sure there's only one WorkingTree for any directory on disk.
36
 
# At the moment they may alias the inventory and have old copies of it in
37
 
# memory.  (Now done? -- mbp 20060309)
38
32
 
39
33
from cStringIO import StringIO
40
34
import os
65
59
    merge,
66
60
    revision as _mod_revision,
67
61
    revisiontree,
68
 
    textui,
69
62
    trace,
70
63
    transform,
 
64
    transport,
71
65
    ui,
72
66
    views,
73
67
    xml5,
74
68
    xml7,
75
69
    )
76
 
import bzrlib.branch
77
 
from bzrlib.transport import get_transport
78
70
from bzrlib.workingtree_4 import (
79
71
    WorkingTreeFormat4,
80
72
    WorkingTreeFormat5,
84
76
 
85
77
from bzrlib import symbol_versioning
86
78
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
79
from bzrlib.lock import LogicalLockResult
87
80
from bzrlib.lockable_files import LockableFiles
88
81
from bzrlib.lockdir import LockDir
89
82
import bzrlib.mutabletree
102
95
from bzrlib.filters import filtered_input_file
103
96
from bzrlib.trace import mutter, note
104
97
from bzrlib.transport.local import LocalTransport
105
 
from bzrlib.progress import DummyProgress, ProgressPhase
106
98
from bzrlib.revision import CURRENT_REVISION
107
99
from bzrlib.rio import RioReader, rio_file, Stanza
108
100
from bzrlib.symbol_versioning import (
112
104
 
113
105
 
114
106
MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"
 
107
# TODO: Modifying the conflict objects or their type is currently nearly
 
108
# impossible as there is no clear relationship between the working tree format
 
109
# and the conflict list file format.
115
110
CONFLICT_HEADER_1 = "BZR conflict list format 1"
116
111
 
117
112
ERROR_PATH_NOT_FOUND = 3    # WindowsError errno code, equivalent to ENOENT
172
167
        return ''
173
168
 
174
169
 
175
 
class WorkingTree(bzrlib.mutabletree.MutableTree):
 
170
class WorkingTree(bzrlib.mutabletree.MutableTree,
 
171
    bzrdir.ControlComponent):
176
172
    """Working copy tree.
177
173
 
178
174
    The inventory is held in the `Branch` working-inventory, and the
180
176
 
181
177
    It is possible for a `WorkingTree` to have a filename which is
182
178
    not listed in the Inventory and vice versa.
 
179
 
 
180
    :ivar basedir: The root of the tree on disk. This is a unicode path object
 
181
        (as opposed to a URL).
183
182
    """
184
183
 
185
184
    # override this to set the strategy for storing views
251
250
        self._rules_searcher = None
252
251
        self.views = self._make_views()
253
252
 
 
253
    @property
 
254
    def user_transport(self):
 
255
        return self.bzrdir.user_transport
 
256
 
 
257
    @property
 
258
    def control_transport(self):
 
259
        return self._transport
 
260
 
254
261
    def _detect_case_handling(self):
255
262
        wt_trans = self.bzrdir.get_workingtree_transport(None)
256
263
        try:
342
349
        if path is None:
343
350
            path = osutils.getcwd()
344
351
        control, relpath = bzrdir.BzrDir.open_containing(path)
345
 
 
346
352
        return control.open_workingtree(), relpath
347
353
 
348
354
    @staticmethod
 
355
    def open_containing_paths(file_list, default_directory='.',
 
356
        canonicalize=True, apply_view=True):
 
357
        """Open the WorkingTree that contains a set of paths.
 
358
 
 
359
        Fail if the paths given are not all in a single tree.
 
360
 
 
361
        This is used for the many command-line interfaces that take a list of
 
362
        any number of files and that require they all be in the same tree.
 
363
        """
 
364
        # recommended replacement for builtins.internal_tree_files
 
365
        if file_list is None or len(file_list) == 0:
 
366
            tree = WorkingTree.open_containing(default_directory)[0]
 
367
            # XXX: doesn't really belong here, and seems to have the strange
 
368
            # side effect of making it return a bunch of files, not the whole
 
369
            # tree -- mbp 20100716
 
370
            if tree.supports_views() and apply_view:
 
371
                view_files = tree.views.lookup_view()
 
372
                if view_files:
 
373
                    file_list = view_files
 
374
                    view_str = views.view_display_str(view_files)
 
375
                    note("Ignoring files outside view. View is %s" % view_str)
 
376
            return tree, file_list
 
377
        tree = WorkingTree.open_containing(file_list[0])[0]
 
378
        return tree, tree.safe_relpath_files(file_list, canonicalize,
 
379
            apply_view=apply_view)
 
380
 
 
381
    def safe_relpath_files(self, file_list, canonicalize=True, apply_view=True):
 
382
        """Convert file_list into a list of relpaths in tree.
 
383
 
 
384
        :param self: A tree to operate on.
 
385
        :param file_list: A list of user provided paths or None.
 
386
        :param apply_view: if True and a view is set, apply it or check that
 
387
            specified files are within it
 
388
        :return: A list of relative paths.
 
389
        :raises errors.PathNotChild: When a provided path is in a different self
 
390
            than self.
 
391
        """
 
392
        if file_list is None:
 
393
            return None
 
394
        if self.supports_views() and apply_view:
 
395
            view_files = self.views.lookup_view()
 
396
        else:
 
397
            view_files = []
 
398
        new_list = []
 
399
        # self.relpath exists as a "thunk" to osutils, but canonical_relpath
 
400
        # doesn't - fix that up here before we enter the loop.
 
401
        if canonicalize:
 
402
            fixer = lambda p: osutils.canonical_relpath(self.basedir, p)
 
403
        else:
 
404
            fixer = self.relpath
 
405
        for filename in file_list:
 
406
            relpath = fixer(osutils.dereference_path(filename))
 
407
            if view_files and not osutils.is_inside_any(view_files, relpath):
 
408
                raise errors.FileOutsideView(filename, view_files)
 
409
            new_list.append(relpath)
 
410
        return new_list
 
411
 
 
412
    @staticmethod
349
413
    def open_downlevel(path=None):
350
414
        """Open an unsupported working tree.
351
415
 
364
428
                return True, None
365
429
            else:
366
430
                return True, tree
367
 
        transport = get_transport(location)
368
 
        iterator = bzrdir.BzrDir.find_bzrdirs(transport, evaluate=evaluate,
 
431
        t = transport.get_transport(location)
 
432
        iterator = bzrdir.BzrDir.find_bzrdirs(t, evaluate=evaluate,
369
433
                                              list_current=list_current)
370
 
        return [t for t in iterator if t is not None]
 
434
        return [tr for tr in iterator if tr is not None]
371
435
 
372
436
    # should be deprecated - this is slow and in any case treating them as a
373
437
    # container is (we now know) bad style -- mbp 20070302
458
522
        return (file_obj, stat_value)
459
523
 
460
524
    def get_file_text(self, file_id, path=None, filtered=True):
461
 
        return self.get_file(file_id, path=path, filtered=filtered).read()
 
525
        my_file = self.get_file(file_id, path=path, filtered=filtered)
 
526
        try:
 
527
            return my_file.read()
 
528
        finally:
 
529
            my_file.close()
462
530
 
463
531
    def get_file_byname(self, filename, filtered=True):
464
532
        path = self.abspath(filename)
518
586
 
519
587
        # Now we have the parents of this content
520
588
        annotator = self.branch.repository.texts.get_annotator()
521
 
        text = self.get_file(file_id).read()
 
589
        text = self.get_file_text(file_id)
522
590
        this_key =(file_id, default_revision)
523
591
        annotator.add_special_text(this_key, file_parent_keys, text)
524
592
        annotations = [(key[-1], line)
544
612
        else:
545
613
            parents = [last_rev]
546
614
        try:
547
 
            merges_file = self._transport.get('pending-merges')
 
615
            merges_bytes = self._transport.get_bytes('pending-merges')
548
616
        except errors.NoSuchFile:
549
617
            pass
550
618
        else:
551
 
            for l in merges_file.readlines():
 
619
            for l in osutils.split_lines(merges_bytes):
552
620
                revision_id = l.rstrip('\n')
553
621
                parents.append(revision_id)
554
622
        return parents
613
681
 
614
682
    def get_file_size(self, file_id):
615
683
        """See Tree.get_file_size"""
 
684
        # XXX: this returns the on-disk size; it should probably return the
 
685
        # canonical size
616
686
        try:
617
687
            return os.path.getsize(self.id2abspath(file_id))
618
688
        except OSError, e:
634
704
 
635
705
    def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
636
706
        file_id = self.path2id(path)
 
707
        if file_id is None:
 
708
            # For unversioned files on win32, we just assume they are not
 
709
            # executable
 
710
            return False
637
711
        return self._inventory[file_id].executable
638
712
 
639
713
    def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
749
823
            raise
750
824
        kind = _mapper(stat_result.st_mode)
751
825
        if kind == 'file':
752
 
            size = stat_result.st_size
753
 
            # try for a stat cache lookup
754
 
            executable = self._is_executable_from_path_and_stat(path, stat_result)
755
 
            return (kind, size, executable, self._sha_from_stat(
756
 
                path, stat_result))
 
826
            return self._file_content_summary(path, stat_result)
757
827
        elif kind == 'directory':
758
828
            # perhaps it looks like a plain directory, but it's really a
759
829
            # reference.
766
836
        else:
767
837
            return (kind, None, None, None)
768
838
 
 
839
    def _file_content_summary(self, path, stat_result):
 
840
        size = stat_result.st_size
 
841
        executable = self._is_executable_from_path_and_stat(path, stat_result)
 
842
        # try for a stat cache lookup
 
843
        return ('file', size, executable, self._sha_from_stat(
 
844
            path, stat_result))
 
845
 
769
846
    def _check_parents_for_ghosts(self, revision_ids, allow_leftmost_as_ghost):
770
847
        """Common ghost checking functionality from set_parent_*.
771
848
 
891
968
 
892
969
    @needs_write_lock # because merge pulls data into the branch.
893
970
    def merge_from_branch(self, branch, to_revision=None, from_revision=None,
894
 
        merge_type=None):
 
971
                          merge_type=None, force=False):
895
972
        """Merge from a branch into this working tree.
896
973
 
897
974
        :param branch: The branch to merge from.
901
978
            branch.last_revision().
902
979
        """
903
980
        from bzrlib.merge import Merger, Merge3Merger
904
 
        pb = ui.ui_factory.nested_progress_bar()
905
 
        try:
906
 
            merger = Merger(self.branch, this_tree=self, pb=pb)
907
 
            merger.pp = ProgressPhase("Merge phase", 5, pb)
908
 
            merger.pp.next_phase()
909
 
            # check that there are no
910
 
            # local alterations
911
 
            merger.check_basis(check_clean=True, require_commits=False)
912
 
            if to_revision is None:
913
 
                to_revision = _mod_revision.ensure_null(branch.last_revision())
914
 
            merger.other_rev_id = to_revision
915
 
            if _mod_revision.is_null(merger.other_rev_id):
916
 
                raise errors.NoCommits(branch)
917
 
            self.branch.fetch(branch, last_revision=merger.other_rev_id)
918
 
            merger.other_basis = merger.other_rev_id
919
 
            merger.other_tree = self.branch.repository.revision_tree(
920
 
                merger.other_rev_id)
921
 
            merger.other_branch = branch
922
 
            merger.pp.next_phase()
923
 
            if from_revision is None:
924
 
                merger.find_base()
925
 
            else:
926
 
                merger.set_base_revision(from_revision, branch)
927
 
            if merger.base_rev_id == merger.other_rev_id:
928
 
                raise errors.PointlessMerge
929
 
            merger.backup_files = False
930
 
            if merge_type is None:
931
 
                merger.merge_type = Merge3Merger
932
 
            else:
933
 
                merger.merge_type = merge_type
934
 
            merger.set_interesting_files(None)
935
 
            merger.show_base = False
936
 
            merger.reprocess = False
937
 
            conflicts = merger.do_merge()
938
 
            merger.set_pending()
939
 
        finally:
940
 
            pb.finished()
 
981
        merger = Merger(self.branch, this_tree=self)
 
982
        # check that there are no local alterations
 
983
        if not force and self.has_changes():
 
984
            raise errors.UncommittedChanges(self)
 
985
        if to_revision is None:
 
986
            to_revision = _mod_revision.ensure_null(branch.last_revision())
 
987
        merger.other_rev_id = to_revision
 
988
        if _mod_revision.is_null(merger.other_rev_id):
 
989
            raise errors.NoCommits(branch)
 
990
        self.branch.fetch(branch, last_revision=merger.other_rev_id)
 
991
        merger.other_basis = merger.other_rev_id
 
992
        merger.other_tree = self.branch.repository.revision_tree(
 
993
            merger.other_rev_id)
 
994
        merger.other_branch = branch
 
995
        if from_revision is None:
 
996
            merger.find_base()
 
997
        else:
 
998
            merger.set_base_revision(from_revision, branch)
 
999
        if merger.base_rev_id == merger.other_rev_id:
 
1000
            raise errors.PointlessMerge
 
1001
        merger.backup_files = False
 
1002
        if merge_type is None:
 
1003
            merger.merge_type = Merge3Merger
 
1004
        else:
 
1005
            merger.merge_type = merge_type
 
1006
        merger.set_interesting_files(None)
 
1007
        merger.show_base = False
 
1008
        merger.reprocess = False
 
1009
        conflicts = merger.do_merge()
 
1010
        merger.set_pending()
941
1011
        return conflicts
942
1012
 
943
1013
    @needs_read_lock
1090
1160
        tree_transport = self.bzrdir.root_transport.clone(sub_path)
1091
1161
        if tree_transport.base != branch_transport.base:
1092
1162
            tree_bzrdir = format.initialize_on_transport(tree_transport)
1093
 
            branch.BranchReferenceFormat().initialize(tree_bzrdir, new_branch)
 
1163
            branch.BranchReferenceFormat().initialize(tree_bzrdir,
 
1164
                target_branch=new_branch)
1094
1165
        else:
1095
1166
            tree_bzrdir = branch_bzrdir
1096
1167
        wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
1134
1205
        This does not include files that have been deleted in this
1135
1206
        tree. Skips the control directory.
1136
1207
 
1137
 
        :param include_root: if True, do not return an entry for the root
 
1208
        :param include_root: if True, return an entry for the root
1138
1209
        :param from_dir: start from this directory or None for the root
1139
1210
        :param recursive: whether to recurse into subdirectories or not
1140
1211
        """
1195
1266
                # absolute path
1196
1267
                fap = from_dir_abspath + '/' + f
1197
1268
 
1198
 
                f_ie = inv.get_child(from_dir_id, f)
 
1269
                dir_ie = inv[from_dir_id]
 
1270
                if dir_ie.kind == 'directory':
 
1271
                    f_ie = dir_ie.children.get(f)
 
1272
                else:
 
1273
                    f_ie = None
1199
1274
                if f_ie:
1200
1275
                    c = 'V'
1201
1276
                elif self.is_ignored(fp[1:]):
1202
1277
                    c = 'I'
1203
1278
                else:
1204
 
                    # we may not have found this file, because of a unicode issue
 
1279
                    # we may not have found this file, because of a unicode
 
1280
                    # issue, or because the directory was actually a symlink.
1205
1281
                    f_norm, can_access = osutils.normalized_filename(f)
1206
1282
                    if f == f_norm or not can_access:
1207
1283
                        # No change, so treat this file normally
1250
1326
                stack.pop()
1251
1327
 
1252
1328
    @needs_tree_write_lock
1253
 
    def move(self, from_paths, to_dir=None, after=False, **kwargs):
 
1329
    def move(self, from_paths, to_dir=None, after=False):
1254
1330
        """Rename files.
1255
1331
 
1256
1332
        to_dir must exist in the inventory.
1290
1366
 
1291
1367
        # check for deprecated use of signature
1292
1368
        if to_dir is None:
1293
 
            to_dir = kwargs.get('to_name', None)
1294
 
            if to_dir is None:
1295
 
                raise TypeError('You must supply a target directory')
1296
 
            else:
1297
 
                symbol_versioning.warn('The parameter to_name was deprecated'
1298
 
                                       ' in version 0.13. Use to_dir instead',
1299
 
                                       DeprecationWarning)
1300
 
 
 
1369
            raise TypeError('You must supply a target directory')
1301
1370
        # check destination directory
1302
1371
        if isinstance(from_paths, basestring):
1303
1372
            raise ValueError()
1594
1663
    @needs_write_lock
1595
1664
    def pull(self, source, overwrite=False, stop_revision=None,
1596
1665
             change_reporter=None, possible_transports=None, local=False):
1597
 
        top_pb = ui.ui_factory.nested_progress_bar()
1598
1666
        source.lock_read()
1599
1667
        try:
1600
 
            pp = ProgressPhase("Pull phase", 2, top_pb)
1601
 
            pp.next_phase()
1602
1668
            old_revision_info = self.branch.last_revision_info()
1603
1669
            basis_tree = self.basis_tree()
1604
1670
            count = self.branch.pull(source, overwrite, stop_revision,
1606
1672
                                     local=local)
1607
1673
            new_revision_info = self.branch.last_revision_info()
1608
1674
            if new_revision_info != old_revision_info:
1609
 
                pp.next_phase()
1610
1675
                repository = self.branch.repository
1611
 
                pb = ui.ui_factory.nested_progress_bar()
1612
1676
                basis_tree.lock_read()
1613
1677
                try:
1614
1678
                    new_basis_tree = self.branch.basis_tree()
1617
1681
                                new_basis_tree,
1618
1682
                                basis_tree,
1619
1683
                                this_tree=self,
1620
 
                                pb=pb,
 
1684
                                pb=None,
1621
1685
                                change_reporter=change_reporter)
1622
 
                    if (basis_tree.inventory.root is None and
1623
 
                        new_basis_tree.inventory.root is not None):
1624
 
                        self.set_root_id(new_basis_tree.get_root_id())
 
1686
                    basis_root_id = basis_tree.get_root_id()
 
1687
                    new_root_id = new_basis_tree.get_root_id()
 
1688
                    if basis_root_id != new_root_id:
 
1689
                        self.set_root_id(new_root_id)
1625
1690
                finally:
1626
 
                    pb.finished()
1627
1691
                    basis_tree.unlock()
1628
1692
                # TODO - dedup parents list with things merged by pull ?
1629
1693
                # reuse the revisiontree we merged against to set the new
1642
1706
            return count
1643
1707
        finally:
1644
1708
            source.unlock()
1645
 
            top_pb.finished()
1646
1709
 
1647
1710
    @needs_write_lock
1648
1711
    def put_file_bytes_non_atomic(self, file_id, bytes):
1733
1796
        r"""Check whether the filename matches an ignore pattern.
1734
1797
 
1735
1798
        Patterns containing '/' or '\' need to match the whole path;
1736
 
        others match against only the last component.
 
1799
        others match against only the last component.  Patterns starting
 
1800
        with '!' are ignore exceptions.  Exceptions take precedence
 
1801
        over regular patterns and cause the filename to not be ignored.
1737
1802
 
1738
1803
        If the file is ignored, returns the pattern which caused it to
1739
1804
        be ignored, otherwise None.  So this can simply be used as a
1740
1805
        boolean if desired."""
1741
1806
        if getattr(self, '_ignoreglobster', None) is None:
1742
 
            self._ignoreglobster = globbing.Globster(self.get_ignore_list())
 
1807
            self._ignoreglobster = globbing.ExceptionGlobster(self.get_ignore_list())
1743
1808
        return self._ignoreglobster.match(filename)
1744
1809
 
1745
1810
    def kind(self, file_id):
1795
1860
            raise errors.ObjectNotLocked(self)
1796
1861
 
1797
1862
    def lock_read(self):
1798
 
        """See Branch.lock_read, and WorkingTree.unlock."""
 
1863
        """Lock the tree for reading.
 
1864
 
 
1865
        This also locks the branch, and can be unlocked via self.unlock().
 
1866
 
 
1867
        :return: A bzrlib.lock.LogicalLockResult.
 
1868
        """
1799
1869
        if not self.is_locked():
1800
1870
            self._reset_data()
1801
1871
        self.branch.lock_read()
1802
1872
        try:
1803
 
            return self._control_files.lock_read()
 
1873
            self._control_files.lock_read()
 
1874
            return LogicalLockResult(self.unlock)
1804
1875
        except:
1805
1876
            self.branch.unlock()
1806
1877
            raise
1807
1878
 
1808
1879
    def lock_tree_write(self):
1809
 
        """See MutableTree.lock_tree_write, and WorkingTree.unlock."""
 
1880
        """See MutableTree.lock_tree_write, and WorkingTree.unlock.
 
1881
 
 
1882
        :return: A bzrlib.lock.LogicalLockResult.
 
1883
        """
1810
1884
        if not self.is_locked():
1811
1885
            self._reset_data()
1812
1886
        self.branch.lock_read()
1813
1887
        try:
1814
 
            return self._control_files.lock_write()
 
1888
            self._control_files.lock_write()
 
1889
            return LogicalLockResult(self.unlock)
1815
1890
        except:
1816
1891
            self.branch.unlock()
1817
1892
            raise
1818
1893
 
1819
1894
    def lock_write(self):
1820
 
        """See MutableTree.lock_write, and WorkingTree.unlock."""
 
1895
        """See MutableTree.lock_write, and WorkingTree.unlock.
 
1896
 
 
1897
        :return: A bzrlib.lock.LogicalLockResult.
 
1898
        """
1821
1899
        if not self.is_locked():
1822
1900
            self._reset_data()
1823
1901
        self.branch.lock_write()
1824
1902
        try:
1825
 
            return self._control_files.lock_write()
 
1903
            self._control_files.lock_write()
 
1904
            return LogicalLockResult(self.unlock)
1826
1905
        except:
1827
1906
            self.branch.unlock()
1828
1907
            raise
1836
1915
    def _reset_data(self):
1837
1916
        """Reset transient data that cannot be revalidated."""
1838
1917
        self._inventory_is_modified = False
1839
 
        result = self._deserialize(self._transport.get('inventory'))
 
1918
        f = self._transport.get('inventory')
 
1919
        try:
 
1920
            result = self._deserialize(f)
 
1921
        finally:
 
1922
            f.close()
1840
1923
        self._set_inventory(result, dirty=False)
1841
1924
 
1842
1925
    @needs_tree_write_lock
1889
1972
            # revision_id is set. We must check for this full string, because a
1890
1973
            # root node id can legitimately look like 'revision_id' but cannot
1891
1974
            # contain a '"'.
1892
 
            xml = self.branch.repository.get_inventory_xml(new_revision)
 
1975
            xml = self.branch.repository._get_inventory_xml(new_revision)
1893
1976
            firstline = xml.split('\n', 1)[0]
1894
1977
            if (not 'revision_id="' in firstline or
1895
1978
                'format="7"' not in firstline):
1896
 
                inv = self.branch.repository.deserialise_inventory(
1897
 
                    new_revision, xml)
 
1979
                inv = self.branch.repository._serializer.read_inventory_from_string(
 
1980
                    xml, new_revision)
1898
1981
                xml = self._create_basis_xml_from_inventory(new_revision, inv)
1899
1982
            self._write_basis_inventory(xml)
1900
1983
        except (errors.NoSuchRevision, errors.RevisionNotPresent):
1918
2001
        # binary.
1919
2002
        if self._inventory_is_modified:
1920
2003
            raise errors.InventoryModified(self)
1921
 
        result = self._deserialize(self._transport.get('inventory'))
 
2004
        f = self._transport.get('inventory')
 
2005
        try:
 
2006
            result = self._deserialize(f)
 
2007
        finally:
 
2008
            f.close()
1922
2009
        self._set_inventory(result, dirty=False)
1923
2010
        return result
1924
2011
 
1939
2026
 
1940
2027
        new_files=set()
1941
2028
        unknown_nested_files=set()
 
2029
        if to_file is None:
 
2030
            to_file = sys.stdout
1942
2031
 
1943
2032
        def recurse_directory_to_add_files(directory):
1944
2033
            # Recurse directory and add all files
1945
2034
            # so we can check if they have changed.
1946
 
            for parent_info, file_infos in\
1947
 
                self.walkdirs(directory):
 
2035
            for parent_info, file_infos in self.walkdirs(directory):
1948
2036
                for relpath, basename, kind, lstat, fileid, kind in file_infos:
1949
2037
                    # Is it versioned or ignored?
1950
2038
                    if self.path2id(relpath) or self.is_ignored(relpath):
1985
2073
                            # ... but not ignored
1986
2074
                            has_changed_files = True
1987
2075
                            break
1988
 
                    elif content_change and (kind[1] is not None):
1989
 
                        # Versioned and changed, but not deleted
 
2076
                    elif (content_change and (kind[1] is not None) and
 
2077
                            osutils.is_inside_any(files, path[1])):
 
2078
                        # Versioned and changed, but not deleted, and still
 
2079
                        # in one of the dirs to be deleted.
1990
2080
                        has_changed_files = True
1991
2081
                        break
1992
2082
 
2014
2104
                        new_status = 'I'
2015
2105
                    else:
2016
2106
                        new_status = '?'
2017
 
                    textui.show_status(new_status, self.kind(fid), f,
2018
 
                                       to_file=to_file)
 
2107
                    # XXX: Really should be a more abstract reporter interface
 
2108
                    kind_ch = osutils.kind_marker(self.kind(fid))
 
2109
                    to_file.write(new_status + '       ' + f + kind_ch + '\n')
2019
2110
                # Unversion file
2020
2111
                inv_delta.append((f, None, fid, None))
2021
2112
                message = "removed %s" % (f,)
2044
2135
 
2045
2136
    @needs_tree_write_lock
2046
2137
    def revert(self, filenames=None, old_tree=None, backups=True,
2047
 
               pb=DummyProgress(), report_changes=False):
 
2138
               pb=None, report_changes=False):
2048
2139
        from bzrlib.conflicts import resolve
2049
2140
        if filenames == []:
2050
2141
            filenames = None
2172
2263
        """
2173
2264
        raise NotImplementedError(self.unlock)
2174
2265
 
2175
 
    def update(self, change_reporter=None, possible_transports=None):
 
2266
    _marker = object()
 
2267
 
 
2268
    def update(self, change_reporter=None, possible_transports=None,
 
2269
               revision=None, old_tip=_marker):
2176
2270
        """Update a working tree along its branch.
2177
2271
 
2178
2272
        This will update the branch if its bound too, which means we have
2196
2290
        - Merge current state -> basis tree of the master w.r.t. the old tree
2197
2291
          basis.
2198
2292
        - Do a 'normal' merge of the old branch basis if it is relevant.
 
2293
 
 
2294
        :param revision: The target revision to update to. Must be in the
 
2295
            revision history.
 
2296
        :param old_tip: If branch.update() has already been run, the value it
 
2297
            returned (old tip of the branch or None). _marker is used
 
2298
            otherwise.
2199
2299
        """
2200
2300
        if self.branch.get_bound_location() is not None:
2201
2301
            self.lock_write()
2202
 
            update_branch = True
 
2302
            update_branch = (old_tip is self._marker)
2203
2303
        else:
2204
2304
            self.lock_tree_write()
2205
2305
            update_branch = False
2207
2307
            if update_branch:
2208
2308
                old_tip = self.branch.update(possible_transports)
2209
2309
            else:
2210
 
                old_tip = None
2211
 
            return self._update_tree(old_tip, change_reporter)
 
2310
                if old_tip is self._marker:
 
2311
                    old_tip = None
 
2312
            return self._update_tree(old_tip, change_reporter, revision)
2212
2313
        finally:
2213
2314
            self.unlock()
2214
2315
 
2215
2316
    @needs_tree_write_lock
2216
 
    def _update_tree(self, old_tip=None, change_reporter=None):
 
2317
    def _update_tree(self, old_tip=None, change_reporter=None, revision=None):
2217
2318
        """Update a tree to the master branch.
2218
2319
 
2219
2320
        :param old_tip: if supplied, the previous tip revision the branch,
2229
2330
        # We MUST save it even if an error occurs, because otherwise the users
2230
2331
        # local work is unreferenced and will appear to have been lost.
2231
2332
        #
2232
 
        result = 0
 
2333
        nb_conflicts = 0
2233
2334
        try:
2234
2335
            last_rev = self.get_parent_ids()[0]
2235
2336
        except IndexError:
2236
2337
            last_rev = _mod_revision.NULL_REVISION
2237
 
        if last_rev != _mod_revision.ensure_null(self.branch.last_revision()):
2238
 
            # merge tree state up to new branch tip.
 
2338
        if revision is None:
 
2339
            revision = self.branch.last_revision()
 
2340
 
 
2341
        old_tip = old_tip or _mod_revision.NULL_REVISION
 
2342
 
 
2343
        if not _mod_revision.is_null(old_tip) and old_tip != last_rev:
 
2344
            # the branch we are bound to was updated
 
2345
            # merge those changes in first
 
2346
            base_tree  = self.basis_tree()
 
2347
            other_tree = self.branch.repository.revision_tree(old_tip)
 
2348
            nb_conflicts = merge.merge_inner(self.branch, other_tree,
 
2349
                                             base_tree, this_tree=self,
 
2350
                                             change_reporter=change_reporter)
 
2351
            if nb_conflicts:
 
2352
                self.add_parent_tree((old_tip, other_tree))
 
2353
                trace.note('Rerun update after fixing the conflicts.')
 
2354
                return nb_conflicts
 
2355
 
 
2356
        if last_rev != _mod_revision.ensure_null(revision):
 
2357
            # the working tree is up to date with the branch
 
2358
            # we can merge the specified revision from master
 
2359
            to_tree = self.branch.repository.revision_tree(revision)
 
2360
            to_root_id = to_tree.get_root_id()
 
2361
 
2239
2362
            basis = self.basis_tree()
2240
2363
            basis.lock_read()
2241
2364
            try:
2242
 
                to_tree = self.branch.basis_tree()
2243
 
                if basis.inventory.root is None:
2244
 
                    self.set_root_id(to_tree.get_root_id())
 
2365
                if (basis.inventory.root is None
 
2366
                    or basis.inventory.root.file_id != to_root_id):
 
2367
                    self.set_root_id(to_root_id)
2245
2368
                    self.flush()
2246
 
                result += merge.merge_inner(
2247
 
                                      self.branch,
2248
 
                                      to_tree,
2249
 
                                      basis,
2250
 
                                      this_tree=self,
2251
 
                                      change_reporter=change_reporter)
2252
2369
            finally:
2253
2370
                basis.unlock()
 
2371
 
 
2372
            # determine the branch point
 
2373
            graph = self.branch.repository.get_graph()
 
2374
            base_rev_id = graph.find_unique_lca(self.branch.last_revision(),
 
2375
                                                last_rev)
 
2376
            base_tree = self.branch.repository.revision_tree(base_rev_id)
 
2377
 
 
2378
            nb_conflicts = merge.merge_inner(self.branch, to_tree, base_tree,
 
2379
                                             this_tree=self,
 
2380
                                             change_reporter=change_reporter)
 
2381
            self.set_last_revision(revision)
2254
2382
            # TODO - dedup parents list with things merged by pull ?
2255
2383
            # reuse the tree we've updated to to set the basis:
2256
 
            parent_trees = [(self.branch.last_revision(), to_tree)]
 
2384
            parent_trees = [(revision, to_tree)]
2257
2385
            merges = self.get_parent_ids()[1:]
2258
2386
            # Ideally we ask the tree for the trees here, that way the working
2259
2387
            # tree can decide whether to give us the entire tree or give us a
2263
2391
            for parent in merges:
2264
2392
                parent_trees.append(
2265
2393
                    (parent, self.branch.repository.revision_tree(parent)))
2266
 
            if (old_tip is not None and not _mod_revision.is_null(old_tip)):
 
2394
            if not _mod_revision.is_null(old_tip):
2267
2395
                parent_trees.append(
2268
2396
                    (old_tip, self.branch.repository.revision_tree(old_tip)))
2269
2397
            self.set_parent_trees(parent_trees)
2270
2398
            last_rev = parent_trees[0][0]
2271
 
        else:
2272
 
            # the working tree had the same last-revision as the master
2273
 
            # branch did. We may still have pivot local work from the local
2274
 
            # branch into old_tip:
2275
 
            if (old_tip is not None and not _mod_revision.is_null(old_tip)):
2276
 
                self.add_parent_tree_id(old_tip)
2277
 
        if (old_tip is not None and not _mod_revision.is_null(old_tip)
2278
 
            and old_tip != last_rev):
2279
 
            # our last revision was not the prior branch last revision
2280
 
            # and we have converted that last revision to a pending merge.
2281
 
            # base is somewhere between the branch tip now
2282
 
            # and the now pending merge
2283
 
 
2284
 
            # Since we just modified the working tree and inventory, flush out
2285
 
            # the current state, before we modify it again.
2286
 
            # TODO: jam 20070214 WorkingTree3 doesn't require this, dirstate
2287
 
            #       requires it only because TreeTransform directly munges the
2288
 
            #       inventory and calls tree._write_inventory(). Ultimately we
2289
 
            #       should be able to remove this extra flush.
2290
 
            self.flush()
2291
 
            graph = self.branch.repository.get_graph()
2292
 
            base_rev_id = graph.find_unique_lca(self.branch.last_revision(),
2293
 
                                                old_tip)
2294
 
            base_tree = self.branch.repository.revision_tree(base_rev_id)
2295
 
            other_tree = self.branch.repository.revision_tree(old_tip)
2296
 
            result += merge.merge_inner(
2297
 
                                  self.branch,
2298
 
                                  other_tree,
2299
 
                                  base_tree,
2300
 
                                  this_tree=self,
2301
 
                                  change_reporter=change_reporter)
2302
 
        return result
 
2399
        return nb_conflicts
2303
2400
 
2304
2401
    def _write_hashcache_if_dirty(self):
2305
2402
        """Write out the hashcache if it is dirty."""
2575
2672
        """
2576
2673
        return
2577
2674
 
2578
 
    @needs_read_lock
2579
2675
    def _get_rules_searcher(self, default_searcher):
2580
2676
        """See Tree._get_rules_searcher."""
2581
2677
        if self._rules_searcher is None:
2617
2713
 
2618
2714
        In Format2 WorkingTrees we have a single lock for the branch and tree
2619
2715
        so lock_tree_write() degrades to lock_write().
 
2716
 
 
2717
        :return: An object with an unlock method which will release the lock
 
2718
            obtained.
2620
2719
        """
2621
2720
        self.branch.lock_write()
2622
2721
        try:
2623
 
            return self._control_files.lock_write()
 
2722
            self._control_files.lock_write()
 
2723
            return self
2624
2724
        except:
2625
2725
            self.branch.unlock()
2626
2726
            raise
2760
2860
        """Return the format for the working tree object in a_bzrdir."""
2761
2861
        try:
2762
2862
            transport = a_bzrdir.get_workingtree_transport(None)
2763
 
            format_string = transport.get("format").read()
 
2863
            format_string = transport.get_bytes("format")
2764
2864
            return klass._formats[format_string]
2765
2865
        except errors.NoSuchFile:
2766
2866
            raise errors.NoWorkingTree(base=transport.base)
3030
3130
        return self.get_format_string()
3031
3131
 
3032
3132
 
3033
 
__default_format = WorkingTreeFormat4()
 
3133
__default_format = WorkingTreeFormat6()
3034
3134
WorkingTreeFormat.register_format(__default_format)
3035
 
WorkingTreeFormat.register_format(WorkingTreeFormat6())
3036
3135
WorkingTreeFormat.register_format(WorkingTreeFormat5())
 
3136
WorkingTreeFormat.register_format(WorkingTreeFormat4())
3037
3137
WorkingTreeFormat.register_format(WorkingTreeFormat3())
3038
3138
WorkingTreeFormat.set_default_format(__default_format)
3039
3139
# formats which have no format string are not discoverable