← 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: 2007-07-22 18:09:04 UTC
  • mfrom: (2485.8.63 bzr.connection.sharing)
  • Revision ID: pqm@pqm.ubuntu.com-20070722180904-wy7y7oyi32wbghgf
Transport connection sharing

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
44
44
lazy_import(globals(), """
45
45
from bisect import bisect_left
46
46
import collections
47
 
from copy import deepcopy
48
47
import errno
49
48
import itertools
50
49
import operator
66
65
    ignores,
67
66
    merge,
68
67
    osutils,
 
68
    revision as _mod_revision,
69
69
    revisiontree,
70
70
    repository,
71
71
    textui,
460
460
        return file(self.abspath(filename), 'rb')
461
461
 
462
462
    @needs_read_lock
463
 
    def annotate_iter(self, file_id):
 
463
    def annotate_iter(self, file_id, default_revision=CURRENT_REVISION):
464
464
        """See Tree.annotate_iter
465
465
 
466
466
        This implementation will use the basis tree implementation if possible.
493
493
                    continue
494
494
                old.append(list(tree.annotate_iter(file_id)))
495
495
            return annotate.reannotate(old, self.get_file(file_id).readlines(),
496
 
                                       CURRENT_REVISION)
 
496
                                       default_revision)
497
497
        finally:
498
498
            basis.unlock()
499
499
 
 
500
    def _get_ancestors(self, default_revision):
 
501
        ancestors = set([default_revision])
 
502
        for parent_id in self.get_parent_ids():
 
503
            ancestors.update(self.branch.repository.get_ancestry(
 
504
                             parent_id, topo_sorted=False))
 
505
        return ancestors
 
506
 
500
507
    def get_parent_ids(self):
501
508
        """See Tree.get_parent_ids.
502
509
        
503
510
        This implementation reads the pending merges list and last_revision
504
511
        value and uses that to decide what the parents list should be.
505
512
        """
506
 
        last_rev = self._last_revision()
507
 
        if last_rev is None:
 
513
        last_rev = _mod_revision.ensure_null(self._last_revision())
 
514
        if _mod_revision.NULL_REVISION == last_rev:
508
515
            parents = []
509
516
        else:
510
517
            parents = [last_rev]
616
623
        # should probably put it back with the previous ID.
617
624
        # the read and write working inventory should not occur in this 
618
625
        # function - they should be part of lock_write and unlock.
619
 
        inv = self.read_working_inventory()
 
626
        inv = self.inventory
620
627
        for f, file_id, kind in zip(files, ids, kinds):
621
628
            assert kind is not None
622
629
            if file_id is None:
624
631
            else:
625
632
                file_id = osutils.safe_file_id(file_id)
626
633
                inv.add_path(f, kind=kind, file_id=file_id)
627
 
        self._write_inventory(inv)
 
634
            self._inventory_is_modified = True
628
635
 
629
636
    @needs_tree_write_lock
630
637
    def _gather_kinds(self, files, kinds):
