Completed issue #52: "Remove the context parameter from Template.__init__()"

HISTORY.rst

@@ -3,6 +3,8 @@ History
 
 Next Release (version TBD)
 --------------------------
+* API change: pass the context to render to Template.render() instead of
+  Template.__init__(). [cjerdonek]
 * Bugfix: Passing **kwargs to Template() modified the context. [cjerdonek]
 * Bugfix: Passing **kwargs to Template() with no context raised an
   exception. [cjerdonek]

pystache/commands.py

@@ -64,7 +64,8 @@ def main(sys_argv):
     except IOError:
         context = json.loads(context)
 
-    print(Template(template, context).render())
+    template = Template(template)
+    print(template.render(context))
 
 
 if __name__=='__main__':

pystache/init.py

@@ -18,4 +18,5 @@ def render(template, context=None, **kwargs):
     Return the given template string rendered using the given context.
 
     """
-    return Template(template, context, **kwargs).render()
+    template = Template(template)
+    return template.render(context, **kwargs)

pystache/template.py

@@ -62,7 +62,7 @@ class Template(object):
 
     modifiers = Modifiers()
 
-    def __init__(self, template=None, context=None, load_template=None, output_encoding=None, **kwargs):
+    def __init__(self, template=None, load_template=None, output_encoding=None):
         """
         Construct a Template instance.
 
@@ -83,13 +83,23 @@ class Template(object):
             information.
 
         """
-        if context is None:
-            context = {}
-
         if load_template is None:
             loader = Loader()
             load_template = loader.load_template
-            load_template = getattr(context, 'load_template', load_template)
+
+        self.load_template = load_template
+        self.output_encoding = output_encoding
+        self.template = template
+
+        self._compile_regexps()
+
+    def _initialize_context(self, context, **kwargs):
+        """
+        Initialize the context attribute.
+
+        """
+        if context is None:
+            context = {}
 
         if isinstance(context, Context):
             context = context.copy()
@@ -100,11 +110,7 @@ class Template(object):
             context.push(kwargs)
 
         self.context = context
-        self.load_template = load_template
-        self.output_encoding = output_encoding
-        self.template = template
 
-        self._compile_regexps()
 
     def _compile_regexps(self):
         """
@@ -181,8 +187,8 @@ class Template(object):
     def _render_dictionary(self, template, context):
         self.context.push(context)
 
-        template = Template(template, self.context, self.load_template)
-        out = template.render()
+        template = Template(template, load_template=self.load_template)
+        out = template.render(self.context)
 
         self.context.pop()
 
@@ -220,8 +226,8 @@ class Template(object):
     @modifiers.set('>')
     def _render_partial(self, template_name):
         markup = self.load_template(template_name)
-        template = Template(markup, self.context, self.load_template)
-        return template.render()
+        template = Template(markup, load_template=self.load_template)
+        return template.render(self.context)
 
     @modifiers.set('=')
     def _change_delimiter(self, tag_name):
@@ -243,7 +249,7 @@ class Template(object):
         """
         return literal(self.context.get(tag_name, ''))
 
-    def render(self):
+    def render(self, context=None, **kwargs):
         """
         Return the template rendered using the current context.
 
@@ -252,6 +258,8 @@ class Template(object):
         and is encoded using that encoding.
 
         """
+        self._initialize_context(context, **kwargs)
+
         template = self._render_sections(self.template)
         result = self._render_tags(template)
 

pystache/view.py

@@ -93,8 +93,8 @@ class View(object):
         Return the view rendered using the current context.
 
         """
-        template = Template(self.get_template(), self.context, self.load_template, output_encoding=encoding)
-        return template.render()
+        template = Template(self.get_template(), self.load_template, output_encoding=encoding)
+        return template.render(self.context)
 
     def get(self, key, default=None):
         return self.context.get(key, default)

tests/test_simple.py

 import unittest
 import pystache
+from pystache import Template
 from examples.nested_context import NestedContext
 from examples.complex_view import ComplexView
 from examples.lambdas import Lambdas
@@ -8,16 +9,15 @@ from examples.simple import Simple
 
 class TestSimple(unittest.TestCase):
 
