← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/versionedfile.py

  • Committer: Robert Collins
  • Date: 2010-05-06 23:41:35 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506234135-yivbzczw1sejxnxc
Lock methods on ``Tree``, ``Branch`` and ``Repository`` are now
expected to return an object which can be used to unlock them. This reduces
duplicate code when using cleanups. The previous 'tokens's returned by
``Branch.lock_write`` and ``Repository.lock_write`` are now attributes
on the result of the lock_write. ``repository.RepositoryWriteLockResult``
and ``branch.BranchWriteLockResult`` document this. (Robert Collins)

``log._get_info_for_log_files`` now takes an add_cleanup callable.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/versionedfile.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2006-2010 Canonical Ltd
2
2
#
3
3
# Authors:
4
4
#   Johan Rydberg <jrydberg@gnu.org>
32
32
from bzrlib import (
33
33
    annotate,
34
34
    errors,
 
35
    graph as _mod_graph,
35
36
    groupcompress,
36
37
    index,
37
38
    knit,
44
45
from bzrlib.graph import DictParentsProvider, Graph, StackedParentsProvider
45
46
from bzrlib.transport.memory import MemoryTransport
46
47
""")
47
 
from bzrlib.inter import InterObject
48
48
from bzrlib.registry import Registry
49
49
from bzrlib.symbol_versioning import *
50
50
from bzrlib.textmerge import TextMerge
913
913
        raise NotImplementedError(self.annotate)
914
914
 
915
915
    def check(self, progress_bar=None):
916
 
        """Check this object for integrity."""
 
916
        """Check this object for integrity.
 
917
        
 
918
        :param progress_bar: A progress bar to output as the check progresses.
 
919
        :param keys: Specific keys within the VersionedFiles to check. When
 
920
            this parameter is not None, check() becomes a generator as per
 
921
            get_record_stream. The difference to get_record_stream is that
 
922
            more or deeper checks will be performed.
 
923
        :return: None, or if keys was supplied a generator as per
 
924
            get_record_stream.
 
925
        """
917
926
        raise NotImplementedError(self.check)
918
927
 
919
928
    @staticmethod
920
929
    def check_not_reserved_id(version_id):
921
930
        revision.check_not_reserved_id(version_id)
922
931
 
 
932
    def clear_cache(self):
 
933
        """Clear whatever caches this VersionedFile holds.
 
934
 
 
935
        This is generally called after an operation has been performed, when we
 
936
        don't expect to be using this versioned file again soon.
 
937
        """
 
938
 
923
939
    def _check_lines_not_unicode(self, lines):
924
940
        """Check that lines being added to a versioned file are not unicode."""
925
941
        for line in lines:
932
948
            if '\n' in line[:-1]:
933
949
                raise errors.BzrBadParameterContainsNewline("lines")
934
950
 
 
951
    def get_known_graph_ancestry(self, keys):
 
952
        """Get a KnownGraph instance with the ancestry of keys."""
 
953
        # most basic implementation is a loop around get_parent_map
 
954
        pending = set(keys)
 
955
        parent_map = {}
 
956
        while pending:
 
957
            this_parent_map = self.get_parent_map(pending)
 
958
            parent_map.update(this_parent_map)
 
959
            pending = set()
 
960
            map(pending.update, this_parent_map.itervalues())
 
961
            pending = pending.difference(parent_map)
 
962
        kg = _mod_graph.KnownGraph(parent_map)
 
963
        return kg
 
964
 
935
965
    def get_parent_map(self, keys):
936
966
        """Get a map of the parents of keys.
937
967
 
1132
1162
    def get_annotator(self):
1133
1163
        return annotate.Annotator(self)
1134
1164
 
1135
 
    def check(self, progress_bar=None):
 
1165
    def check(self, progress_bar=None, keys=None):
1136
1166
        """See VersionedFiles.check()."""
 
1167
        # XXX: This is over-enthusiastic but as we only thunk for Weaves today
 
1168
        # this is tolerable. Ideally we'd pass keys down to check() and 
 
1169
        # have the older VersiondFile interface updated too.
1137
1170
        for prefix, vf in self._iter_all_components():
1138
1171
            vf.check()
 
1172
        if keys is not None:
 
1173
            return self.get_record_stream(keys, 'unordered', True)
1139
1174
 
1140
1175
    def get_parent_map(self, keys):
1141
1176
        """Get a map of the parents of keys.
1390
1425
    def __init__(self, plan, a_marker=TextMerge.A_MARKER,
1391
1426
                 b_marker=TextMerge.B_MARKER):
1392
1427
        TextMerge.__init__(self, a_marker, b_marker)
1393
 
        self.plan = plan
 
1428
        self.plan = list(plan)
1394
1429
 
1395
1430
    def _merge_struct(self):
1396
1431
        lines_a = []
1454
1489
        for struct in outstanding_struct():
1455
1490
            yield struct
1456
1491
 
 
1492
    def base_from_plan(self):
 
1493
        """Construct a BASE file from the plan text."""
 
1494
        base_lines = []
 
1495
        for state, line in self.plan:
 
1496
            if state in ('killed-a', 'killed-b', 'killed-both', 'unchanged'):
 
1497
                # If unchanged, then this line is straight from base. If a or b
 
1498
                # or both killed the line, then it *used* to be in base.
 
1499
                base_lines.append(line)
 
1500
            else:
 
1501
                if state not in ('killed-base', 'irrelevant',
 
1502
                                 'ghost-a', 'ghost-b',
 
1503
                                 'new-a', 'new-b',
 
1504
                                 'conflicted-a', 'conflicted-b'):
 
1505
                    # killed-base, irrelevant means it doesn't apply
 
1506
                    # ghost-a/ghost-b are harder to say for sure, but they
 
1507
                    # aren't in the 'inc_c' which means they aren't in the
 
1508
                    # shared base of a & b. So we don't include them.  And
 
1509
                    # obviously if the line is newly inserted, it isn't in base
 
1510
 
 
1511
                    # If 'conflicted-a' or b, then it is new vs one base, but
 
1512
                    # old versus another base. However, if we make it present
 
1513
                    # in the base, it will be deleted from the target, and it
 
1514
                    # seems better to get a line doubled in the merge result,
 
1515
                    # rather than have it deleted entirely.
 
1516
                    # Example, each node is the 'text' at that point:
 
1517
                    #           MN
 
1518
                    #          /   \
 
1519
                    #        MaN   MbN
 
1520
                    #         |  X  |
 
1521
                    #        MabN MbaN
 
1522
                    #          \   /
 
1523
                    #           ???
 
1524
                    # There was a criss-cross conflict merge. Both sides
 
1525
                    # include the other, but put themselves first.
 
1526
                    # Weave marks this as a 'clean' merge, picking OTHER over
 
1527
                    # THIS. (Though the details depend on order inserted into
 
1528
                    # weave, etc.)
 
1529
                    # LCA generates a plan:
 
1530
                    # [('unchanged', M),
 
1531
                    #  ('conflicted-b', b),
 
1532
                    #  ('unchanged', a),
 
1533
                    #  ('conflicted-a', b),
 
1534
                    #  ('unchanged', N)]
 
1535
                    # If you mark 'conflicted-*' as part of BASE, then a 3-way
 
1536
                    # merge tool will cleanly generate "MaN" (as BASE vs THIS
 
1537
                    # removes one 'b', and BASE vs OTHER removes the other)
 
1538
                    # If you include neither, 3-way creates a clean "MbabN" as
 
1539
                    # THIS adds one 'b', and OTHER does too.
 
1540
                    # It seems that having the line 2 times is better than
 
1541
                    # having it omitted. (Easier to manually delete than notice
 
1542
                    # it needs to be added.)
 
1543
                    raise AssertionError('Unknown state: %s' % (state,))
 
1544
        return base_lines
 
1545
 
1457
1546
 
1458
1547
class WeaveMerge(PlanWeaveMerge):
1459
1548
    """Weave merge that takes a VersionedFile and two versions as its input."""
1557
1646
            record.get_bytes_as(record.storage_kind) call.
1558
1647
        """
1559
1648
        self._bytes_iterator = bytes_iterator
1560
 
        self._kind_factory = {'knit-ft-gz':knit.knit_network_to_record,
1561
 
            'knit-delta-gz':knit.knit_network_to_record,
1562
 
            'knit-annotated-ft-gz':knit.knit_network_to_record,
1563
 
            'knit-annotated-delta-gz':knit.knit_network_to_record,
1564
 
            'knit-delta-closure':knit.knit_delta_closure_to_records,
1565
 
            'fulltext':fulltext_network_to_record,
1566
 
            'groupcompress-block':groupcompress.network_block_to_records,
 
1649
        self._kind_factory = {
 
1650
            'fulltext': fulltext_network_to_record,
 
1651
            'groupcompress-block': groupcompress.network_block_to_records,
 
1652
            'knit-ft-gz': knit.knit_network_to_record,
 
1653
            'knit-delta-gz': knit.knit_network_to_record,
 
1654
            'knit-annotated-ft-gz': knit.knit_network_to_record,
 
1655
            'knit-annotated-delta-gz': knit.knit_network_to_record,
 
1656
            'knit-delta-closure': knit.knit_delta_closure_to_records,
1567
1657
            }
1568
1658
 
1569
1659
    def read(self):