735
742
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
736
743
        self._check_parents_for_ghosts(revision_ids,
737
744
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
 
745
        for revision_id in revision_ids:
 
746
            _mod_revision.check_not_reserved_id(revision_id)
738
747
 
739
748
        if len(revision_ids) > 0:
740
749
            self.set_last_revision(revision_ids[0])
741
750
        else:
742
 
            self.set_last_revision(None)
 
751
            self.set_last_revision(_mod_revision.NULL_REVISION)
743
752
 
744
753
        self._set_merges_from_parent_ids(revision_ids)
745
754
 
747
756
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
748
757
        """See MutableTree.set_parent_trees."""
749
758
        parent_ids = [osutils.safe_revision_id(rev) for (rev, tree) in parents_list]
 
759
        for revision_id in parent_ids:
 
760
            _mod_revision.check_not_reserved_id(revision_id)
750
761
 
751
762
        self._check_parents_for_ghosts(parent_ids,
752
763
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
753
764
 
754
765
        if len(parent_ids) == 0:
755
 
            leftmost_parent_id = None
 
766
            leftmost_parent_id = _mod_revision.NULL_REVISION
756
767
            leftmost_parent_tree = None
757
768
        else:
758
769
            leftmost_parent_id, leftmost_parent_tree = parents_list[0]
808
819
            # local alterations
809
820
            merger.check_basis(check_clean=True, require_commits=False)
810
821
            if to_revision is None:
811
 
                to_revision = branch.last_revision()
 
822
                to_revision = _mod_revision.ensure_null(branch.last_revision())
812
823
            else:
813
824
                to_revision = osutils.safe_revision_id(to_revision)
814
825
            merger.other_rev_id = to_revision
815
 
            if merger.other_rev_id is None:
816
 
                raise error.NoCommits(branch)
 
826
            if _mod_revision.is_null(merger.other_rev_id):
 
827
                raise errors.NoCommits(branch)
817
828
            self.branch.fetch(branch, last_revision=merger.other_rev_id)
818
829
            merger.other_basis = merger.other_rev_id
819
830
            merger.other_tree = self.branch.repository.revision_tree(
1686
1697
        This is used to allow WorkingTree3 instances to not affect branch
1687
1698
        when their last revision is set.
1688
1699
        """
1689
 
        if new_revision is None:
 
1700
        if _mod_revision.is_null(new_revision):
1690
1701
            self.branch.set_revision_history([])
1691
1702
            return False
1692
1703
        try:
1763
1774
    @needs_tree_write_lock
1764
1775
    def remove(self, files, verbose=False, to_file=None, keep_files=True,
1765
1776
        force=False):
1766
 
        """Remove nominated files from the working inventor.
 
1777
        """Remove nominated files from the working inventory.
1767
1778
 
1768
1779
        :files: File paths relative to the basedir.
1769
1780
        :keep_files: If true, the files will also be kept.
1775
1786
        if isinstance(files, basestring):
1776
1787
            files = [files]
1777
1788
 
1778
 
        inv = self.inventory
 
1789
        inv_delta = []
1779
1790
 
1780
1791
        new_files=set()
1781
1792
        unknown_files_in_directory=set()
1783
1794
        def recurse_directory_to_add_files(directory):
1784
1795
            # recurse directory and add all files
1785
1796
            # so we can check if they have changed.
1786
 
            for contained_dir_info in self.walkdirs(directory):
1787
 
                for file_info in contained_dir_info[1]:
1788
 
                    if file_info[2] == 'file':
1789
 
                        relpath = self.relpath(file_info[0])
1790
 
                        if file_info[4]: #is it versioned?
 
1797
            for parent_info, file_infos in\
 
1798
                osutils.walkdirs(self.abspath(directory),
 
1799
                    directory):
 
1800
                for relpath, basename, kind, lstat, abspath in file_infos:
 
1801
                    if kind == 'file':
 
1802
                        if self.path2id(relpath): #is it versioned?
1791
1803
                            new_files.add(relpath)
1792
1804
                        else:
1793
1805
                            unknown_files_in_directory.add(
1794
 
                                (relpath, None, file_info[2]))
 
1806
                                (relpath, None, kind))
1795
1807
 
1796
1808
        for filename in files:
1797
1809
            # Get file name into canonical form.
1798
 
            filename = self.relpath(self.abspath(filename))
 
1810
            abspath = self.abspath(filename)
 
1811
            filename = self.relpath(abspath)
1799
1812
            if len(filename) > 0:
1800
1813
                new_files.add(filename)
1801
 
                if osutils.isdir(filename) and len(os.listdir(filename)) > 0:
 
1814
                if osutils.isdir(abspath):
1802
1815
                    recurse_directory_to_add_files(filename)
1803
1816
        files = [f for f in new_files]
1804
1817
 
 
1818
        if len(files) == 0:
 
1819
            return # nothing to do
 
1820
 
1805
1821
        # Sort needed to first handle directory content before the directory
1806
1822
        files.sort(reverse=True)
1807
1823
        if not keep_files and not force:
1808
 
            tree_delta = self.changes_from(self.basis_tree(),
1809
 
                specific_files=files)
1810
 
            for unknown_file in unknown_files_in_directory:
1811
 
                tree_delta.unversioned.extend((unknown_file,))
1812
 
            if bool(tree_delta.modified
1813
 
                    or tree_delta.added
1814
 
                    or tree_delta.renamed
1815
 
                    or tree_delta.kind_changed
1816
 
                    or tree_delta.unversioned):
 
1824
            has_changed_files = len(unknown_files_in_directory) > 0
 
1825
            if not has_changed_files:
 
1826
                for (file_id, path, content_change, versioned, parent_id, name,
 
1827
                     kind, executable) in self._iter_changes(self.basis_tree(),
 
1828
                         include_unchanged=True, require_versioned=False,
 
1829
                         want_unversioned=True, specific_files=files):
 
1830
                    # check if it's unknown OR changed but not deleted:
 
1831
                    if (versioned == (False, False)
 
1832
                        or (content_change and kind[1] != None)):
 
1833
                        has_changed_files = True
 
1834
                        break
 
1835
 
 
1836
            if has_changed_files:
 
1837
                # make delta to show ALL applicable changes in error message.
 
1838
                tree_delta = self.changes_from(self.basis_tree(),
 
1839
                    specific_files=files)
 
1840
                for unknown_file in unknown_files_in_directory:
 
1841
                    tree_delta.unversioned.extend((unknown_file,))
1817
1842
                raise errors.BzrRemoveChangedFilesError(tree_delta)
1818
1843
 
1819
1844
        # do this before any modifications
1820
1845
        for f in files:
1821
 
            fid = inv.path2id(f)
 
1846
            fid = self.path2id(f)
1822
1847
            message=None
1823
1848
            if not fid:
1824
1849
                message="%s is not versioned." % (f,)
1829
1854
                        new_status = 'I'
1830
1855
                    else:
1831
1856
                        new_status = '?'
1832
 
                    textui.show_status(new_status, inv[fid].kind, f,
 
1857
                    textui.show_status(new_status, self.kind(fid), f,
1833
1858
                                       to_file=to_file)
1834
1859
                # unversion file
1835
 
                del inv[fid]
 
1860
                inv_delta.append((f, None, fid, None))
1836
1861
                message="removed %s" % (f,)
1837
1862
 
1838
1863
            if not keep_files:
1852
1877
            # print only one message (if any) per file.
1853
1878
            if message is not None:
1854
1879
                note(message)
1855
 
        self._write_inventory(inv)
 
1880
        self.apply_inventory_delta(inv_delta)
1856
1881
 
1857
1882
    @needs_tree_write_lock
1858
1883
    def revert(self, filenames, old_tree=None, backups=True, 
1969
1994
        """
1970
1995
        raise NotImplementedError(self.unlock)
1971
1996
 
1972
 
    def update(self):
 
1997
    def update(self, change_reporter=None):
1973
1998
        """Update a working tree along its branch.
1974
1999
 
1975
2000
        This will update the branch if its bound too, which means we have
2005
2030
                old_tip = self.branch.update()
2006
2031
            else:
2007
2032
                old_tip = None
2008
 
            return self._update_tree(old_tip)
 
2033
            return self._update_tree(old_tip, change_reporter)
2009
2034
        finally:
2010
2035
            self.unlock()
2011
2036
 
2012
2037
    @needs_tree_write_lock
2013
 
    def _update_tree(self, old_tip=None):
 
2038
    def _update_tree(self, old_tip=None, change_reporter=None):
2014
2039
        """Update a tree to the master branch.
2015
2040
 
2016
2041
        :param old_tip: if supplied, the previous tip revision the branch,
2030
2055
        try:
2031
2056
            last_rev = self.get_parent_ids()[0]
2032
2057
        except IndexError:
2033
 
            last_rev = None
2034
 
        if last_rev != self.branch.last_revision():
 
2058
            last_rev = _mod_revision.NULL_REVISION
 
2059
        if last_rev != _mod_revision.ensure_null(self.branch.last_revision()):
2035
2060
            # merge tree state up to new branch tip.
2036
2061
            basis = self.basis_tree()
2037
2062
            basis.lock_read()
2044
2069
                                      self.branch,
2045
2070
                                      to_tree,
2046
2071
                                      basis,
2047
 
                                      this_tree=self)
 
2072
                                      this_tree=self,
 
2073
                                      change_reporter=change_reporter)
2048
2074
            finally:
2049
2075
                basis.unlock()
2050
2076
            # TODO - dedup parents list with things merged by pull ?
2059
2085
            for parent in merges:
2060
2086
                parent_trees.append(
2061
2087
                    (parent, self.branch.repository.revision_tree(parent)))
2062
 
            if old_tip is not None:
 
2088
            if (old_tip is not None and not _mod_revision.is_null(old_tip)):
2063
2089
                parent_trees.append(
2064
2090
                    (old_tip, self.branch.repository.revision_tree(old_tip)))
2065
2091
            self.set_parent_trees(parent_trees)
2068
2094
            # the working tree had the same last-revision as the master
2069
2095
            # branch did. We may still have pivot local work from the local
2070
2096
            # branch into old_tip:
2071
 
            if old_tip is not None:
 
2097
            if (old_tip is not None and not _mod_revision.is_null(old_tip)):
2072
2098
                self.add_parent_tree_id(old_tip)
2073
 
        if old_tip and old_tip != last_rev:
 
2099
        if (old_tip is not None and not _mod_revision.is_null(old_tip)
 
2100
            and old_tip != last_rev):
2074
2101
            # our last revision was not the prior branch last revision
2075
2102
            # and we have converted that last revision to a pending merge.
2076
2103
            # base is somewhere between the branch tip now
2083
2110
            #       inventory and calls tree._write_inventory(). Ultimately we
2084
2111
            #       should be able to remove this extra flush.
2085
2112
            self.flush()
2086
 
            from bzrlib.revision import common_ancestor
2087
 
            try:
2088
 
                base_rev_id = common_ancestor(self.branch.last_revision(),
2089
 
                                              old_tip,
2090
 
                                              self.branch.repository)
2091
 
            except errors.NoCommonAncestor:
2092
 
                base_rev_id = None
 
2113
            graph = self.branch.repository.get_graph()
 
2114
            base_rev_id = graph.find_unique_lca(self.branch.last_revision(),
 
2115
                                                old_tip)
2093
2116
            base_tree = self.branch.repository.revision_tree(base_rev_id)
2094
2117
            other_tree = self.branch.repository.revision_tree(old_tip)
2095
2118
            result += merge.merge_inner(
2096
2119
                                  self.branch,
2097
2120
                                  other_tree,
2098
2121
                                  base_tree,
2099
 
                                  this_tree=self)
 
2122
                                  this_tree=self,
 
2123
                                  change_reporter=change_reporter)
