Ticket #230: genshi-context.patch

genshi/template/base.py

@@ -30 +30 @@
            'TemplateSyntaxError', 'BadDirectiveError']
 __docformat__ = 'restructuredtext en'
 
-if sys.version_info < (2, 4):
-    _ctxt2dict = lambda ctxt: ctxt.frames[0]
-else:
-    _ctxt2dict = lambda ctxt: ctxt
-
-
 class TemplateError(Exception):
     """Base exception class for errors related to template processing."""
 
@@ -133 +127 @@
         """Initialize the template context with the given keyword arguments as
         data.
         """
-        self.frames = deque([data])
-        self.pop = self.frames.popleft
-        self.push = self.frames.appendleft
+        self.__frames = deque([data])
         self._match_templates = []
         self._choice_stack = []
 
@@ -152 +144 @@
         data.setdefault('value_of', value_of)
 
     def __repr__(self):
-        return repr(list(self.frames))
+        return repr(list(self.__frames))
 
     def __contains__(self, key):
         """Return whether a variable exists in any of the scopes.
         
         :param key: the name of the variable
         """
-        return self._find(key)[1] is not None
+        return self.__find(key)[1] is not None
     has_key = __contains__
 
-    def __delitem__(self, key):
-        """Remove a variable from all scopes.
-        
-        :param key: the name of the variable
-        """
-        for frame in self.frames:
-            if key in frame:
-                del frame[key]
-
     def __getitem__(self, key):
         """Get a variables's value, starting at the current scope and going
         upward.
@@ -179 +162 @@
         :return: the variable value
         :raises KeyError: if the requested variable wasn't found in any scope
         """
-        value, frame = self._find(key)
+        value, frame = self.__find(key)
         if frame is None:
             raise KeyError(key)
         return value
@@ -197 +180 @@
         :param key: the name of the variable
         :param value: the variable value
         """
-        self.frames[0][key] = value
+        self.__frames[0][key] = value
 
-    def _find(self, key, default=None):
+    def __find(self, key, default=None):
         """Retrieve a given variable's value and the frame it was found in.
 
-        Intended primarily for internal use by directives.
+        Internal use.
         
         :param key: the name of the variable
         :param default: the default value to return when the variable is not
                         found
         """
-        for frame in self.frames:
+        for frame in self.__frames:
             if key in frame:
                 return frame[key], frame
         return default, None
@@ -221 +204 @@
         :param default: the default value to return when the variable is not
                         found
         """
-        for frame in self.frames:
+        for frame in self.__frames:
             if key in frame:
                 return frame[key]
         return default
@@ -232 +215 @@
         :return: a list of variable names
         """
         keys = []
-        for frame in self.frames:
+        for frame in self.__frames:
             keys += [key for key in frame if key not in keys]
         return keys
 
@@ -246 +229 @@
 
     def update(self, mapping):
         """Update the context from the mapping provided."""
-        self.frames[0].update(mapping)
+        self.__frames[0].update(mapping)
 
     def push(self, data):
         """Push a new scope on the stack.
@@ -254 +237 @@
         :param data: the data dictionary to push on the context stack.
         """
 
+        self.__frames.appendleft(data)
+
     def pop(self):
         """Pop the top-most scope from the stack."""
 
+        return self.__frames.popleft()
 
+    def execdict(self):
+        """Return an object Python's exec can use for variables"""
+        
+        if sys.version_info < (2, 4):
+            return self.__frames[0]
+        else:
+            return self
+
 def _apply_directives(stream, directives, ctxt, **vars):
     """Apply the given directives to the stream.
     
@@ -299 +293 @@
     if vars:
         ctxt.push(vars)
         ctxt.push({})
-    suite.execute(_ctxt2dict(ctxt))
+    suite.execute(ctxt.execdict())
     if vars:
         top = ctxt.pop()
         ctxt.pop()
-        ctxt.frames[0].update(top)
+        ctxt.update(top)
 
 
 class TemplateMeta(type):

genshi/template/tests/markup.py

@@ -254 +254 @@
           <Item/>
         </Test>""", str(tmpl.generate()))
 
+    def test_included_function_override(self):
+        dirname = tempfile.mkdtemp(suffix='genshi_test')
+        try:
+            file1 = open(os.path.join(dirname, 'tmpl1.html'), 'w')
+            try:
+                file1.write("""<div xmlns:xi="http://www.w3.org/2001/XInclude"
+                                    xmlns:py="http://genshi.edgewall.org/">
+                  <py:def function="msg">Foo</py:def>
+                  <xi:include href="tmpl2.html" />${msg()}</div>""")
+            finally:
+                file1.close()
+
+            file2 = open(os.path.join(dirname, 'tmpl2.html'), 'w')
+            try:
+                file2.write("""<py:def
+                                xmlns:py="http://genshi.edgewall.org/"
+                                function="msg">Bar</py:def>""")
+            finally:
+                file2.close()
+
+            loader = TemplateLoader([dirname])
+            tmpl = loader.load('tmpl1.html')
+
+            self.assertEqual("""<div>
+                  Bar</div>""", tmpl.generate().render())
+                
+        finally:
+            shutil.rmtree(dirname)
+
     def test_include_in_loop(self):
         dirname = tempfile.mkdtemp(suffix='genshi_test')
         try:

genshi/template/directives.py

@@ -322 +322 @@
             # Function name can't be set in Python 2.3 
             pass
 
-        # Store the function reference in the bottom context frame so that it
-        # doesn't get popped off before processing the template has finished
-        # FIXME: this makes context data mutable as a side-effect
-        ctxt.frames[-1][self.name] = function
+        ctxt[self.name] = function
 
         return []
 
@@ -731 +728 @@
     attach = classmethod(attach)
 
     def __call__(self, stream, directives, ctxt, **vars):
-        frame = {}
-        ctxt.push(frame)
+        ctxt.push({})
+        
         for targets, expr in self.vars: 
             value = _eval_expr(expr, ctxt, **vars)
             for assign in targets:
-                assign(frame, value)
+                assign(ctxt, value)
+                
         for event in _apply_directives(stream, directives, ctxt, **vars):
             yield event
         ctxt.pop()