← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/knit.py

  • Committer: Martin Pool
  • Date: 2008-04-24 07:22:53 UTC
  • mto: This revision was merged to the branch mainline in revision 3415.
  • Revision ID: mbp@sourcefrog.net-20080424072253-opmjij7xfy38w27f
Remove every assert statement from bzrlib!

Depending on the context they are:

 * turned into an explicit if/raise of either AssertionError 
   or something more specific -- particularly where they protect
   programming interfaces, complex invariants, or data file integrity
 * removed, if they're redundant with a later check, not protecting
   a meaningful invariant
 * turned into a selftest method on tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/knit.py
301
301
        """
302
302
        method, noeol = record_details
303
303
        if method == 'line-delta':
304
 
            assert base_content is not None
305
304
            if copy_base_content:
306
305
                content = base_content.copy()
307
306
            else:
693
692
                # put them in anywhere, but we hope that sending them soon
694
693
                # after the fulltext will give good locality in the receiver
695
694
                ready_to_send[:0] = deferred.pop(version_id)
696
 
        assert len(deferred) == 0, \
697
 
            "Still have compressed child versions waiting to be sent"
 
695
        if not (len(deferred) == 0):
 
696
            raise AssertionError("Still have compressed child versions waiting to be sent")
698
697
        # XXX: The stream format is such that we cannot stream it - we have to
699
698
        # know the length of all the data a-priori.
700
699
        raw_datum = []
703
702
            (version_id2, options, _, parents) in \
704
703
            izip(self._data.read_records_iter_raw(copy_queue_records),
705
704
                 temp_version_list):
706
 
            assert version_id == version_id2, \
707
 
                'logic error, inconsistent results'
 
705
            if not (version_id == version_id2):
 
706
                raise AssertionError('logic error, inconsistent results')
708
707
            raw_datum.append(raw_data)
709
708
            result_version_list.append(
710
709
                (version_id, options, len(raw_data), parents))
1049
1048
            # I/O and the time spend applying deltas.
1050
1049
            delta = self._check_should_delta(present_parents)
1051
1050
 
1052
 
        assert isinstance(version_id, str)
1053
1051
        content = self.factory.make(lines, version_id)
1054
1052
        if delta or (self.factory.annotated and len(present_parents) > 0):
1055
1053
            # Merge annotations from parent texts if needed.
1215
1213
            enumerate(self._data.read_records_iter(version_id_records)):
1216
1214
            pb.update('Walking content.', version_idx, total)
1217
1215
            method = self._index.get_method(version_id)
1218
 
 
1219
 
            assert method in ('fulltext', 'line-delta')
1220
1216
            if method == 'fulltext':
1221
1217
                line_iterator = self.factory.get_fulltext_content(data)
1222
 
            else:
 
1218
            elif method == 'line-delta':
1223
1219
                line_iterator = self.factory.get_linedelta_content(data)
 
1220
            else:
 
1221
                raise ValueError('invalid method %r' % (method,))
1224
1222
            # XXX: It might be more efficient to yield (version_id,
1225
1223
            # line_iterator) in the future. However for now, this is a simpler
1226
1224
            # change to integrate into the rest of the codebase. RBC 20071110
1537
1535
                                               pos,
1538
1536
                                               size,
1539
1537
                                               self._version_list_to_index(parents))
1540
 
                assert isinstance(line, str), \
1541
 
                    'content must be utf-8 encoded: %r' % (line,)
1542
1538
                lines.append(line)
1543
1539
                self._cache_version(version_id, options, pos, size, tuple(parents))
1544
1540
            if not self._need_to_create:
1804
1800
        compression_parents = an_entry[3][1]
1805
1801
        if not compression_parents:
1806
1802
            return None
1807
 
        assert len(compression_parents) == 1
1808
1803
        return compression_parents[0]
1809
1804
 
1810
1805
    def _get_method(self, node):
1991
1986
            tuple - (index, pos, length), where the index field is always None
1992
1987
            for the .knit access method.
1993
1988
        """
1994
 
        assert type(raw_data) == str, \
1995
 
            'data must be plain bytes was %s' % type(raw_data)
1996
1989
        if not self._need_to_create:
1997
1990
            base = self._transport.append_bytes(self._filename, raw_data)
1998
1991
        else:
2075
2068
            tuple - (index, pos, length), where the index field is the 
2076
2069
            write_index object supplied to the PackAccess object.