2100
2124
        return result
2101
2125
 
2102
2126
    def _write_hashcache_if_dirty(self):
2595
2619
        if not isinstance(a_bzrdir.transport, LocalTransport):
2596
2620
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
2597
2621
        branch = a_bzrdir.open_branch()
2598
 
        if revision_id is not None:
 
2622
        if revision_id is None:
 
2623
            revision_id = _mod_revision.ensure_null(branch.last_revision())
 
2624
        else:
2599
2625
            revision_id = osutils.safe_revision_id(revision_id)
2600
 
            branch.lock_write()
2601
 
            try:
2602
 
                revision_history = branch.revision_history()
2603
 
                try:
2604
 
                    position = revision_history.index(revision_id)
2605
 
                except ValueError:
2606
 
                    raise errors.NoSuchRevision(branch, revision_id)
2607
 
                branch.set_revision_history(revision_history[:position + 1])
2608
 
            finally:
2609
 
                branch.unlock()
2610
 
        revision = branch.last_revision()
 
2626
        branch.lock_write()
 
2627
        try:
 
2628
            branch.generate_revision_history(revision_id)
 
2629
        finally:
 
2630
            branch.unlock()
2611
2631
        inv = Inventory()
2612
2632
        wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
2613
2633
                         branch,
2615
2635
                         _internal=True,
