Docserver: roll third_party/handlebar/handlebar.py and tiny server2 change to

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 137 matching lines @@
   def Push(self, context):
     self._nodes.append(_Contexts._Node(context))
 
   def Pop(self):
     node = self._nodes.pop()
     assert len(self._nodes) >= self._first_local
     for found_key in node.GetKeys():
       # [0] is the stack of nodes that |found_key| has been found in.
       self._value_info[found_key][0].pop()
 
+  def FirstLocal(self):
+    if len(self._nodes) == self._first_local:
+      return None
+    return self._nodes[-1]._value
+
   def Resolve(self, path):
     # This method is only efficient at finding |key|; if |tail| has a value (and
     # |key| evaluates to an indexable value) we'll need to descend into that.
     key, tail = path.split('.', 1) if '.' in path else (path, None)
     found = self._FindNodeValue(key)
     if tail is None:
       return found
     for part in tail.split('.'):
       if not hasattr(found, 'get'):
         return None
@@ skipping 468 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
 
+# TODO: Better common model of _PartialNodeWithArguments, _PartialNodeInContext,
+# and _PartialNode.
+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 _PartialNodeInContext(_DecoratorNode):
+  def __init__(self, partial, context):
+    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._context = context
+
+  def Render(self, render_state):
+    original_contexts = render_state.contexts
+    try:
+      render_state.contexts = self._context
+      render_state.contexts.Scope(
+          # The first local context of |original_contexts| will be the
+          # arguments that were passed to the partial, if any.
+          original_contexts.FirstLocal() or {},
+          self._partial.Render, render_state)
+    finally:
+      render_state.contexts = original_contexts
+
 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
+      arg_context[self._bind_to.name] = _PartialNodeInContext(
+          self._content, render_state.contexts)
     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)