Changeset 24

Timestamp:

19/08/04 12:05:48 (8 years ago)

Author:

steve

Message:

macros!

Location:

trunk

Files:

• airspeed.py (modified) (8 diffs)
• airspeed_test.py (modified) (2 diffs)

trunk/airspeed.py

@@ -1 +1 @@
 #!/usr/bin/env python
 
-import re
-import cStringIO as StringIO
-import operator
+import re, operator
+
+try: import cStringIO as StringIO
+except ImportError: import StringIO
 
 __all__ = ['TemplateSyntaxError', 'Template']
@@ -91 +92 @@
         m = pattern.match(self._full_text, self.end)
         if not m: raise NoMatch()
+        self.end = m.start(pattern.groups)
+        return m.groups()[:-1]
+
+    def next_match(self, pattern):
+        m = pattern.match(self._full_text, self.end)
+        if not m: return False
         self.end = m.start(pattern.groups)
         return m.groups()[:-1]
@@ -212 +219 @@
     def parse(self):
         self.identity_match(self.DOT)
-        self.expression = self.next_element(Expression)
+        self.expression = self.next_element(VariableExpression)
 
     def calculate(self, current_object, global_namespace):
@@ -218 +225 @@
 
 
-class Expression(_Element):
+class VariableExpression(_Element):
     subexpression = None
 
@@ -260 +267 @@
     def parse(self):
         self.silent, self.braces = self.identity_match(self.START)
-        self.expression = self.require_next_element(Expression, 'expression')
+        self.expression = self.require_next_element(VariableExpression, 'expression')
         if self.braces: self.require_match(self.CLOSING_BRACE, '}')
 
@@ -276 +283 @@
     def parse(self):
         self.identity_match(self.LEADING_DOLLAR)
-        self.expression = self.require_next_element(Expression, 'name')
+        self.expression = self.require_next_element(VariableExpression, 'name')
         self.calculate = self.expression.calculate
 
@@ -392 +399 @@
 
 
+class MacroDefinition(_Element):
+    START = re.compile(r'#macro\b(.*)', re.S + re.I)
+    OPEN_PAREN = re.compile(r'[ \t]*\(\s*(.*)$', re.S)
+    NAME = re.compile(r'\s*([a-z][a-z_0-9]*)\b(.*)', re.S + re.I)
+    CLOSE_PAREN = re.compile(r'[ \t]*\)(.*)$', re.S)
+    ARG_NAME = re.compile(r'[ \t]+\$([a-z][a-z_0-9]*)(.*)$', re.S + re.I)
+    RESERVED_NAMES = ('if', 'else', 'elseif', 'set', 'macro', 'foreach', 'parse', 'include', 'stop', 'end')
+    def parse(self):
+        self.identity_match(self.START)
+        self.require_match(self.OPEN_PAREN, '(')
+        self.macro_name, = self.require_match(self.NAME, 'macro name')
+        if self.macro_name.lower() in self.RESERVED_NAMES:
+            raise self.syntax_error('non-reserved name')
+        self.arg_names = []
+        while True:
+            m = self.next_match(self.ARG_NAME)
+            if not m: break
+            self.arg_names.append(m[0])
+        self.require_match(self.CLOSE_PAREN, ') or arg name')
+        self.block = self.require_next_element(Block, 'block')
+        self.require_next_element(End, 'block')
+
+    def evaluate(self, namespace, stream):
+        macro_key = '#' + self.macro_name.lower()
+        if macro_key in namespace:
+            raise Exception("cannot redefine macro")
+        namespace[macro_key] = self
+
+    def execute_macro(self, namespace, stream, arg_value_elements):
+        if len(arg_value_elements) != len(self.arg_names):
+            raise Exception("expected %d arguments, got %d" % (len(self.arg_names), len(arg_value_elements)))
+        macro_namespace = LocalNamespace(namespace)
+        for arg_name, arg_value in zip(self.arg_names, arg_value_elements):
+            macro_namespace[arg_name] = arg_value.calculate(namespace)
+        self.block.evaluate(macro_namespace, stream)
+
+
+class MacroCall(_Element):
+    START = re.compile(r'#([a-z][a-z_0-9]*)\b(.*)', re.S + re.I)
+    OPEN_PAREN = re.compile(r'[ \t]*\(\s*(.*)$', re.S)
+    CLOSE_PAREN = re.compile(r'[ \t]*\)(.*)$', re.S)
+    SPACE = re.compile(r'[ \t]+(.*)$', re.S)
+
+    def parse(self):
+        self.macro_name, = self.identity_match(self.START)
+        self.macro_name = self.macro_name.lower()
+        self.args = []
+        if self.macro_name in MacroDefinition.RESERVED_NAMES or self.macro_name.startswith('end'):
+            raise NoMatch()
+        self.require_match(self.OPEN_PAREN, '(')
+        while True:
+            try: self.args.append(self.next_element(Value))
+            except NoMatch: break
+            if not self.optional_match(self.SPACE): break
+        self.require_match(self.CLOSE_PAREN, 'argument value or )')
+
+    def evaluate(self, namespace, stream):
+        try: macro = namespace['#' + self.macro_name]
+        except KeyError: raise Exception('no such macro: ' + self.macro_name)
+        macro.execute_macro(namespace, stream, self.args)
+
+
 class SetDirective(_Element):
     START = re.compile(r'#set\b(.*)', re.S + re.I)
