Merge 'issue_59' into development: closing issue #59 (Template -> Renderer)

pystache/commands.py

@@ -20,7 +20,7 @@ import sys
 #   ValueError: Attempted relative import in non-package
 #
 from pystache.loader import Loader
-from pystache.template import Template
+from pystache.renderer import Renderer
 
 
 USAGE = """\
@@ -64,8 +64,10 @@ def main(sys_argv):
     except IOError:
         context = json.loads(context)
 
-    template = Template(template)
-    print(template.render(context))
+    renderer = Renderer()
+
+    rendered = renderer.render(template, context)
+    print rendered
 
 
 if __name__=='__main__':

pystache/init.py

@@ -5,12 +5,12 @@ This module contains the initialization logic called by __init__.py.
 
 """
 
-from .template import Template
+from .renderer import Renderer
 from .view import View
 from .loader import Loader
 
 
-__all__ = ['Template', 'View', 'Loader', 'render']
+__all__ = ['render', 'Loader', 'Renderer', 'View']
 
 
 def render(template, context=None, **kwargs):
@@ -18,5 +18,5 @@ def render(template, context=None, **kwargs):
     Return the given template string rendered using the given context.
 
     """
-    template = Template(template)
-    return template.render(context, **kwargs)
+    renderer = Renderer()
+    return renderer.render(template, context, **kwargs)

pystache/template.py → pystache/renderer.py

@@ -20,22 +20,20 @@ except ImportError:
     pass
 
 
-class Template(object):
+class Renderer(object):
 
-    def __init__(self, template=None, load_template=None, output_encoding=None, escape=None,
+    # TODO: change load_template to load_partial.
+    def __init__(self, load_template=None, output_encoding=None, escape=None,
                  default_encoding=None, decode_errors='strict'):
         """
-        Construct a Template instance.
+        Construct an instance.
 
         Arguments:
 
-          template: a template string that is either unicode, or of type
-            str and encoded using the encoding named by the default_encoding
-            keyword argument.
-
-          load_template: the function for loading partials.  The function should
-            accept a single template_name parameter and return a template as
-            a string.  Defaults to the default Loader's load_template() method.
+          load_template: a function for loading templates by name, for
+            example when loading partials.  The function should accept a
+            single template_name parameter and return a template as a string.
+            Defaults to the default Loader's load_template() method.
 
           output_encoding: the encoding to use when rendering to a string.
             The argument should be the name of an encoding as a string, for
@@ -84,7 +82,6 @@ class Template(object):
         self.escape = escape
         self.load_template = load_template
         self.output_encoding = output_encoding
-        self.template = template
 
     def _unicode_and_escape(self, s):
         if not isinstance(s, unicode):
@@ -146,9 +143,9 @@ class Template(object):
                               escape=self._unicode_and_escape)
         return engine
 
-    def render(self, context=None, **kwargs):
+    def render(self, template, context=None, **kwargs):
         """
-        Return the template rendered using the given context.
+        Render the given template using the given context.
 
         The return value is a unicode string, unless the output_encoding
         attribute has been set to a non-None value, in which case the
@@ -160,6 +157,10 @@ class Template(object):
 
         Arguments:
 
+          template: a template string that is either unicode, or of type
+            str and encoded using the encoding named by the default_encoding
+            keyword argument.
+
           context: a dictionary, Context, or object (e.g. a View instance).
 
           **kwargs: additional key values to add to the context when rendering.
@@ -169,13 +170,12 @@ class Template(object):
         engine = self._make_render_engine()
         context = self._make_context(context, **kwargs)
 
-        template = self.template
         if not isinstance(template, unicode):
             template = self.unicode(template)
 
-        result = engine.render(template, context)
+        rendered = engine.render(template, context)
 
         if self.output_encoding is not None:
-            result = result.encode(self.output_encoding)
+            rendered = rendered.encode(self.output_encoding)
 
-        return result
+        return rendered

pystache/view.py

@@ -10,7 +10,7 @@ from types import UnboundMethodType
 
 from .context import Context
 from .loader import Loader
-from .template import Template
+from .renderer import Renderer
 
 
 class View(object):
@@ -68,7 +68,7 @@ class View(object):
 
     def _get_template_name(self):
         """