2077
2070
        """
2078
 
        assert type(raw_data) == str, \
2079
 
            'data must be plain bytes was %s' % type(raw_data)
2080
2071
        result = []
2081
2072
        offset = 0
2082
2073
        for size in sizes:
2175
2166
        # use a generator for memory friendliness
2176
2167
        for from_backing_knit, version_id, start, end in memos_for_retrieval:
2177
2168
            if not from_backing_knit:
2178
 
                assert version_id is self.stream_index
 
2169
                if version_id is not self.stream_index:
 
2170
                    raise AssertionError()
2179
2171
                yield self.data[start:end]
2180
2172
                continue
2181
2173
            # we have been asked to thunk. This thunking only occurs when
2402
2394
                                     digest)],
2403
2395
            dense_lines or lines,
2404
2396
            ["end %s\n" % version_id]))
2405
 
        assert bytes.__class__ == str
2406
2397
        compressed_bytes = bytes_to_gzip(bytes)
2407
2398
        return len(compressed_bytes), compressed_bytes
2408
2399
 
2590
2581
 
2591
2582
    def join(self, pb=None, msg=None, version_ids=None, ignore_missing=False):
2592
2583
        """See InterVersionedFile.join."""
2593
 
        assert isinstance(self.source, KnitVersionedFile)
2594
 
        assert isinstance(self.target, KnitVersionedFile)
2595
 
 
2596
2584
        # If the source and target are mismatched w.r.t. annotations vs
2597
2585
        # plain, the data needs to be converted accordingly
2598
2586
        if self.source.factory.annotated == self.target.factory.annotated:
2644
2632
                    # * already have it or
2645
2633
                    # * have it scheduled already
2646
2634
                    # otherwise we don't care
2647
 
                    assert (self.target.has_version(parent) or
 
2635
                    if not (self.target.has_version(parent) or
2648
2636
                            parent in copy_set or
2649
 
                            not self.source.has_version(parent))
 
2637
                            not self.source.has_version(parent)):
 
2638
                        raise AssertionError("problem joining parent %r "
 
2639
                            "from %r to %r"
 
2640
                            % (parent, self.source, self.target))
2650
2641
                index_memo = self.source._index.get_position(version_id)
2651
2642
                copy_queue_records.append((version_id, index_memo))
2652
2643
                copy_queue.append((version_id, options, parents))
2661
2652
                (version_id2, options, parents) in \
2662
2653
                izip(self.source._data.read_records_iter_raw(copy_queue_records),
2663
2654
                     copy_queue):
2664
 
                assert version_id == version_id2, 'logic error, inconsistent results'
 
2655
                if not (version_id == version_id2):
 
2656
                    raise AssertionError('logic error, inconsistent results')
2665
2657
                count = count + 1
2666
2658
                pb.update("Joining knit", count, total)
2667
2659
                if converter:
2710
2702
 
2711
2703
    def join(self, pb=None, msg=None, version_ids=None, ignore_missing=False):
2712
2704
        """See InterVersionedFile.join."""
2713
 
        assert isinstance(self.source, bzrlib.weave.Weave)
2714
 
        assert isinstance(self.target, KnitVersionedFile)
2715
 
 
2716
2705
        version_ids = self._get_source_version_ids(version_ids, ignore_missing)
2717
2706
 
2718
2707
        if not version_ids:
2744
2733
                # check that its will be a consistent copy:
2745
2734
                for parent in parents:
2746
2735
                    # if source has the parent, we must already have it
2747
 
                    assert (self.target.has_version(parent))
 
2736
                    if not self.target.has_version(parent):
 
2737
                        raise AssertionError("%r does not have parent %r"
 
2738
                            % (self.target, parent))
2748
2739
                self.target.add_lines(
2749
2740
                    version_id, parents, self.source.get_lines(version_id))
2750
2741
                count = count + 1
2920
2911
                # add a key, no parents
2921
2912
                self._revision_id_graph[missing_version] = ()
2922
2913
                pending.discard(missing_version) # don't look for it
2923
 
        # XXX: This should probably be a real exception, as it is a data
2924
 
        #      inconsistency
2925
 
        assert not self._ghosts.intersection(self._compression_children), \
2926
 
            "We cannot have nodes which have a compression parent of a ghost."
 
2914
        if self._ghosts.intersection(self._compression_children):
 
2915
            raise KnitCorrupt(
 
2916
                "We cannot have nodes which have a ghost compression parent:\n"
 
2917
                "ghosts: %r\n"
 
2918
                "compression children: %r"
 
2919
                % (self._ghosts, self._compression_children))
2927
2920
        # Cleanout anything that depends on a ghost so that we don't wait for
2928
2921
        # the ghost to show up
2929
2922
        for node in self._ghosts:
2957
2950
            if len(parent_ids) == 0:
2958
2951
                # There are no parents for this node, so just add it
2959
2952
                # TODO: This probably needs to be decoupled
2960
 
                assert compression_parent is None
2961
2953
                fulltext_content, delta = self._knit.factory.parse_record(
2962
2954
                    rev_id, record, record_details, None)
2963
2955
                fulltext = self._add_fulltext_content(rev_id, fulltext_content)
2974
2966
                 record_details) = self._all_build_details[rev_id]
2975
2967
                if compression_parent is not None:
2976
2968
                    comp_children = self._compression_children[compression_parent]
2977
 
                    assert rev_id in comp_children
 
2969
                    if rev_id not in comp_children:
 
2970
                        raise AssertionError("%r not in compression children %r"
 
2971
                            % (rev_id, comp_children))
2978
2972
                    # If there is only 1 child, it is safe to reuse this
2979
2973
                    # content
2980
2974
                    reuse_content = (len(comp_children) == 1