/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/knit.py

  • Committer: Aaron Bentley
  • Date: 2006-11-17 04:06:03 UTC
  • mfrom: (2139 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2162.
  • Revision ID: aaron.bentley@utoronto.ca-20061117040603-pgebxndswvwk26tt
Merge from bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/knit.py
1
 
# Copyright (C) 2005, 2006 by Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
2
# Written by Martin Pool.
3
3
# Modified by Johan Rydberg <jrydberg@gnu.org>
4
4
# Modified by Robert Collins <robert.collins@canonical.com>
77
77
from bzrlib import (
78
78
    cache_utf8,
79
79
    errors,
 
80
    patiencediff,
 
81
    progress,
80
82
    )
81
83
from bzrlib.errors import FileExists, NoSuchFile, KnitError, \
82
84
        InvalidRevisionId, KnitCorrupt, KnitHeaderError, \
521
523
            delta_seq = None
522
524
            for parent_id in parents:
523
525
                merge_content = self._get_content(parent_id, parent_texts)
524
 
                seq = KnitSequenceMatcher(None, merge_content.text(), content.text())
 
526
                seq = patiencediff.PatienceSequenceMatcher(
 
527
                                   None, merge_content.text(), content.text())
525
528
                if delta_seq is None:
526
529
                    # setup a delta seq to reuse.
527
530
                    delta_seq = seq
538
541
                reference_content = self._get_content(parents[0], parent_texts)
539
542
                new_texts = content.text()
540
543
                old_texts = reference_content.text()
541
 
                delta_seq = KnitSequenceMatcher(None, old_texts, new_texts)
 
544
                delta_seq = patiencediff.PatienceSequenceMatcher(
 
545
                                                 None, old_texts, new_texts)
542
546
            return self._make_line_delta(delta_seq, content)
543
547
 
544
548
    def _make_line_delta(self, delta_seq, new_content):
798
802
            text_map[version_id] = text 
799
803
        return text_map, final_content 
800
804
 
801
 
    def iter_lines_added_or_present_in_versions(self, version_ids=None):
 
805
    def iter_lines_added_or_present_in_versions(self, version_ids=None, 
 
806
                                                pb=None):
802
807
        """See VersionedFile.iter_lines_added_or_present_in_versions()."""
803
808
        if version_ids is None:
804
809
            version_ids = self.versions()
 
810
        if pb is None:
 
811
            pb = progress.DummyProgress()
805
812
        # we don't care about inclusions, the caller cares.
806
813
        # but we need to setup a list of records to visit.
807
814
        # we need version_id, position, length
819
826
                data_pos, length = self._index.get_position(version_id)
820
827
                version_id_records.append((version_id, data_pos, length))
821
828
 
822
 
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
823
829
        count = 0
824
830
        total = len(version_id_records)
825
 
        try:
 
831
        pb.update('Walking content.', count, total)
 
832
        for version_id, data, sha_value in \
 
833
            self._data.read_records_iter(version_id_records):
826
834
            pb.update('Walking content.', count, total)
827
 
            for version_id, data, sha_value in \
828
 
                self._data.read_records_iter(version_id_records):
829
 
                pb.update('Walking content.', count, total)
830
 
                method = self._index.get_method(version_id)
831
 
                version_idx = self._index.lookup(version_id)
832
 
                assert method in ('fulltext', 'line-delta')
833
 
                if method == 'fulltext':
834
 
                    content = self.factory.parse_fulltext(data, version_idx)
835
 
                    for line in content.text():
 
835
            method = self._index.get_method(version_id)
 
836
            version_idx = self._index.lookup(version_id)
 
837
            assert method in ('fulltext', 'line-delta')
 
838
            if method == 'fulltext':
 
839
                content = self.factory.parse_fulltext(data, version_idx)
 
840
                for line in content.text():
 
841
                    yield line
 
842
            else:
 
843
                delta = self.factory.parse_line_delta(data, version_idx)
 
844
                for start, end, count, lines in delta:
 
845
                    for origin, line in lines:
836
846
                        yield line
837
 
                else:
838
 
                    delta = self.factory.parse_line_delta(data, version_idx)
839
 
                    for start, end, count, lines in delta:
840
 
                        for origin, line in lines:
841
 
                            yield line
842
 
                count +=1
843
 
            pb.update('Walking content.', total, total)
844
 
            pb.finished()
845
 
        except:
846
 
            pb.update('Walking content.', total, total)
847
 
            pb.finished()
848
 
            raise
 
847
            count +=1
 
848
        pb.update('Walking content.', total, total)
849
849
        
850
850
    def num_versions(self):
851
851
        """See VersionedFile.num_versions()."""
1256
1256
        """
1257
1257
        lines = []
1258
1258
        encode_utf8 = cache_utf8.encode
1259
 
        for version_id, options, pos, size, parents in versions:
1260
 
            line = "\n%s %s %s %s %s :" % (encode_utf8(version_id),
1261
 
                                           ','.join(options),
1262
 
                                           pos,
1263
 
                                           size,
1264
 
                                           self._version_list_to_index(parents))
1265
 
            assert isinstance(line, str), \
1266
 
                'content must be utf-8 encoded: %r' % (line,)
1267
 
            lines.append(line)
1268
 
        if not self._need_to_create:
1269
 
            self._transport.append_bytes(self._filename, ''.join(lines))
1270
 
        else:
1271
 
            sio = StringIO()
1272
 
            sio.write(self.HEADER)
1273
 
            sio.writelines(lines)
1274
 
            sio.seek(0)
1275
 
            self._transport.put_file_non_atomic(self._filename, sio,
1276
 
                                create_parent_dir=self._create_parent_dir,
1277
 
                                mode=self._file_mode,
1278
 
                                dir_mode=self._dir_mode)
1279
 
            self._need_to_create = False
1280
 
 
1281
 
        # cache after writing, so that a failed write leads to missing cache
1282
 
        # entries not extra ones. XXX TODO: RBC 20060502 in the event of a 
1283
 
        # failure, reload the index or flush it or some such, to prevent
1284
 
        # writing records that did complete twice.
1285
 
        for version_id, options, pos, size, parents in versions:
1286
 
            self._cache_version(version_id, options, pos, size, parents)
1287
 
        
 
1259
        orig_history = self._history[:]
 
1260
        orig_cache = self._cache.copy()
 
1261
 
 
1262
        try:
 
1263
            for version_id, options, pos, size, parents in versions:
 
1264
                line = "\n%s %s %s %s %s :" % (encode_utf8(version_id),
 
1265
                                               ','.join(options),
 
1266
                                               pos,
 
1267
                                               size,
 
1268
                                               self._version_list_to_index(parents))
 
1269
                assert isinstance(line, str), \
 
1270
                    'content must be utf-8 encoded: %r' % (line,)
 
1271
                lines.append(line)
 
1272
                self._cache_version(version_id, options, pos, size, parents)
 
1273
            if not self._need_to_create:
 
1274
                self._transport.append_bytes(self._filename, ''.join(lines))
 
1275
            else:
 
1276
                sio = StringIO()
 
1277
                sio.write(self.HEADER)
 
1278
                sio.writelines(lines)
 
1279
                sio.seek(0)
 
1280
                self._transport.put_file_non_atomic(self._filename, sio,
 
1281
                                    create_parent_dir=self._create_parent_dir,
 
1282
                                    mode=self._file_mode,
 
1283
                                    dir_mode=self._dir_mode)
 
1284
                self._need_to_create = False
 
1285
        except:
 
1286
            # If any problems happen, restore the original values and re-raise
 
1287
            self._history = orig_history
 
1288
            self._cache = orig_cache
 
1289
            raise
 
1290
 
1288
1291
    def has_version(self, version_id):
1289
1292
        """True if the version is in the index."""
1290
1293
        return (version_id in self._cache)