-        Return the name of this Template instance.
+        Return the name of the template to load.
 
         If the template_name attribute is not set, then this method constructs
         the template name from the class name as follows, for example:
@@ -98,9 +98,9 @@ class View(object):
         Return the view rendered using the current context.
 
         """
-        template = Template(self.get_template(), self.load_template, output_encoding=encoding,
-                            escape=escape)
-        return template.render(self.context)
+        template = self.get_template()
+        renderer = Renderer(self.load_template, output_encoding=encoding, escape=escape)
+        return renderer.render(template, self.context)
 
     def get(self, key, default=None):
         return self.context.get(key, default)

tests/test_pystache.py

@@ -2,7 +2,7 @@
 
 import unittest
 import pystache
-from pystache import template
+from pystache import renderer
 
 
 class PystacheTests(object):
@@ -114,16 +114,16 @@ class PystacheWithoutMarkupsafeTests(PystacheTests, unittest.TestCase):
     """Test pystache without markupsafe enabled."""
 
     def setUp(self):
-        self.original_markupsafe = template.markupsafe
-        template.markupsafe = None
+        self.original_markupsafe = renderer.markupsafe
+        renderer.markupsafe = None
 
     def tearDown(self):
-        template.markupsafe = self.original_markupsafe
+        renderer.markupsafe = self.original_markupsafe
 
 
 # If markupsafe is available, then run the same tests again but without
 # disabling markupsafe.
-_BaseClass = unittest.TestCase if template.markupsafe else object
+_BaseClass = unittest.TestCase if renderer.markupsafe else object
 class PystacheWithMarkupsafeTests(PystacheTests, _BaseClass):
 
     """Test pystache with markupsafe enabled."""
@@ -132,5 +132,5 @@ class PystacheWithMarkupsafeTests(PystacheTests, _BaseClass):
     non_strings_expected = """(123 & ['something'])(chris & 0.9)"""
 
     def test_markupsafe_available(self):
-        self.assertTrue(template.markupsafe, "markupsafe isn't available.  "
+        self.assertTrue(renderer.markupsafe, "markupsafe isn't available.  "
             "The with-markupsafe tests shouldn't be running.")

tests/test_template.py → tests/test_renderer.py

@@ -9,25 +9,28 @@ import codecs
 import sys
 import unittest
 
-from pystache import template
-from pystache.template import Template
+from pystache import renderer
+from pystache.renderer import Renderer
 
 
-class TemplateTestCase(unittest.TestCase):
+class RendererTestCase(unittest.TestCase):
 
-    """Test the Template class."""
+    """Test the Renderer class."""
 
     def setUp(self):
         """
         Disable markupsafe.
 
         """
-        self.original_markupsafe = template.markupsafe
-        template.markupsafe = None
+        self.original_markupsafe = renderer.markupsafe
+        renderer.markupsafe = None
 
     def tearDown(self):
         self._restore_markupsafe()
 
+    def _renderer(self):
+        return Renderer()
+
     def _was_markupsafe_imported(self):
         return bool(self.original_markupsafe)
 
@@ -36,7 +39,7 @@ class TemplateTestCase(unittest.TestCase):
         Restore markupsafe to its original state.
 
         """
