Extensions Docs Server: Faster Handlebar

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 25 matching lines @@
 a get() method.
 
 class CustomContext(object):
   def get(self, key):
     return 10
 
 # Any time {{ }} is used, will fill it with 10.
 print(Handlebar('hello {{world}}').render(CustomContext()).text)
 """
 
-def _SafeStr(obj):
-  return obj if isinstance(obj, basestring) else str(obj)
-
 class ParseException(Exception):
   """ Exception thrown while parsing the template.
   """
   def __init__(self, error, line):
     Exception.__init__(self, "%s (line %s)" % (error, line.number))
 
 class RenderResult(object):
   """ Result of a render operation.
   """
   def __init__(self, text, errors):
     self.text = text;
     self.errors = errors
 
 class StringBuilder(object):
   """ Mimics Java's StringBuilder for easy porting from the Java version of
   this file to Python.
   """
   def __init__(self):
     self._buf = []
-    self._length = 0
 
   def __len__(self):
-    return self._length
+    self._Collapse()
+    return len(self._buf[0])
 
-  def append(self, obj):
-    string = _SafeStr(obj)
+  def append(self, string):
     self._buf.append(string)
-    self._length += len(string)
 
   def toString(self):
-    return u''.join(self._buf)
+    self._Collapse()
+    return self._buf[0]
 
   def __str__(self):
     return self.toString()
 
+  def _Collapse(self):
+    self._buf = [u''.join(self._buf)]
+
 class RenderState(object):
   """ The state of a render call.
   """
   def __init__(self, globalContexts, localContexts):
     self.globalContexts = globalContexts
     self.localContexts = localContexts
     self.text = StringBuilder()
     self.errors = []
     self._errorsDisabled = False
 
   def inSameContext(self):
     return RenderState(self.globalContexts, self.localContexts)
 
   def getFirstContext(self):
     if len(self.localContexts) > 0:
       return self.localContexts[0]
     if len(self.globalContexts) > 0:
       return self.globalContexts[0]
     return None
 
   def disableErrors(self):
     self._errorsDisabled = True
     return self
 
   def addError(self, *messages):
     if self._errorsDisabled:
       return self
     buf = StringBuilder()
     for message in messages:
-      buf.append(message)
+      buf.append(str(message))
     self.errors.append(buf.toString())
     return self
 
   def getResult(self):
     return RenderResult(self.text.toString(), self.errors);
 
 class Identifier(object):
   """ An identifier of the form "@", "foo.bar.baz", or "@.foo.bar.baz".
   """
   def __init__(self, name, line):
@@ skipping 13 matching lines @@
     self._path = name.split('.')
 
   def resolve(self, renderState):
     if self._isThis:
       return renderState.getFirstContext()
 
     if self._startsWithThis:
       return self._resolveFromContext(renderState.getFirstContext())
 
     resolved = self._resolveFromContexts(renderState.localContexts)
-    if resolved == None:
+    if resolved is None:
       resolved = self._resolveFromContexts(renderState.globalContexts)
-    if resolved == None:
+    if resolved is None:
       renderState.addError("Couldn't resolve identifier ", self._path)
     return resolved
 
   def _resolveFromContexts(self, contexts):
     for context in contexts:
       resolved = self._resolveFromContext(context)
-      if resolved != None:
+      if resolved is not None:
         return resolved
     return None
 
   def _resolveFromContext(self, context):
     result = context
     for next in self._path:
       # Only require that contexts provide a get method, meaning that callers
       # can provide dict-like contexts (for example, to populate values lazily).
-      if result == None or not getattr(result, "get", None):
+      if result is None or not getattr(result, "get", None):
         return None
       result = result.get(next)
     return result
 
   def __str__(self):
     if self._isThis:
       return '@'
     name = '.'.join(self._path)
     return ('@.' + name) if self._startsWithThis else name
 
@@ skipping 53 matching lines @@
 
 class InlineNode(DecoratorNode):
   def __init__(self, content):
     DecoratorNode.__init__(self, content)
 
   def render(self, renderState):
     contentRenderState = renderState.inSameContext()
     self._content.render(contentRenderState)
 
     renderState.errors.extend(contentRenderState.errors)
-
-    for c in contentRenderState.text.toString():
-      if c != '\n':
-        renderState.text.append(c)
+    renderState.text.append(
+        contentRenderState.text.toString().replace('\n', ''))
 
 class IndentedNode(DecoratorNode):
   def __init__(self, content, indentation):
     DecoratorNode.__init__(self, content)
-    self._indentation = indentation
+    self._indent_str = ' ' * indentation
 
   def render(self, renderState):
     contentRenderState = renderState.inSameContext()
     self._content.render(contentRenderState)
 
     renderState.errors.extend(contentRenderState.errors)
-
-    self._indent(renderState.text)
-    for i, c in enumerate(contentRenderState.text.toString()):
-      renderState.text.append(c)
-      if c == '\n' and i < len(contentRenderState.text) - 1:
-        self._indent(renderState.text)
+    renderState.text.append(self._indent_str)
+    # TODO: this might introduce an extra \n at the end? need test.
+    renderState.text.append(
+        contentRenderState.text.toString().replace('\n',
+                                                   '\n' + self._indent_str))
     renderState.text.append('\n')
 
-  def _indent(self, buf):
-    buf.append(' ' * self._indentation)
-
 class BlockNode(DecoratorNode):
   def __init__(self, content):
     DecoratorNode.__init__(self, content)
     content.trimStartingNewLine()
     content.trimEndingSpaces()
 
   def render(self, renderState):
     self._content.render(renderState)
 
 class NodeCollection(object):
@@ skipping 72 matching lines @@
 
 class EscapedVariableNode(LeafNode):
   """ {{foo}}
   """
   def __init__(self, id, line):
     LeafNode.__init__(self, line)
     self._id = id
 
   def render(self, renderState):
     value = self._id.resolve(renderState)
-    if value != None:
-      self._appendEscapedHtml(renderState.text, _SafeStr(value))
+    if value is None:
+      return
 
-  def _appendEscapedHtml(self, escaped, unescaped):
-    for c in unescaped:
-      if c == '<':
-        escaped.append("&lt;")
-      elif c == '>':
-        escaped.append("&gt;")
-      elif c == '&':
-        escaped.append("&amp;")
-      else:
-        escaped.append(c)
+    string = value if isinstance(value, basestring) else str(value)
+    renderState.text.append(string.replace('&', '&amp;')
+                                  .replace('<', '&lt;')
+                                  .replace('>', '&gt;'))
 
 class UnescapedVariableNode(LeafNode):
   """ {{{foo}}}
   """
   def __init__(self, id, line):
     LeafNode.__init__(self, line)
     self._id = id
 
   def render(self, renderState):
     value = self._id.resolve(renderState)
-    if value != None:
-      renderState.text.append(value)
+    if value is None:
+      return
+    renderState.text.append(
+        value if isinstance(value, basestring) else str(value))
 
 class SectionNode(DecoratorNode):
   """ {{#foo}} ... {{/}}
   """
   def __init__(self, id, content):
     DecoratorNode.__init__(self, content)
     self._id = id
 
   def render(self, renderState):
     value = self._id.resolve(renderState)
-    if value == None:
+    if value is None:
       return
 
     if isinstance(value, list):
       for item in value:
         renderState.localContexts.insert(0, item)
         self._content.render(renderState)
         renderState.localContexts.pop(0)
     elif isinstance(value, dict):
       renderState.localContexts.insert(0, value)
       self._content.render(renderState)
@@ skipping 10 matching lines @@
     self._id = id
 
   def render(self, renderState):
     value = self._id.resolve(renderState.inSameContext().disableErrors())
     if _VertedSectionNodeShouldRender(value):
       renderState.localContexts.insert(0, value)
       self._content.render(renderState)
       renderState.localContexts.pop(0)
 
 def _VertedSectionNodeShouldRender(value):
-  if value == None:
+  if value is None:
     return False
   if isinstance(value, bool):
     return value
   if (isinstance(value, int) or
       isinstance(value, long) or
       isinstance(value, float)):
     return True
   if isinstance(value, basestring):
     return True
   if isinstance(value, list):
@@ skipping 16 matching lines @@
 
 class JsonNode(LeafNode):
   """ {{*foo}}
   """
   def __init__(self, id, line):
     LeafNode.__init__(self, line)
     self._id = id
 
   def render(self, renderState):
     value = self._id.resolve(renderState)
-    if value != None:
-      renderState.text.append(json.dumps(value, separators=(',',':')))
+    if value is None:
+      return
+    renderState.text.append(json.dumps(value, separators=(',',':')))
 
 class PartialNode(LeafNode):
   """ {{+foo}}
   """
   def __init__(self, id, line):
     LeafNode.__init__(self, line)
     self._id = id
     self._args = None
 
   def render(self, renderState):
@@ skipping 70 matching lines @@
   """
   def __init__(self, string):
     self._remainder = string
 
     self.nextToken = None
     self.nextContents = None
     self.nextLine = Line(1)
     self.advance()
 
   def hasNext(self):
-    return self.nextToken != None
+    return self.nextToken is not None
 
   def advance(self):
     if self.nextContents == '\n':
       self.nextLine = Line(self.nextLine.number + 1)
 
     self.nextToken = None
     self.nextContents = None
 
     if self._remainder == '':
       return None
@@ skipping 184 matching lines @@
   def render(self, *contexts):
     """ Renders this template given a variable number of "contexts" to read
     out values from (such as those appearing in {{foo}}).
     """
     globalContexts = []
     for context in contexts:
       globalContexts.append(context)
     renderState = RenderState(globalContexts, [])
     self._topNode.render(renderState)
     return renderState.getResult()