← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/versionedfile.py

(igc) Improve paths are not versioned reporting (Benoît PIERRE)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/versionedfile.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
2
2
#
3
3
# Authors:
4
4
#   Johan Rydberg <jrydberg@gnu.org>
30
30
import urllib
31
31
 
32
32
from bzrlib import (
33
 
    annotate,
34
33
    errors,
35
 
    graph as _mod_graph,
36
34
    groupcompress,
37
35
    index,
38
36
    knit,
45
43
from bzrlib.graph import DictParentsProvider, Graph, StackedParentsProvider
46
44
from bzrlib.transport.memory import MemoryTransport
47
45
""")
 
46
from bzrlib.inter import InterObject
48
47
from bzrlib.registry import Registry
49
48
from bzrlib.symbol_versioning import *
50
49
from bzrlib.textmerge import TextMerge
175
174
        self.key = key
176
175
        self.parents = None
177
176
 
178
 
    def get_bytes_as(self, storage_kind):
179
 
        raise ValueError('A request was made for key: %s, but that'
180
 
                         ' content is not available, and the calling'
181
 
                         ' code does not handle if it is missing.'
182
 
                         % (self.key,))
183
 
 
184
177
 
185
178
class AdapterFactory(ContentFactory):
186
179
    """A content factory to adapt between key prefix's."""
913
906
        raise NotImplementedError(self.annotate)
914
907
 
915
908
    def check(self, progress_bar=None):
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
 
        """
 
909
        """Check this object for integrity."""
926
910
        raise NotImplementedError(self.check)
927
911
 
928
912
    @staticmethod
929
913
    def check_not_reserved_id(version_id):
930
914
        revision.check_not_reserved_id(version_id)
931
915
 
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
 
 
939
916
    def _check_lines_not_unicode(self, lines):
940
917
        """Check that lines being added to a versioned file are not unicode."""
941
918
        for line in lines:
948
925
            if '\n' in line[:-1]:
949
926
                raise errors.BzrBadParameterContainsNewline("lines")
950
927
 
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
 
 
965
928
    def get_parent_map(self, keys):
966
929
        """Get a map of the parents of keys.
967
930
 
1159
1122
            result.append((prefix + (origin,), line))
1160
1123
        return result
1161
1124
 
1162
 
    def get_annotator(self):
1163
 
        return annotate.Annotator(self)
1164
 
 
1165
 
    def check(self, progress_bar=None, keys=None):
 
1125
    def check(self, progress_bar=None):
1166
1126
        """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.
1170
1127
        for prefix, vf in self._iter_all_components():
1171
1128
            vf.check()
1172
 
        if keys is not None:
1173
 
            return self.get_record_stream(keys, 'unordered', True)
1174
1129
 
1175
1130
    def get_parent_map(self, keys):
1176
1131
        """Get a map of the parents of keys.
1425
1380
    def __init__(self, plan, a_marker=TextMerge.A_MARKER,
1426
1381
                 b_marker=TextMerge.B_MARKER):
1427
1382
        TextMerge.__init__(self, a_marker, b_marker)
1428
 
        self.plan = list(plan)
 
1383
        self.plan = plan
1429
1384
 
1430
1385
    def _merge_struct(self):
1431
1386
        lines_a = []
1489
1444
        for struct in outstanding_struct():
1490
1445
            yield struct
1491
1446
 
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
 
 
1546
1447
 
1547
1448
class WeaveMerge(PlanWeaveMerge):
1548
1449
    """Weave merge that takes a VersionedFile and two versions as its input."""
1646
1547
            record.get_bytes_as(record.storage_kind) call.
1647
1548
        """
1648
1549
        self._bytes_iterator = bytes_iterator
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,
 
1550
        self._kind_factory = {'knit-ft-gz':knit.knit_network_to_record,
 
1551
            'knit-delta-gz':knit.knit_network_to_record,
 
1552
            'knit-annotated-ft-gz':knit.knit_network_to_record,
 
1553
            'knit-annotated-delta-gz':knit.knit_network_to_record,
 
1554
            'knit-delta-closure':knit.knit_delta_closure_to_records,
 
1555
            'fulltext':fulltext_network_to_record,
 
1556
            'groupcompress-block':groupcompress.network_block_to_records,
1657
1557
            }
1658
1558
 
1659
1559
    def read(self):