Open Source Monorail

appengine/monorail/third_party/ezt.py

 #!/usr/bin/env python
 """ezt.py -- EaZy Templating
 
 For documentation, please see: http://code.google.com/p/ezt/wiki/Syntax
 """
 #
 # Copyright (C) 2001-2011 Greg Stein. All Rights Reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
@@ skipping 21 matching lines @@
 #
 # This software is maintained by Greg and is available at:
 #    http://code.google.com/p/ezt/
 #
 
 __author__ = 'Greg Stein'
 __version__ = '1.0'
 __license__ = 'BSD'
 
 import re
-from types import StringType, IntType, FloatType, LongType
+from types import IntType, FloatType, LongType
 import os
 import urllib
-try:
-  import cStringIO
-except ImportError:
-  import StringIO
-  cStringIO = StringIO
+import StringIO
 
 #
 # Formatting types
 #
 FORMAT_RAW = 'raw'
 FORMAT_HTML = 'html'
 FORMAT_XML = 'xml'
 FORMAT_JS = 'js'
 FORMAT_URL = 'url'
 
 #
-# This regular expression matches three alternatives:
+# This regular expression matches four alternatives:
 #   expr: NEWLINE | DIRECTIVE | BRACKET | COMMENT
-#   DIRECTIVE: '[' ITEM (whitespace ITEM)* ']
+#   DIRECTIVE: '[' ITEM (whitespace ARG)* ']
 #   ITEM: STRING | NAME
+#   ARG: STRING | NAME | NUMBER
 #   STRING: '"' (not-slash-or-dquote | '\' anychar)* '"'
-#   NAME: (alphanum | '_' | '-' | '.')+
+#   NAME: (alpha | '_') (alphanum | '_' | '-' | '.')*
+#   NUMBER: digit+
 #   BRACKET: '[[]'
 #   COMMENT: '[#' not-rbracket* ']'
 #
+# Note: the above BNR is a bit loose around ITEM/ARG/NAME/NUMBER. The
+#       important point is that the first value in a directive must
+#       start with '_' or an alpha character (no digits). This greatly
+#       helps to avoid simple errors like '[0]' in templates.
+#
 # When used with the split() method, the return value will be composed of
 # non-matching text and the three paren groups (NEWLINE, DIRECTIVE and
 # BRACKET). Since the COMMENT matches are not placed into a group, they are
 # considered a "splitting" value and simply dropped.
 #
-_item = r'(?:"(?:[^\\"]|\\.)*"|[-\w.]+)'
+_item = r'(?:"(?:[^\\"]|\\.)*"|[A-Za-z_][-\w.]*)'
+_arg = r'(?:"(?:[^\\"]|\\.)*"|[-\w.]+)'
 _re_parse = re.compile(r'(\r?\n)|\[(%s(?: +%s)*)\]|(\[\[\])|\[#[^\]]*\]' %
-                       (_item, _item))
+                       (_item, _arg))
 
 _re_args = re.compile(r'"(?:[^\\"]|\\.)*"|[-\w.]+')
 
 # block commands and their argument counts
 _block_cmd_specs = { 'if-index':2, 'for':1, 'is':2, 'define':1, 'format':1 }
 _block_cmds = _block_cmd_specs.keys()
 
 # two regular expressions for compressing whitespace. the first is used to
 # compress any whitespace including a newline into a single newline. the
 # second regex is used to compress runs of whitespace into a single space.
@@ skipping 195 matching lines @@
       raise UnclosedBlocksError('Block opened at line %s' % stack[-1][4],
                                 filename=filename)
     return program
 
   def _execute(self, program, fp, ctx):
     """This private helper function takes a 'program' sequence as created
     by the method '_parse' and executes it step by step.  strings are written
     to the file object 'fp' and functions are called.
     """
     for step in program:
-      if isinstance(step, StringType):
+      if isinstance(step, basestring):
         fp.write(step)
       else:
         method, method_args, filename, line_number = step
         method(method_args, fp, ctx, filename, line_number)
 
   def _cmd_print(self, (transforms, valref), fp, ctx, filename, line_number):
     value = _get_value(valref, ctx, filename, line_number)
     # if the value has a 'read' attribute, then it is a stream: copy it
     if hasattr(value, 'read'):
       while 1:
@@ skipping 77 matching lines @@
       section = t_section
     else:
       section = f_section
     if section is not None:
       self._execute(section, fp, ctx)
 
   def _cmd_for(self, args, fp, ctx, filename, line_number):
     ((valref,), unused, section) = args
     list = _get_value(valref, ctx, filename, line_number)
     refname = valref[0]
-    if isinstance(list, StringType):
+    if isinstance(list, basestring):
       raise NeedSequenceError(refname, filename, line_number)
     ctx.for_index[refname] = idx = [ list, 0 ]
     for item in list:
       self._execute(section, fp, ctx)
       idx[1] = idx[1] + 1
     del ctx.for_index[refname]
 
   def _cmd_define(self, args, fp, ctx, filename, line_number):
     ((name,), unused, section) = args
-    valfp = cStringIO.StringIO()
+    valfp = StringIO.StringIO()
     if section is not None:
       self._execute(section, valfp, ctx)
     ctx.defines[name] = valfp.getvalue()
 
 def boolean(value):
   "Return a value suitable for [if-any bool_var] usage in a template."
   if value:
     return 'yes'
   return None
 
@@ skipping 65 matching lines @@
   elif ctx.defines.has_key(start):
     ob = ctx.defines[start]
   elif hasattr(ctx.data, start):
     ob = getattr(ctx.data, start)
   else:
     raise UnknownReference(refname, filename, line_number)
 
   # walk the rest of the dotted reference
   for attr in rest:
     try:
-      ob = getattr(ob, attr)
-    except AttributeError:
+      if isinstance(ob, dict):
+        ob = ob[attr]
+      else:
+        ob = getattr(ob, attr)
+    except AttributeError, KeyError:
       raise UnknownReference(refname, filename, line_number)
 
   # make sure we return a string instead of some various Python types
   if isinstance(ob, (IntType, FloatType, LongType)):
     return str(ob)
   if ob is None:
     return ''
 
   # string or a sequence
   return ob
@@ skipping 145 matching lines @@
 
 def _test(argv):
   import doctest, ezt
   verbose = "-v" in argv
   return doctest.testmod(ezt, verbose=verbose)
 
 if __name__ == "__main__":
   # invoke unit test for this module:
   import sys
   sys.exit(_test(sys.argv)[0])