Extensions Docs Server: Handlebar updates again

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 (type(obj) in [str, unicode]) 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
 
   def append(self, obj):
-    string = str(obj)
+    string = _SafeStr(obj)
     self._buf.append(string)
     self._length += len(string)
 
   def toString(self):
-    return ''.join(self._buf)
+    return u''.join(self._buf)
+
+  def __str__(self):
+    return self.toString()
 
 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
@@ skipping 255 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, str(value))
+      self._appendEscapedHtml(renderState.text, _SafeStr(value))
 
   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:
@@ skipping 50 matching lines @@
       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:
     return value
-  if type_ == int or type_ == float:
+  if type_ in [int, float]:
     return True
-  if type_ == str or type_ == unicode:
+  if type_ in [str, unicode]:
     return True
   if type_ == list:
     return len(value) > 0
   if type_ == dict:
     return True
   raise TypeError("Unhandled type: " + str(type_))
 
 class InvertedSectionNode(DecoratorNode):
   """ {{^foo}} ... {{/}}
   """
@@ skipping 297 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()