-        template.markupsafe = self.original_markupsafe
+        renderer.markupsafe = self.original_markupsafe
 
     def test__was_markupsafe_imported(self):
         """
@@ -52,8 +55,8 @@ class TemplateTestCase(unittest.TestCase):
         self.assertEquals(bool(markupsafe), self._was_markupsafe_imported())
 
     def test_init__escape__default_without_markupsafe(self):
-        template = Template()
-        self.assertEquals(template.escape(">'"), ">'")
+        renderer = Renderer()
+        self.assertEquals(renderer.escape(">'"), ">'")
 
     def test_init__escape__default_with_markupsafe(self):
         if not self._was_markupsafe_imported():
@@ -61,73 +64,73 @@ class TemplateTestCase(unittest.TestCase):
             return
         self._restore_markupsafe()
 
-        template = Template()
-        self.assertEquals(template.escape(">'"), ">'")
+        renderer = Renderer()
+        self.assertEquals(renderer.escape(">'"), ">'")
 
     def test_init__escape(self):
         escape = lambda s: "foo" + s
-        template = Template(escape=escape)
-        self.assertEquals(template.escape("bar"), "foobar")
+        renderer = Renderer(escape=escape)
+        self.assertEquals(renderer.escape("bar"), "foobar")
 
     def test_init__default_encoding__default(self):
         """
         Check the default value.
 
         """
-        template = Template()
-        self.assertEquals(template.default_encoding, sys.getdefaultencoding())
+        renderer = Renderer()
+        self.assertEquals(renderer.default_encoding, sys.getdefaultencoding())
 
     def test_init__default_encoding(self):
         """
         Check that the constructor sets the attribute correctly.
 
         """
-        template = Template(default_encoding="foo")
-        self.assertEquals(template.default_encoding, "foo")
+        renderer = Renderer(default_encoding="foo")
+        self.assertEquals(renderer.default_encoding, "foo")
 
     def test_init__decode_errors__default(self):
         """
         Check the default value.
 
         """
-        template = Template()
-        self.assertEquals(template.decode_errors, 'strict')
+        renderer = Renderer()
+        self.assertEquals(renderer.decode_errors, 'strict')
 
     def test_init__decode_errors(self):
         """
         Check that the constructor sets the attribute correctly.
 
         """
-        template = Template(decode_errors="foo")
-        self.assertEquals(template.decode_errors, "foo")
+        renderer = Renderer(decode_errors="foo")
+        self.assertEquals(renderer.decode_errors, "foo")
 
     def test_unicode(self):
-        template = Template()
-        actual = template.literal("abc")
+        renderer = Renderer()
+        actual = renderer.literal("abc")
         self.assertEquals(actual, "abc")
         self.assertEquals(type(actual), unicode)
 
     def test_unicode__default_encoding(self):
-        template = Template()
+        renderer = Renderer()
         s = "é"
 
-        template.default_encoding = "ascii"
-        self.assertRaises(UnicodeDecodeError, template.unicode, s)
+        renderer.default_encoding = "ascii"
+        self.assertRaises(UnicodeDecodeError, renderer.unicode, s)
 
-        template.default_encoding = "utf-8"
-        self.assertEquals(template.unicode(s), u"é")
+        renderer.default_encoding = "utf-8"
+        self.assertEquals(renderer.unicode(s), u"é")
 
     def test_unicode__decode_errors(self):
-        template = Template()
+        renderer = Renderer()
         s = "é"
 
-        template.default_encoding = "ascii"
-        template.decode_errors = "strict"
-        self.assertRaises(UnicodeDecodeError, template.unicode, s)
+        renderer.default_encoding = "ascii"
+        renderer.decode_errors = "strict"
+        self.assertRaises(UnicodeDecodeError, renderer.unicode, s)
 
-        template.decode_errors = "replace"
+        renderer.decode_errors = "replace"
         # U+FFFD is the official Unicode replacement character.
-        self.assertEquals(template.unicode(s), u'\ufffd\ufffd')
+        self.assertEquals(renderer.unicode(s), u'\ufffd\ufffd')
 
     def test_literal__with_markupsafe(self):
         if not self._was_markupsafe_imported():
@@ -135,39 +138,39 @@ class TemplateTestCase(unittest.TestCase):
             return
         self._restore_markupsafe()
 
-        _template = Template()
-        _template.default_encoding = "utf_8"
+        _renderer = Renderer()
+        _renderer.default_encoding = "utf_8"
 
         # Check the standard case.
-        actual = _template.literal("abc")
+        actual = _renderer.literal("abc")
         self.assertEquals(actual, "abc")
-        self.assertEquals(type(actual), template.markupsafe.Markup)
+        self.assertEquals(type(actual), renderer.markupsafe.Markup)
 
         s = "é"
         # Check that markupsafe respects default_encoding.
-        self.assertEquals(_template.literal(s), u"é")
-        _template.default_encoding = "ascii"
-        self.assertRaises(UnicodeDecodeError, _template.literal, s)
+        self.assertEquals(_renderer.literal(s), u"é")
+        _renderer.default_encoding = "ascii"
+        self.assertRaises(UnicodeDecodeError, _renderer.literal, s)
 
         # Check that markupsafe respects decode_errors.
-        _template.decode_errors = "replace"
-        self.assertEquals(_template.literal(s), u'\ufffd\ufffd')
+        _renderer.decode_errors = "replace"
+        self.assertEquals(_renderer.literal(s), u'\ufffd\ufffd')
 
     def test_render__unicode(self):
-        template = Template(u'foo')
-        actual = template.render()
+        renderer = Renderer()
+        actual = renderer.render(u'foo')
         self.assertTrue(isinstance(actual, unicode))
         self.assertEquals(actual, u'foo')
 
     def test_render__str(self):
-        template = Template('foo')
-        actual = template.render()
+        renderer = Renderer()
+        actual = renderer.render('foo')
         self.assertTrue(isinstance(actual, unicode))
         self.assertEquals(actual, 'foo')
 
     def test_render__non_ascii_character(self):
-        template = Template(u'Poincaré')
-        actual = template.render()
+        renderer = Renderer()
+        actual = renderer.render(u'Poincaré')
         self.assertTrue(isinstance(actual, unicode))
         self.assertEquals(actual, u'Poincaré')
 
@@ -176,32 +179,33 @@ class TemplateTestCase(unittest.TestCase):
         Test render(): passing a context.
 
         """
