Rename the docserver third_party dependency "handlebar" to "motemplate", as part

third_party/motemplate/motemplate.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,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# TODO: New name, not "handlebar".
 # TODO: Escaping control characters somehow. e.g. \{{, \{{-.
 
 import json
 import re
 
-'''Handlebar templates are data binding templates more-than-loosely inspired by
+'''Motemplate templates are data binding templates more-than-loosely inspired by
 ctemplate. Use like:
 
-  from handlebar import Handlebar
+  from motemplate import Motemplate
 
-  template = Handlebar('hello {{#foo bar/}} world')
+  template = Motemplate('hello {{#foo bar/}} world')
   input = {
     'foo': [
       { 'bar': 1 },
       { 'bar': 2 },
       { 'bar': 3 }
     ]
   }
   print(template.render(input).text)
 
-Handlebar will use get() on contexts to return values, so to create custom
+Motemplate will use get() on contexts to return values, so to create custom
 getters (for example, something that populates values lazily from keys), just
 provide an object with a get() method.
 
   class CustomContext(object):
     def get(self, key):
       return 10
-  print(Handlebar('hello {{world}}').render(CustomContext()).text)
+  print(Motemplate('hello {{world}}').render(CustomContext()).text)
 
 will print 'hello 10'.
 '''
 
 class ParseException(Exception):
   '''The exception thrown while parsing a template.
   '''
   def __init__(self, error):
     Exception.__init__(self, error)
 
@@ skipping 587 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):
+    if isinstance(partial, Motemplate):
       # 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):
+    if isinstance(partial, Motemplate):
       # 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
@@ skipping 20 matching lines @@
 
   @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)):
+    if not isinstance(value, (Motemplate, _Node)):
       render_state.AddResolutionError(self._id, description='not a partial')
       return
 
-    if isinstance(value, Handlebar):
+    if isinstance(value, Motemplate):
       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:
@@ skipping 180 matching lines @@
       self.Advance()
 
   def __repr__(self):
     return '%s(next_token=%s, remainder=%s)' % (type(self).__name__,
                                                 self.next_token,
                                                 self._string[self._cursor:])
 
   def __str__(self):
     return repr(self)
 
-class Handlebar(object):
-  '''A handlebar template.
+class Motemplate(object):
+  '''A motemplate template.
   '''
   def __init__(self, template, name=None):
     self.source = template
     self._name = name
     tokens = _TokenStream(template)
     self._top_node = self._ParseSection(tokens)
     if not self._top_node:
       raise ParseException('Template is empty')
     if tokens.HasNext():
       raise ParseException('There are still tokens remaining at %s, '
@@ skipping 222 matching lines @@
     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)