Docserver: Attach intro metadata to the template itself, not to an object which

third_party/handlebar/handlebar.py

 # Copyright 2012 Benjamin Kalman
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #     http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 625 matching lines @@
   def Render(self, render_state):
     value = render_state.contexts.Resolve(self._id.name)
     if value is None:
       render_state.AddResolutionError(self._id)
       return
     render_state.text.Append(json.dumps(value, separators=(',',':')))
 
   def __repr__(self):
     return '{{*%s}}' % self._id
 
+class _PartialNodeWithArguments(_DecoratorNode):
+  def __init__(self, partial, args):
+    if isinstance(partial, Handlebar):
+      # Preserve any get() method that the caller has added.
+      if hasattr(partial, 'get'):
+        self.get = partial.get
+      partial = partial._top_node
+    _DecoratorNode.__init__(self, partial)
+    self._partial = partial
+    self._args = args
+
+  def Render(self, render_state):
+    render_state.contexts.Scope(self._args, self._partial.Render, render_state)
+
 class _PartialNode(_LeafNode):
   '''{{+var:foo}} ... {{/foo}}
   '''
   def __init__(self, bind_to, id_, content):
     _LeafNode.__init__(self, id_.line, id_.line)
     self._bind_to = bind_to
     self._id = id_
     self._content = content
-    self._resolved_args = None
     self._args = None
     self._pass_through_id = None
 
   @classmethod
   def Inline(cls, id_):
     return cls(None, id_, None)
 
   def Render(self, render_state):
     value = render_state.contexts.Resolve(self._id.name)
     if value is None:
       render_state.AddResolutionError(self._id)
       return
     if not isinstance(value, (Handlebar, _Node)):
       render_state.AddResolutionError(self._id, description='not a partial')
       return
 
     if isinstance(value, Handlebar):
       node, name = value._top_node, value._name
     else:
       node, name = value, None
 
     partial_render_state = render_state.ForkPartial(name, self._id)
 
     arg_context = {}
     if self._pass_through_id is not None:
       context = render_state.contexts.Resolve(self._pass_through_id.name)
       if context is not None:
         arg_context[self._pass_through_id.name] = context
-    if self._resolved_args is not None:
-      arg_context.update(self._resolved_args)
     if self._args is not None:
       def resolve_args(args):
         resolved = {}
         for key, value in args.iteritems():
           if isinstance(value, dict):
             assert len(value.keys()) == 1
-            inner_id, inner_args = value.items()[0]
-            inner_partial = render_state.contexts.Resolve(inner_id.name)
-            if inner_partial is not None:
-              context = _PartialNode(None, inner_id, inner_partial)
-              context.SetResolvedArguments(resolve_args(inner_args))
-              resolved[key] = context
+            id_of_partial, partial_args = value.items()[0]
+            partial = render_state.contexts.Resolve(id_of_partial.name)
+            if partial is not None:
+              resolved[key] = _PartialNodeWithArguments(
+                  partial, resolve_args(partial_args))
           else:
             context = render_state.contexts.Resolve(value.name)
             if context is not None:
               resolved[key] = context
         return resolved
       arg_context.update(resolve_args(self._args))
     if self._bind_to and self._content:
       arg_context[self._bind_to.name] = self._content
     if arg_context:
       partial_render_state.contexts.Push(arg_context)
 
     node.Render(partial_render_state)
 
     render_state.Merge(
         partial_render_state,
         text_transform=lambda text: text[:-1] if text.endswith('\n') else text)
 
-  def SetResolvedArguments(self, args):
-    self._resolved_args = args
-
   def SetArguments(self, args):
     self._args = args
 
   def PassThroughArgument(self, id_):
     self._pass_through_id = id_
 
   def __repr__(self):
     return '{{+%s}}' % self._id
 
 _TOKENS = {}
@@ skipping 358 matching lines @@
     id_ = _Identifier(tokens.AdvanceOverNextString(excluded=' \n\r\t:()'),
                       tokens.next_line,
                       column_start)
     tokens.SkipWhitespace()
     return id_
 
   def Render(self, *user_contexts):
     '''Renders this template given a variable number of contexts to read out
     values from (such as those appearing in {{foo}}).
     '''
-    name = self._name or '<root>'
     internal_context = _InternalContext()
-    render_state = _RenderState(
-        name, _Contexts([{'_': internal_context}] + list(user_contexts)))
+    contexts = list(user_contexts)
+    contexts.append({
+      '_': internal_context,
+      'false': False,
+      'true': True,
+    })
+    render_state = _RenderState(self._name or '<root>', _Contexts(contexts))
     internal_context.SetRenderState(render_state)
     self._top_node.Render(render_state)
     return render_state.GetResult()
 
   def render(self, *contexts):
     return self.Render(*contexts)
 
   def __eq__(self, other):
     return self.source == other.source and self._name == other._name
 
   def __ne__(self, other):
     return not (self == other)
 
   def __repr__(self):
     return str('%s(%s)' % (type(self).__name__, self._top_node))
 
   def __str__(self):
     return repr(self)