-        template = Template('Hi {{person}}')
-        self.assertEquals(template.render({'person': 'Mom'}), 'Hi Mom')
+        renderer = Renderer()
+        self.assertEquals(renderer.render('Hi {{person}}', {'person': 'Mom'}), 'Hi Mom')
 
     def test_render__context_and_kwargs(self):
         """
         Test render(): passing a context and **kwargs.
 
         """
-        template = Template('Hi {{person1}} and {{person2}}')
-        self.assertEquals(template.render({'person1': 'Mom'}, person2='Dad'), 'Hi Mom and Dad')
+        renderer = Renderer()
+        template = 'Hi {{person1}} and {{person2}}'
+        self.assertEquals(renderer.render(template, {'person1': 'Mom'}, person2='Dad'), 'Hi Mom and Dad')
 
     def test_render__kwargs_and_no_context(self):
         """
         Test render(): passing **kwargs and no context.
 
         """
-        template = Template('Hi {{person}}')
-        self.assertEquals(template.render(person='Mom'), 'Hi Mom')
+        renderer = Renderer()
+        self.assertEquals(renderer.render('Hi {{person}}', person='Mom'), 'Hi Mom')
 
     def test_render__context_and_kwargs__precedence(self):
         """
         Test render(): **kwargs takes precedence over context.
 
         """
-        template = Template('Hi {{person}}')
-        self.assertEquals(template.render({'person': 'Mom'}, person='Dad'), 'Hi Dad')
+        renderer = Renderer()
+        self.assertEquals(renderer.render('Hi {{person}}', {'person': 'Mom'}, person='Dad'), 'Hi Dad')
 
     def test_render__kwargs_does_not_modify_context(self):
         """
@@ -209,14 +213,14 @@ class TemplateTestCase(unittest.TestCase):
 
         """
         context = {}
-        template = Template('Hi {{person}}')
-        template.render(context=context, foo="bar")
+        renderer = Renderer()
+        renderer.render('Hi {{person}}', context=context, foo="bar")
         self.assertEquals(context, {})
 
     def test_render__output_encoding(self):
-        template = Template(u'Poincaré')
-        template.output_encoding = 'utf-8'
-        actual = template.render()
+        renderer = Renderer()
+        renderer.output_encoding = 'utf-8'
+        actual = renderer.render(u'Poincaré')
         self.assertTrue(isinstance(actual, str))
         self.assertEquals(actual, 'Poincaré')
 