-    def test_simple_render(self):
-        self.assertEqual('herp', pystache.Template('{{derp}}', {'derp': 'herp'}).render())
-
     def test_nested_context(self):
         view = NestedContext()
-        self.assertEquals(pystache.Template('{{#foo}}{{thing1}} and {{thing2}} and {{outer_thing}}{{/foo}}{{^foo}}Not foo!{{/foo}}', view).render(), "one and foo and two")
+        view.template = '{{#foo}}{{thing1}} and {{thing2}} and {{outer_thing}}{{/foo}}{{^foo}}Not foo!{{/foo}}'
+        self.assertEquals(view.render(), "one and foo and two")
 
     def test_looping_and_negation_context(self):
         view = ComplexView()
-        self.assertEquals(pystache.Template('{{#item}}{{header}}: {{name}} {{/item}}{{^item}} Shouldnt see me{{/item}}', view).render(), "Colors: red Colors: green Colors: blue ")
+        view.template = '{{#item}}{{header}}: {{name}} {{/item}}{{^item}} Shouldnt see me{{/item}}'
+        self.assertEquals(view.render(), "Colors: red Colors: green Colors: blue ")
 
     def test_empty_context(self):
         view = ComplexView()
@@ -25,13 +25,16 @@ class TestSimple(unittest.TestCase):
 
     def test_callables(self):
         view = Lambdas()
-        self.assertEquals(pystache.Template('{{#replace_foo_with_bar}}foo != bar. oh, it does!{{/replace_foo_with_bar}}', view).render(), 'bar != bar. oh, it does!')
+        view.template = '{{#replace_foo_with_bar}}foo != bar. oh, it does!{{/replace_foo_with_bar}}'
+        self.assertEquals(view.render(), 'bar != bar. oh, it does!')
 
     def test_rendering_partial(self):
         view = TemplatePartial()
-        self.assertEquals(pystache.Template('{{>inner_partial}}', view).render(), 'Again, Welcome!')
+        view.template = '{{>inner_partial}}'
+        self.assertEquals(view.render(), 'Again, Welcome!')
 
-        self.assertEquals(pystache.Template('{{#looping}}{{>inner_partial}} {{/looping}}', view).render(), '''Again, Welcome! Again, Welcome! Again, Welcome! ''')
+        view.template = '{{#looping}}{{>inner_partial}} {{/looping}}'
+        self.assertEquals(view.render(), '''Again, Welcome! Again, Welcome! Again, Welcome! ''')
 
     def test_non_existent_value_renders_blank(self):
         view = Simple()

tests/test_template.py

@@ -15,23 +15,6 @@ class TemplateTestCase(unittest.TestCase):
 
     """Test the Template class."""
 
-    def test_init__kwargs_with_no_context(self):
-        """
-        Test passing **kwargs with no context.
-
-        """
-        # This test checks that the following line raises no exception.
-        template = Template(foo="bar")
-
-    def test_init__kwargs_does_not_modify_context(self):
-        """
-        Test that passing **kwargs does not modify the passed context.
-
-        """
-        context = {}
-        template = Template(context=context, foo="bar")
-        self.assertEquals(context, {})
-
     def test_render__unicode(self):
         template = Template(u'foo')
         actual = template.render()
@@ -51,8 +34,46 @@ class TemplateTestCase(unittest.TestCase):
         self.assertEquals(actual, u'Poincaré')
 
     def test_render__context(self):
-        template = Template('Hi {{person}}', {'person': 'Mom'})
-        self.assertEquals(template.render(), 'Hi Mom')
+        """
+        Test render(): passing a context.
+
+        """
+        template = Template('Hi {{person}}')
+        self.assertEquals(template.render({'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')
+
+    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')
+
+    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')
+
+    def test_render__kwargs_does_not_modify_context(self):
+        """
+        Test render(): passing **kwargs does not modify the passed context.
+
+        """
+        context = {}
+        template = Template('Hi {{person}}')
+        template.render(context=context, foo="bar")
+        self.assertEquals(context, {})
 
     def test_render__output_encoding(self):
         template = Template(u'Poincaré')