@@ -441 +510 @@
         self.children = []
         while True:
-            try:
-                self.children.append(self.next_element((Text, Placeholder, Comment, IfDirective, SetDirective, ForeachDirective)))
-            except NoMatch:
-                break
+            try: self.children.append(self.next_element((Text, Placeholder, Comment, IfDirective, SetDirective, ForeachDirective, MacroDefinition, MacroCall)))
+            except NoMatch: break
 
     def evaluate(self, namespace, stream):

trunk/airspeed_test.py

@@ -295 +295 @@
         self.assertEquals('yes', template.merge({'value': 1}))
         self.assertEquals('', template.merge({'value': 2}))
+
+    def test_cannot_define_macro_to_override_reserved_statements(self):
+        for reserved in ('if', 'else', 'elseif', 'set', 'macro', 'foreach', 'parse', 'include', 'stop', 'end'):
+            template = airspeed.Template('#macro ( %s $value) $value #end' % reserved)
+            self.assertRaises(airspeed.TemplateSyntaxError, template.merge, {})
+
+    def test_cannot_call_undefined_macro(self):
+        template = airspeed.Template('#undefined()')
+        self.assertRaises(Exception, template.merge, {})
+
+    def test_define_and_use_macro_with_no_parameters(self):
+        template = airspeed.Template('#macro ( hello)hi#end#hello ()#hello()')
+        self.assertEquals('hihi', template.merge({'text': 'hello'}))
+
+    def test_define_and_use_macro_with_one_parameter(self):
+        template = airspeed.Template('#macro ( bold $value)<strong>$value</strong>#end#bold ($text)')
+        self.assertEquals('<strong>hello</strong>', template.merge({'text': 'hello'}))
+
+    def test_use_of_macro_name_is_case_insensitive(self):
+        template = airspeed.Template('#macro ( bold $value)<strong>$value</strong>#end#BoLd ($text)')
+        self.assertEquals('<strong>hello</strong>', template.merge({'text': 'hello'}))
+
+    def test_define_and_use_macro_with_two_parameter(self):
+        template = airspeed.Template('#macro (addition $value1 $value2 )$value1+$value2#end#addition (1 2)')
+        self.assertEquals('1+2', template.merge({}))
+        template = airspeed.Template('#macro (addition $value1 $value2 )$value1+$value2#end#addition( $one   $two )')
+        self.assertEquals('ONE+TWO', template.merge({'one': 'ONE', 'two': 'TWO'}))
+
+    def test_cannot_redefine_macro(self):
+        template = airspeed.Template('#macro ( hello)hi#end#macro(hello)again#end')
+        self.assertRaises(Exception, template.merge, {}) ## Should this be TemplateSyntaxError?
+
 #
 # TODO:
 #
-#  Comparative operators >=, ==, !=, <=, !
 #  Math expressions
 #  Gobbling up whitespace (tricky!)
@@ -304 +335 @@
 #  list literals
 #  #parse, #include
-#  #macro
+#  Bind #macro calls at compile time?
+#  Interpolated strings
 #  Directives inside string literals
 #  map literals