@@ -225,29 +229,30 @@ class TemplateTestCase(unittest.TestCase):
         Test passing a non-unicode template with non-ascii characters.
 
         """
-        template = Template("déf", output_encoding="utf-8")
+        renderer = Renderer(output_encoding="utf-8")
+        template = "déf"
 
         # Check that decode_errors and default_encoding are both respected.
-        template.decode_errors = 'ignore'
-        template.default_encoding = 'ascii'
-        self.assertEquals(template.render(), "df")
+        renderer.decode_errors = 'ignore'
+        renderer.default_encoding = 'ascii'
+        self.assertEquals(renderer.render(template), "df")
 
-        template.default_encoding = 'utf_8'
-        self.assertEquals(template.render(), "déf")
+        renderer.default_encoding = 'utf_8'
+        self.assertEquals(renderer.render(template), "déf")
 
-    # By testing that Template.render() constructs the RenderEngine instance
+    # By testing that Renderer.render() constructs the RenderEngine instance
     # correctly, we no longer need to test the rendering code paths through
-    # the Template.  We can test rendering paths through only the RenderEngine
+    # the Renderer.  We can test rendering paths through only the RenderEngine
     # for the same amount of code coverage.
     def test_make_render_engine__load_template(self):
         """
         Test that _make_render_engine() passes the right load_template.
 
         """
-        template = Template()
-        template.load_template = "foo"  # in real life, this would be a function.
+        renderer = Renderer()
+        renderer.load_template = "foo"  # in real life, this would be a function.
 
-        engine = template._make_render_engine()
+        engine = renderer._make_render_engine()
         self.assertEquals(engine.load_template, "foo")
 
     def test_make_render_engine__literal(self):
@@ -255,10 +260,10 @@ class TemplateTestCase(unittest.TestCase):
         Test that _make_render_engine() passes the right literal.
 
         """
-        template = Template()
-        template.literal = "foo"  # in real life, this would be a function.
+        renderer = Renderer()
+        renderer.literal = "foo"  # in real life, this would be a function.
 
-        engine = template._make_render_engine()
+        engine = renderer._make_render_engine()
         self.assertEquals(engine.literal, "foo")
 
     def test_make_render_engine__escape(self):
@@ -266,11 +271,11 @@ class TemplateTestCase(unittest.TestCase):
         Test that _make_render_engine() passes the right escape.
 
         """
-        template = Template()
-        template.unicode = lambda s: s.upper()  # a test version.
-        template.escape = lambda s: "**" + s  # a test version.
+        renderer = Renderer()
+        renderer.unicode = lambda s: s.upper()  # a test version.
+        renderer.escape = lambda s: "**" + s  # a test version.
 
-        engine = template._make_render_engine()
+        engine = renderer._make_render_engine()
         escape = engine.escape
 
         self.assertEquals(escape(u"foo"), "**foo")

tests/test_simple.py

 import unittest
 import pystache
-from pystache import Template
+from pystache import Renderer
 from examples.nested_context import NestedContext
 from examples.complex_view import ComplexView
 from examples.lambdas import Lambdas
@@ -21,7 +21,8 @@ class TestSimple(unittest.TestCase):
 
     def test_empty_context(self):
         view = ComplexView()
-        self.assertEquals(pystache.Template('{{#empty_list}}Shouldnt see me {{/empty_list}}{{^empty_list}}Should see me{{/empty_list}}', view).render(), "Should see me")
+        template = '{{#empty_list}}Shouldnt see me {{/empty_list}}{{^empty_list}}Should see me{{/empty_list}}'
+        self.assertEquals(pystache.Renderer().render(template), "Should see me")
 
     def test_callables(self):
         view = Lambdas()
@@ -38,8 +39,8 @@ class TestSimple(unittest.TestCase):
 
     def test_non_existent_value_renders_blank(self):
         view = Simple()
-
-        self.assertEquals(pystache.Template('{{not_set}} {{blank}}', view).render(), ' ')
+        template = '{{not_set}} {{blank}}'
+        self.assertEquals(pystache.Renderer().render(template), ' ')
 
 
     def test_template_partial_extension(self):