← 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-12 09:49:37 UTC
  • mfrom: (2598.5.9 nullrevision)
  • Revision ID: pqm@pqm.ubuntu.com-20070712094937-rw5qbi81enh0pvhw
Make most functions prefer NULL_REVISION

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
65
65
    ignores,
66
66
    merge,
67
67
    osutils,
 
68
    revision as _mod_revision,
68
69
    revisiontree,
69
70
    repository,
70
71
    textui,
502
503
        This implementation reads the pending merges list and last_revision
503
504
        value and uses that to decide what the parents list should be.
504
505
        """
505
 
        last_rev = self._last_revision()
506
 
        if last_rev is None:
 
506
        last_rev = _mod_revision.ensure_null(self._last_revision())
 
507
        if _mod_revision.NULL_REVISION == last_rev:
507
508
            parents = []
508
509
        else:
509
510
            parents = [last_rev]
734
735
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
735
736
        self._check_parents_for_ghosts(revision_ids,
736
737
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
 
738
        for revision_id in revision_ids:
 
739
            _mod_revision.check_not_reserved_id(revision_id)
737
740
 
738
741
        if len(revision_ids) > 0:
739
742
            self.set_last_revision(revision_ids[0])
740
743
        else:
741
 
            self.set_last_revision(None)
 
744
            self.set_last_revision(_mod_revision.NULL_REVISION)
742
745
 
743
746
        self._set_merges_from_parent_ids(revision_ids)
744
747
 
746
749
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
747
750
        """See MutableTree.set_parent_trees."""
748
751
        parent_ids = [osutils.safe_revision_id(rev) for (rev, tree) in parents_list]
 
752
        for revision_id in parent_ids:
 
753
            _mod_revision.check_not_reserved_id(revision_id)
749
754
 
750
755
        self._check_parents_for_ghosts(parent_ids,
751
756
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
752
757
 
753
758
        if len(parent_ids) == 0:
754
 
            leftmost_parent_id = None
 
759
            leftmost_parent_id = _mod_revision.NULL_REVISION
755
760
            leftmost_parent_tree = None
756
761
        else:
757
762
            leftmost_parent_id, leftmost_parent_tree = parents_list[0]
807
812
            # local alterations
808
813
            merger.check_basis(check_clean=True, require_commits=False)
809
814
            if to_revision is None:
810
 
                to_revision = branch.last_revision()
 
815
                to_revision = _mod_revision.ensure_null(branch.last_revision())
811
816
            else:
812
817
                to_revision = osutils.safe_revision_id(to_revision)
813
818
            merger.other_rev_id = to_revision
814
 
            if merger.other_rev_id is None:
 
819
            if _mod_revision.is_null(merger.other_rev_id):
815
820
                raise errors.NoCommits(branch)
816
821
            self.branch.fetch(branch, last_revision=merger.other_rev_id)
817
822
            merger.other_basis = merger.other_rev_id
1685
1690
        This is used to allow WorkingTree3 instances to not affect branch
1686
1691
        when their last revision is set.
1687
1692
        """
1688
 
        if new_revision is None:
 
1693
        if _mod_revision.is_null(new_revision):
1689
1694
            self.branch.set_revision_history([])
1690
1695
            return False
1691
1696
        try:
2031
2036
        try:
2032
2037
            last_rev = self.get_parent_ids()[0]
2033
2038
        except IndexError:
2034
 
            last_rev = None
2035
 
        if last_rev != self.branch.last_revision():
 
2039
            last_rev = _mod_revision.NULL_REVISION
 
2040
        if last_rev != _mod_revision.ensure_null(self.branch.last_revision()):
2036
2041
            # merge tree state up to new branch tip.
2037
2042
            basis = self.basis_tree()
2038
2043
            basis.lock_read()
2061
2066
            for parent in merges:
2062
2067
                parent_trees.append(
2063
2068
                    (parent, self.branch.repository.revision_tree(parent)))
2064
 
            if old_tip is not None:
 
2069
            if (old_tip is not None and not _mod_revision.is_null(old_tip)):
2065
2070
                parent_trees.append(
2066
2071
                    (old_tip, self.branch.repository.revision_tree(old_tip)))
2067
2072
            self.set_parent_trees(parent_trees)
2070
2075
            # the working tree had the same last-revision as the master
2071
2076
            # branch did. We may still have pivot local work from the local
2072
2077
            # branch into old_tip:
2073
 
            if old_tip is not None:
 
2078
            if (old_tip is not None and not _mod_revision.is_null(old_tip)):
2074
2079
                self.add_parent_tree_id(old_tip)
2075
 
        if old_tip and old_tip != last_rev:
 
2080
        if (old_tip is not None and not _mod_revision.is_null(old_tip)
 
2081
            and old_tip != last_rev):
2076
2082
            # our last revision was not the prior branch last revision
2077
2083
            # and we have converted that last revision to a pending merge.
2078
2084
            # base is somewhere between the branch tip now
2594
2600
        if not isinstance(a_bzrdir.transport, LocalTransport):
2595
2601
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
2596
2602
        branch = a_bzrdir.open_branch()
2597
 
        if revision_id is not None:
 
2603
        if revision_id is None:
 
2604
            revision_id = _mod_revision.ensure_null(branch.last_revision())
 
2605
        else:
2598
2606
            revision_id = osutils.safe_revision_id(revision_id)
2599
 
            branch.lock_write()
2600
 
            try:
2601
 
                revision_history = branch.revision_history()
2602
 
                try:
2603
 
                    position = revision_history.index(revision_id)
2604
 
                except ValueError:
2605
 
                    raise errors.NoSuchRevision(branch, revision_id)
2606
 
                branch.set_revision_history(revision_history[:position + 1])
2607
 
            finally:
2608
 
                branch.unlock()
2609
 
        revision = branch.last_revision()
 
2607
        branch.lock_write()
 
2608
        try:
 
2609
            branch.generate_revision_history(revision_id)
 
2610
        finally:
 
2611
            branch.unlock()
2610
2612
        inv = Inventory()
2611
2613
        wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
2612
2614
                         branch,
2614
2616
                         _internal=True,
2615
2617
                         _format=self,
2616
2618
                         _bzrdir=a_bzrdir)
2617
 
        basis_tree = branch.repository.revision_tree(revision)
 
2619
        basis_tree = branch.repository.revision_tree(revision_id)
2618
2620
        if basis_tree.inventory.root is not None:
2619
2621
            wt.set_root_id(basis_tree.inventory.root.file_id)
2620
2622
        # set the parent list and cache the basis tree.
2621
 
        wt.set_parent_trees([(revision, basis_tree)])
 
2623
        if _mod_revision.is_null(revision_id):
 
2624
            parent_trees = []
 
2625
        else:
 
2626
            parent_trees = [(revision_id, basis_tree)]
 
2627
        wt.set_parent_trees(parent_trees)
2622
2628
        transform.build_tree(basis_tree, wt)
2623
2629
        return wt
2624
2630
 
2695
2701
        control_files.put_utf8('format', self.get_format_string())
2696
2702
        branch = a_bzrdir.open_branch()
2697
2703
        if revision_id is None:
2698
 
            revision_id = branch.last_revision()
 
2704
            revision_id = _mod_revision.ensure_null(branch.last_revision())
2699
2705
        else:
2700
2706
            revision_id = osutils.safe_revision_id(revision_id)
2701
2707
        # WorkingTree3 can handle an inventory which has a unique root id.