2616
2636
                         _format=self,
2617
2637
                         _bzrdir=a_bzrdir)
2618
 
        basis_tree = branch.repository.revision_tree(revision)
 
2638
        basis_tree = branch.repository.revision_tree(revision_id)
2619
2639
        if basis_tree.inventory.root is not None:
2620
2640
            wt.set_root_id(basis_tree.inventory.root.file_id)
2621
2641
        # set the parent list and cache the basis tree.
2622
 
        wt.set_parent_trees([(revision, basis_tree)])
 
2642
        if _mod_revision.is_null(revision_id):
 
2643
            parent_trees = []
 
2644
        else:
 
2645
            parent_trees = [(revision_id, basis_tree)]
 
2646
        wt.set_parent_trees(parent_trees)
2623
2647
        transform.build_tree(basis_tree, wt)
2624
2648
        return wt
2625
2649
 
2696
2720
        control_files.put_utf8('format', self.get_format_string())
2697
2721
        branch = a_bzrdir.open_branch()
2698
2722
        if revision_id is None:
2699
 
            revision_id = branch.last_revision()
 
2723
            revision_id = _mod_revision.ensure_null(branch.last_revision())
2700
2724
        else:
2701
2725
            revision_id = osutils.safe_revision_id(revision_id)
2702
2726
        # WorkingTree3 can handle an inventory which has a unique root id.
