Extensions Docs Server: Handlebar handles line breaks in partials

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 26 matching lines @@
 
 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 (type(obj) in [str, unicode]) else str(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.
   """
@@ skipping 327 matching lines @@
   """
   def __init__(self, id, content):
     DecoratorNode.__init__(self, content)
     self._id = id
 
   def render(self, renderState):
     value = self._id.resolve(renderState)
     if value == None:
       return
 
-    type_ = type(value)
-    if type_ == list:
+    if isinstance(value, list):
       for item in value:
         renderState.localContexts.insert(0, item)
         self._content.render(renderState)
         renderState.localContexts.pop(0)
-    elif type_ == dict:
+    elif isinstance(value, dict):
       renderState.localContexts.insert(0, value)
       self._content.render(renderState)
       renderState.localContexts.pop(0)
     else:
       renderState.addError("{{#", self._id,
-                           "}} cannot be rendered with a ", type_)
+                           "}} cannot be rendered with a ", type(value))
 
 class VertedSectionNode(DecoratorNode):
   """ {{?foo}} ... {{/}}
   """
   def __init__(self, id, content):
     DecoratorNode.__init__(self, content)
     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:
     return False
-  type_ = type(value)
-  if type_ == bool:
+  if isinstance(value, bool):
     return value
-  if type_ in [int, float]:
+  if (isinstance(value, int) or
+      isinstance(value, long) or
+      isinstance(value, float)):
     return True
-  if type_ in [str, unicode]:
+  if isinstance(value, basestring):
     return True
-  if type_ == list:
+  if isinstance(value, list):
     return len(value) > 0
-  if type_ == dict:
+  if isinstance(value, dict):
     return True
-  raise TypeError("Unhandled type: " + str(type_))
+  raise TypeError("Unhandled type %s" % type(value))
 
 class InvertedSectionNode(DecoratorNode):
   """ {{^foo}} ... {{/}}
   """
   def __init__(self, id, content):
     DecoratorNode.__init__(self, content)
     self._id = id
 
   def render(self, renderState):
     value = self._id.resolve(renderState.inSameContext().disableErrors())
@@ skipping 133 matching lines @@
     return self.advance()
 
   def advanceOverNextString(self, excluded=''):
     buf = StringBuilder()
     while self.nextToken == Token.CHARACTER and \
           excluded.find(self.nextContents) == -1:
       buf.append(self.nextContents)
       self.advance()
     return buf.toString()
 
+  def advanceToNextWhitespace(self):
+    return self.advanceOverNextString(excluded=' \n\r\t')
+
+  def skipWhitespace(self):
+    while len(self.nextContents) > 0 and \
+          ' \n\r\t'.find(self.nextContents) >= 0:
+      self.advance()
+
 class Handlebar(object):
   """ A handlebar template.
   """
   def __init__(self, template):
     self.source = template
     tokens = TokenStream(template)
     self._topNode = self._parseSection(tokens)
     if not self._topNode:
       raise ParseException("Template is empty", tokens.nextLine)
     if tokens.hasNext():
@@ skipping 12 matching lines @@
         startLine = tokens.nextLine
         string = tokens.advanceOverNextString()
         nodes.append(StringNode(string, startLine, tokens.nextLine))
       elif token == Token.OPEN_VARIABLE or \
            token == Token.OPEN_UNESCAPED_VARIABLE or \
            token == Token.OPEN_START_JSON:
         id = self._openSectionOrTag(tokens)
         nodes.append(token.clazz(id, tokens.nextLine))
       elif token == Token.OPEN_START_PARTIAL:
         tokens.advance()
-        id = Identifier(tokens.advanceOverNextString(excluded=' '),
+        id = Identifier(tokens.advanceToNextWhitespace(),
                         tokens.nextLine)
         partialNode = PartialNode(id, tokens.nextLine)
 
         while tokens.nextToken == Token.CHARACTER:
-          tokens.advance()
+          tokens.skipWhitespace()
           key = tokens.advanceOverNextString(excluded=':')
           tokens.advance()
           partialNode.addArgument(
               key,
-              Identifier(tokens.advanceOverNextString(excluded=' '),
+              Identifier(tokens.advanceToNextWhitespace(),
                          tokens.nextLine))
 
         tokens.advanceOver(Token.CLOSE_MUSTACHE)
         nodes.append(partialNode)
       elif token == Token.OPEN_START_SECTION:
         id = self._openSectionOrTag(tokens)
         section = self._parseSection(tokens)
         self._closeSection(tokens, id)
         if section:
           nodes.append(SectionNode(id, section))
@@ skipping 95 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()