← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/versionedfile.py

  • Committer: v.ladeuil+lp at free
  • Date: 2007-05-18 18:20:31 UTC
  • mto: (2485.8.44 bzr.connection.sharing)
  • mto: This revision was merged to the branch mainline in revision 2646.
  • Revision ID: v.ladeuil+lp@free.fr-20070518182031-gbg2cgidv5l20x9p
Takes Robert comments into account.

* bzrlib/transport/ftp.py:
(FtpTransport.__init__): Write a better explanation.

* bzrlib/tests/test_init.py:
(InstrumentedTransport): Just make hooks a class attribute.
(InstrumentedTransport._get_FTP): Run hook directly in the for
loop.
(TransportHooks.run_hook, TransportHooks.uninstall_hook): Not
needed. The hooks should be cleaned up by the test itself.
(TestInit.setUp.cleanup): Resset to default hooks.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/versionedfile.py
21
21
 
22
22
from bzrlib.lazy_import import lazy_import
23
23
lazy_import(globals(), """
 
24
from copy import deepcopy
 
25
import unittest
24
26
 
25
27
from bzrlib import (
26
28
    errors,
27
29
    osutils,
28
 
    multiparent,
29
30
    tsort,
30
31
    revision,
31
32
    ui,
33
34
from bzrlib.transport.memory import MemoryTransport
34
35
""")
35
36
 
36
 
