← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Robert Collins
  • Date: 2006-09-05 08:14:23 UTC
  • mto: (1852.16.2 Tree.walkdirs)
  • mto: This revision was merged to the branch mainline in revision 1993.
  • Revision ID: robertc@robertcollins.net-20060905081423-b1bc9b092a9f8597
Deprecate WorkingTree.last_revision.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
96
96
        deprecated_function,
97
97
        DEPRECATED_PARAMETER,
98
98
        zero_eight,
 
99
        zero_eleven,
99
100
        )
100
101
from bzrlib.trace import mutter, note
101
102
from bzrlib.transform import build_tree
399
400
        If the left most parent is a ghost then the returned tree will be an
400
401
        empty tree - one obtained by calling repository.revision_tree(None).
401
402
        """
402
 
        revision_id = self.last_revision()
403
 
        if revision_id is not None:
 
403
        try:
 
404
            revision_id = self.get_parent_ids()[0]
 
405
        except IndexError:
 
406
            # no parents, return an empty revision tree.
 
407
            # in the future this should return the tree for
 
408
            # 'empty:' - the implicit root empty tree.
 
409
            return self.branch.repository.revision_tree(None)
 
410
        else:
404
411
            try:
405
412
                xml = self.read_basis_inventory()
406
413
                inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
410
417
            if inv is not None and inv.revision_id == revision_id:
411
418
                return bzrlib.tree.RevisionTree(self.branch.repository, inv,
412
419
                                                revision_id)
413
 
        # FIXME? RBC 20060403 should we cache the inventory here ?
 
420
        # No cached copy available, retrieve from the repository.
 
421
        # FIXME? RBC 20060403 should we cache the inventory locally
 
422
        # at this point ?
414
423
        try:
415
424
            return self.branch.repository.revision_tree(revision_id)
416
425
        except errors.RevisionNotPresent:
486
495
        This implementation reads the pending merges list and last_revision
487
496
        value and uses that to decide what the parents list should be.
488
497
        """
489
 
        last_rev = self.last_revision()
 
498
        last_rev = self._last_revision()
490
499
        if last_rev is None:
491
500
            parents = []
492
501
        else:
1320
1329
    def kind(self, file_id):
1321
1330
        return file_kind(self.id2abspath(file_id))
1322
1331
 
1323
 
    @needs_read_lock
 
1332
    @deprecated_method(zero_eleven)
1324
1333
    def last_revision(self):
1325
1334
        """Return the last revision id of this working tree.
1326
1335
 
1327
 
        In early branch formats this was == the branch last_revision,
 
1336
        In early branch formats this was the same as the branch last_revision,
1328
1337
        but that cannot be relied upon - for working tree operations,
1329
 
        always use tree.last_revision().
 
1338
        always use tree.last_revision(). This returns the left most parent id,
 
1339
        or None if there are no parents.
 
1340
 
 
1341
        This was deprecated as of 0.10. Please use get_parent_ids now.
1330
1342
        """
 
1343
        return self._last_revision()
 
1344
 
 
1345
    @needs_read_lock
 
1346
    def _last_revision(self):
 
1347
        """helper for get_parent_ids."""
1331
1348
        return self.branch.last_revision()
1332
1349
 
1333
1350
    def is_locked(self):
1560
1577
        # local work is unreferenced and will appear to have been lost.
1561
1578
        # 
1562
1579
        result = 0
1563
 
        if self.last_revision() != self.branch.last_revision():
 
1580
        try:
 
1581
            last_rev = self.get_parent_ids()[0]
 
1582
        except IndexError:
 
1583
            last_rev = None
 
1584
        if last_rev != self.branch.last_revision():
1564
1585
            # merge tree state up to new branch tip.
1565
1586
            basis = self.basis_tree()
1566
1587
            to_tree = self.branch.basis_tree()
1584
1605
                parent_trees.append(
1585
1606
                    (old_tip, self.branch.repository.revision_tree(old_tip)))
1586
1607
            self.set_parent_trees(parent_trees)
 
1608
            last_rev = parent_trees[0][0]
1587
1609
        else:
1588
1610
            # the working tree had the same last-revision as the master
1589
1611
            # branch did. We may still have pivot local work from the local
1590
1612
            # branch into old_tip:
1591
1613
            if old_tip is not None:
1592
1614
                self.add_parent_tree_id(old_tip)
1593
 
        if old_tip and old_tip != self.last_revision():
 
1615
        if old_tip and old_tip != last_rev:
1594
1616
            # our last revision was not the prior branch last revision
1595
1617
            # and we have converted that last revision to a pending merge.
1596
1618
            # base is somewhere between the branch tip now
1682
1704
    """
1683
1705
 
1684
1706
    @needs_read_lock
1685
 
    def last_revision(self):
1686
 
        """See WorkingTree.last_revision."""
 
1707
    def _last_revision(self):
 
1708
        """See WorkingTree._last_revision."""
1687
1709
        try:
1688
1710
            return self._control_files.get_utf8('last-revision').read()
1689
1711
        except NoSuchFile: