Changeset 18:432718b59587

Timestamp:

07/17/08 00:11:51 (5 years ago)

Author:

Nicolas Evrard <nicoe@…>

Branch:

default

Message:

- correctly import StringIO

• Allow the use of genshi filters on odt templates
  
  • divided the odt templates in three parts to stop abusing generate
    a Template object, a OOStream object, a OOSerializer object
    
  • the stream object is responsible for storing the stream of genshi events
    related to content.xml
    
  • the serializer object knows how to render a stream of event as if it was
    a specific oo file
    
• Fixed tests
  
  • we can now use the events for testing
    
  • ported test.odt to the new directive syntax
    
• The templates and the report are now meant to return genshi streams it is up
  to the framework implementer to call render on them or continue processing
  them.
  

Files:

• relatorio.egg-info/entry_points.txt (modified) (1 diff)
• relatorio/reporting.py (modified) (2 diffs)
• relatorio/templates/odt.py (modified) (3 diffs)
• relatorio/tests/test.odt (modified) (previous)
• relatorio/tests/test_api.py (modified) (5 diffs)
• relatorio/tests/test_odt.py (modified) (5 diffs)

relatorio.egg-info/entry_points.txt

@@ -1 +1 @@
 [relatorio.templates.engines]
 oo.org = relatorio.templates.odt:Template
-trml = relatorio.templates.trml:Template
 pdf = relatorio.templates.pdf:Template
 text = genshi.template:TextTemplate

relatorio/reporting.py

@@ -19 +19 @@
 ###############################################################################
 
-__revision__ = "$Id: reporting.py 17 2008-07-15 10:26:58Z nicoe $"
+__revision__ = "$Id: reporting.py 19 2008-07-17 00:11:51Z nicoe $"
 __metaclass__ = type
 
 import os, sys
 import warnings
-import cStringIO
+from cStringIO import StringIO
 
 import pkg_resources
@@ -104 +104 @@
         self.data_factory = factory
         self.tmpl_loader = loader
+        self.filters = []
 
     def __call__(self, obj, **kwargs):
         template = self.tmpl_loader.load(self.fpath, self.mimetype)
         data = self.data_factory(obj, **kwargs)
-        report = template.generate(**data)
-        if not isinstance(report, (cStringIO.InputType, cStringIO.OutputType)):
-            report = StringIO(str(report))
-        return report
+        return template.generate(**data).filter(*self.filters)
 
     def __repr__(self):

relatorio/templates/odt.py

@@ -19 +19 @@
 ###############################################################################
 
-__revision__ = "$Id: odt.py 14 2008-07-14 22:09:55Z nicoe $"
+__revision__ = "$Id: odt.py 19 2008-07-17 00:11:51Z nicoe $"
 __metaclass__ = type
 
@@ -29 +29 @@
 
 import lxml.etree
+import genshi
 from genshi.template import Template as GenshiTemplate, MarkupTemplate
 
@@ -179 +180 @@
 
     def generate(self, *args, **kwargs):
-        new_oo = StringIO()
-        inzip = zipfile.ZipFile(self.filepath)
-        outzip = zipfile.ZipFile(new_oo, 'w')
-
-        kwargs['make_href'] = ImageHref(outzip)
-        content = str(self.content_template.generate(*args, **kwargs))
-
-        for f in inzip.infolist():
+        serializer = OOSerializer(self.filepath)
+        kwargs['make_href'] = ImageHref(serializer.outzip)
+        content_stream = self.content_template.generate(*args, **kwargs)
+
+        return OOStream(content_stream, serializer)
+
+
+class OOStream(genshi.core.Stream):
+
+    def __init__(self, content_stream, serializer):
+        self.events = content_stream
+        self.serializer = serializer
+
+    def render(self, method=None, encoding='utf-8', out=None, **kwargs):
+        return self.serializer(self.events)
+
+    def serialize(self, method, **kwargs):
+        return self.render(method, **kwargs)
+
+    def __or__(self, function):
+        return OOStream(self.events | function, self.serializer)
+
+
+class OOSerializer:
+
+    def __init__(self, oo_path):
+        self.inzip = zipfile.ZipFile(oo_path)
+        self.new_oo = StringIO()
+        self.outzip = zipfile.ZipFile(self.new_oo, 'w')
+
+    def __call__(self, stream):
+        for f in self.inzip.infolist():
             if f.filename == 'content.xml':
                 s = StringIO()
-                s.write(str(content))
-                outzip.writestr('content.xml', s.getvalue())
-            else:
-                outzip.writestr(f, inzip.read(f.filename))
-        inzip.close()
-        outzip.close()
-
-        return new_oo
-
+                s.write(str(stream))
+                self.outzip.writestr('content.xml', s.getvalue())
+            else:
+                self.outzip.writestr(f, self.inzip.read(f.filename))
+        self.inzip.close()
+        self.outzip.close()
+
+        return self.new_oo

relatorio/tests/test_api.py

@@ -19 +19 @@
 ###############################################################################
 
-__revision__ = "$Id: test_api.py 1 2008-07-04 14:31:52Z nicoe $"
+__revision__ = "$Id: test_api.py 19 2008-07-17 00:11:51Z nicoe $"
 
 import os
@@ -27 +27 @@
                        DefaultFactory, _absolute)
 
+
 class StubObject(object):
 
@@ -32 +33 @@
         for key, val in kwargs.iteritems():
             setattr(self, key, val)
+
+def setup():
+    MIMETemplateLoader.load_template_engines()
 
 
@@ -74 +78 @@
         "Testing the report generation"
         a = StubObject(name='OpenHex')
-        eq_(self.report(a).getvalue(), 'Hello OpenHex.\n')
+        eq_(self.report(a).render(), 'Hello OpenHex.\n')
 
     def test_factory(self):
@@ -92 +96 @@
 
         a = StubObject(name='Foo')
-        eq_(report(a, time="One o'clock").getvalue(), 
+        eq_(report(a, time="One o'clock").render(), 
             "Hi Foo,\nIt's One o'clock to 2 !\n")
-        eq_(report(a, time="One o'clock", y=4).getvalue(), 
+        eq_(report(a, time="One o'clock", y=4).render(), 
             "Hi Foo,\nIt's One o'clock to 5 !\n")
         assert_raises(TypeError, report, a) 

relatorio/tests/test_odt.py

@@ +1 @@
+# -*- encoding: utf-8 -*-
 ###############################################################################
 #
@@ -19 +20 @@
 ###############################################################################
 
-__revision__ = "$Id: test_odt.py 1 2008-07-04 14:31:52Z nicoe $"
+__revision__ = "$Id: test_odt.py 19 2008-07-17 00:11:51Z nicoe $"
 
 import os
@@ -27 +28 @@
 from nose.tools import *
 from genshi.template import MarkupTemplate
+from genshi.filters import Translator
 
-from mimetypes.odt import OOTemplate, NS
+from templates.odt import Template, NS
+
+def pseudo_gettext(string):
+    catalog = {'Mes collègues sont:': 'My collegues are:',
+               'Bonjour,': 'Hello,',
+               'Je suis un test de templating en odt.': 
+                'I am an odt templating test',
+               'Felix da housecat': unicode('Félix le chat de la maison',
+                                            'utf8'),
+              }
+    return catalog.get(string, string)
 
 
@@ -36 +48 @@
         thisdir = os.path.dirname(__file__)
         filepath = os.path.join(thisdir, 'test.odt')
-        self.oot = OOTemplate(file(filepath), filepath)
+        self.oot = Template(file(filepath), filepath)
+        self.data = {'first_name': 'Trente',
+                     'last_name': unicode('Møller', 'utf8'),
+                     'ville': unicode('Liège', 'utf8'),
+                     'friends': [{'first_name': 'Camille', 
+                                  'last_name': 'Salauhpe'},
+                                 {'first_name': 'Mathias',
+                                  'last_name': 'Lechat'}],
+                     'hobbies': ['Music', 'Dancing', 'DJing'],
+                     'animals': ['Felix da housecat', 'Dog eat Dog']}
 
     def test_init(self):
@@ -50 +71 @@
         eq_(root_parsed[0].attrib['{http://genshi.edgewall.org/}replace'], 
             'foo')
+
+    def test_generate(self):
+        stream = self.oot.generate(**self.data)
+        rendered = stream.events.render()
+        assert 'Bonjour,' in rendered
+        assert 'Trente' in rendered
+        assert 'Møller' in rendered
+        assert 'Dog eat Dog' in rendered
+        assert 'Felix da housecat' in rendered
+
+    def test_filters(self):
+        stream = self.oot.generate(**self.data)
+        translated = stream.filter(Translator(pseudo_gettext))
+        content_xml = translated.events.render()
+        assert "Hello," in content_xml
+        assert "I am an odt templating test" in content_xml
+        assert 'Felix da housecat' not in content_xml
+        assert 'Félix le chat de la maison' in content_xml