2774
2798
# and not independently creatable, so are not registered.
2775
2799
_legacy_formats = [WorkingTreeFormat2(),
2776
2800
                   ]
2777
 
 
2778
 
 
2779
 
class WorkingTreeTestProviderAdapter(object):
2780
 
    """A tool to generate a suite testing multiple workingtree formats at once.
2781
 
 
2782
 
    This is done by copying the test once for each transport and injecting
2783
 
    the transport_server, transport_readonly_server, and workingtree_format
2784
 
    classes into each copy. Each copy is also given a new id() to make it
2785
 
    easy to identify.
2786
 
    """
2787
 
 
2788
 
    def __init__(self, transport_server, transport_readonly_server, formats):
2789
 
        self._transport_server = transport_server
2790
 
        self._transport_readonly_server = transport_readonly_server
2791
 
        self._formats = formats
2792
 
    
2793
 
    def _clone_test(self, test, bzrdir_format, workingtree_format, variation):
2794
 
        """Clone test for adaption."""
2795
 
        new_test = deepcopy(test)
2796
 
        new_test.transport_server = self._transport_server
2797
 
        new_test.transport_readonly_server = self._transport_readonly_server
2798
 
        new_test.bzrdir_format = bzrdir_format
2799
 
        new_test.workingtree_format = workingtree_format
2800
 
        def make_new_test_id():
2801
 
            new_id = "%s(%s)" % (test.id(), variation)
2802
 
            return lambda: new_id
2803
 
        new_test.id = make_new_test_id()
2804
 
        return new_test
2805
 
    
2806
 
    def adapt(self, test):
2807
 
        from bzrlib.tests import TestSuite
2808
 
        result = TestSuite()
2809
 
        for workingtree_format, bzrdir_format in self._formats:
2810
 
            new_test = self._clone_test(
2811
 
                test,
2812
 
                bzrdir_format,
2813
 
                workingtree_format, workingtree_format.__class__.__name__)
2814
 
            result.addTest(new_test)
2815
 
        return result