from cStringIO import StringIO
37
 
 
38
37
from bzrlib.inter import InterObject
39
38
from bzrlib.textmerge import TextMerge
40
39
from bzrlib.symbol_versioning import (deprecated_function,
267
266
            result[version_id] = self.get_delta(version_id)
268
267
        return result
269
268
 
270
 
    def make_mpdiffs(self, version_ids):
271
 
        """Create multiparent diffs for specified versions"""
272
 
        knit_versions = set()
273
 
        for version_id in version_ids:
274
 
            knit_versions.add(version_id)
275
 
            knit_versions.update(self.get_parents(version_id))
276
 
        lines = dict(zip(knit_versions,
277
 
            self._get_lf_split_line_list(knit_versions)))
278
 
        diffs = []
279
 
        for version_id in version_ids:
280
 
            target = lines[version_id]
281
 
            parents = [lines[p] for p in self.get_parents(version_id)]
282
 
            if len(parents) > 0:
283
 
                left_parent_blocks = self._extract_blocks(version_id,
284
 
                                                          parents[0], target)
285
 
            else:
286
 
                left_parent_blocks = None
287
 
            diffs.append(multiparent.MultiParent.from_lines(target, parents,
288
 
                         left_parent_blocks))
289
 
        return diffs
290
 
 
291
 
    def _extract_blocks(self, version_id, source, target):
292
 
        return None
293
 
 
294
 
    def add_mpdiffs(self, records):
295
 
        """Add mpdiffs to this versionedfile
296
 
 
297
 
        Records should be iterables of version, parents, expected_sha1,
298
 
        mpdiff.  mpdiff should be a MultiParent instance.
299
 
        """
300
 
        vf_parents = {}
301
 
        for version, parents, expected_sha1, mpdiff in records:
302
 
            mpvf = multiparent.MultiMemoryVersionedFile()
303
 
            needed_parents = [p for p in parents if not mpvf.has_version(p)]
304
 
            parent_lines = self._get_lf_split_line_list(needed_parents)
305
 
            for parent_id, lines in zip(needed_parents, parent_lines):
306
 
                mpvf.add_version(lines, parent_id, [])
307
 
            mpvf.add_diff(mpdiff, version, parents)
308
 
            lines = mpvf.get_line_list([version])[0]
309
 
            version_text = self.add_lines(version, parents, lines, vf_parents)
310
 
            vf_parents[version] = version_text
311
 
            if expected_sha1 != self.get_sha1(version):
312
 
                raise errors.VersionedFileInvalidChecksum(version)
313
 
 
314
269
    def get_sha1(self, version_id):
315
270
        """Get the stored sha1 sum for the given revision.
316
271
        
318
273
        """
319
274
        raise NotImplementedError(self.get_sha1)
320
275
 
321
 
    def get_sha1s(self, version_ids):
322
 
        """Get the stored sha1 sums for the given revisions.
323
 
 
324
 
        :param version_ids: The names of the versions to lookup
325
 
        :return: a list of sha1s in order according to the version_ids
326
 
        """
327
 
        raise NotImplementedError(self.get_sha1)
328
 
 
329
276
    def get_suffixes(self):
330
277
        """Return the file suffixes associated with this versioned file."""
331
278
        raise NotImplementedError(self.get_suffixes)
355
302
        """
356
303
        raise NotImplementedError(self.get_lines)
357
304
 
358
 
    def _get_lf_split_line_list(self, version_ids):
359
 
        return [StringIO(t).readlines() for t in self.get_texts(version_ids)]
360
 
 
361
 
    def get_ancestry(self, version_ids, topo_sorted=True):
 
305
    def get_ancestry(self, version_ids):
362
306
        """Return a list of all ancestors of given version(s). This
363
307
        will not include the null revision.
364
308
 
365
 
        This list will not be topologically sorted if topo_sorted=False is
366
 
        passed.
367
 
 
368
309
        Must raise RevisionNotPresent if any of the given versions are
369
310
        not present in file history."""
370
311
        if isinstance(version_ids, basestring):
740
681
                    else:
741
682
                        new_version_ids.add(version)
742
683
                return new_version_ids
 
684
 
 
685
 
 
686
class InterVersionedFileTestProviderAdapter(object):
 
687
    """A tool to generate a suite testing multiple inter versioned-file classes.
 
688
 
 
689
    This is done by copying the test once for each InterVersionedFile provider
 
690
    and injecting the transport_server, transport_readonly_server,
 
691
    versionedfile_factory and versionedfile_factory_to classes into each copy.
 
692
    Each copy is also given a new id() to make it easy to identify.
 
693
    """
 
694
 
 
695
    def __init__(self, transport_server, transport_readonly_server, formats):
 
696
        self._transport_server = transport_server
 
697
        self._transport_readonly_server = transport_readonly_server
 
698
        self._formats = formats
 
699
    
 
700
    def adapt(self, test):
 
701
        result = unittest.TestSuite()
 
702
        for (interversionedfile_class,
 
703
             versionedfile_factory,
 
704
             versionedfile_factory_to) in self._formats:
 
705
            new_test = deepcopy(test)
 
706
            new_test.transport_server = self._transport_server
 
707
            new_test.transport_readonly_server = self._transport_readonly_server
 
708
            new_test.interversionedfile_class = interversionedfile_class
 
709
            new_test.versionedfile_factory = versionedfile_factory
 
710
            new_test.versionedfile_factory_to = versionedfile_factory_to
 
711
            def make_new_test_id():
 
712
                new_id = "%s(%s)" % (new_test.id(), interversionedfile_class.__name__)
 
713
                return lambda: new_id
 
714
            new_test.id = make_new_test_id()
 
715
            result.addTest(new_test)
 
716
        return result
 
717
 
 
718
    @staticmethod
 
719
    def default_test_list():
 
720
        """Generate the default list of interversionedfile permutations to test."""
 
721
        from bzrlib.weave import WeaveFile
 
722
        from bzrlib.knit import KnitVersionedFile
 
723
        result = []
 
724
        # test the fallback InterVersionedFile from annotated knits to weave
 
725
        result.append((InterVersionedFile, 
 
726
                       KnitVersionedFile,
 
727
                       WeaveFile))
 
728
        for optimiser in InterVersionedFile._optimisers:
 
729
            result.append((optimiser,
 
730
                           optimiser._matching_file_from_factory,
 
731
                           optimiser._matching_file_to_factory
 
732
                           ))
 
733
        # if there are specific combinations we want to use, we can add them 
 
734
        # here.
 
735
        return result