Changeset 33

Timestamp:

16/09/04 15:07:05 (8 years ago)

Author:

steve

Message:

interpolated strings

Location:

trunk

Files:

• airspeed.py (modified) (27 diffs)
• airspeed_test.py (modified) (3 diffs)

trunk/airspeed.py

@@ -30 +30 @@
         if loader is None: loader = NullLoader()
         self.ensure_compiled()
-        self.root_element.evaluate(namespace, fileobj, loader)
+        self.root_element.evaluate(fileobj, namespace, loader)
 
 
@@ -190 +190 @@
 
 class Text(_Element):
-    PLAIN = re.compile(r'((?:[^\\\$#]|\\[\$#])+|\$[^!\{a-z0-9_]|\$$|\\\\)(.*)$', re.S + re.I)
+    PLAIN = re.compile(r'((?:[^\\\$#]|\\[\$#])+|\$[^!\{a-z0-9_]|\$$|\\.)(.*)$', re.S + re.I)
     ESCAPED_CHAR = re.compile(r'\\([\\\$#])')
 
@@ -199 +199 @@
         self.text = self.ESCAPED_CHAR.sub(unescape, text)
 
-    def evaluate(self, namespace, stream, loader):
+    def evaluate(self, stream, namespace, loader):
         stream.write(self.text)
 
@@ -210 +210 @@
         self.value = int(self.value)
 
-    def calculate(self, namespace):
+    def calculate(self, namespace, loader):
         return self.value
 
 
 class StringLiteral(_Element):
-    STRING = re.compile(r'"((?:\\["nrbt\\\\]|[^"\n\r\\])+)"(.*)', re.S)
-    ESCAPED_CHAR = re.compile(r'\\([nrbt"\\])')
+    STRING = re.compile(r"'((?:\\['nrbt\\\\\\$]|[^'\n\r\\])+)'(.*)", re.S)
+    ESCAPED_CHAR = re.compile(r"\\([nrbt'\\])")
 
     def parse(self):
         value, = self.identity_match(self.STRING)
         def unescape(match):
-            return {'n': '\n', 'r': '\r', 'b': '\b', 't': '\t', '"': '"', '\\': '\\', "'": "'"}[match.group(1)]
+            return {'n': '\n', 'r': '\r', 'b': '\b', 't': '\t', '"': '"', '\\': '\\', "'": "'"}.get(match.group(1), '\\' + match.group(1))
         self.value = self.ESCAPED_CHAR.sub(unescape, value)
 
-    def calculate(self, namespace):
+    def calculate(self, namespace, loader):
         return self.value
 
-
-class SingleQuotedStringLiteral(StringLiteral):
-    STRING = re.compile(r"'((?:\\['nrbt\\\\]|[^'\n\r\\])+)'(.*)", re.S)
-    ESCAPED_CHAR = re.compile(r"\\([nrbt'\\])")
+class InterpolatedStringLiteral(StringLiteral):
+    STRING = re.compile(r'"((?:\\["nrbt\\\\\\$]|[^"\n\r\\])+)"(.*)', re.S)
+    ESCAPED_CHAR = re.compile(r'\\([nrbt"\\])')
+
+    def parse(self):
+        StringLiteral.parse(self)
+        self.block = Block(self.value, 0)
+
+    def calculate(self, namespace, loader):
+        output = StringIO.StringIO()
+        self.block.evaluate(output, namespace, loader)
+        return output.getvalue()
 
 
@@ -239 +247 @@
         self.value1, self.value2 = map(int, self.identity_match(self.RANGE))
 
-    def calculate(self, namespace):
+    def calculate(self, namespace, loader):
         if self.value2 < self.value1:
             return xrange(self.value1, self.value2 - 1, -1)
@@ -259 +267 @@
                 self.values.append(value)
 
-    def calculate(self, namespace):
+    def calculate(self, namespace, loader):
         for value in self.values:
-            yield value.calculate(namespace)
+            yield value.calculate(namespace, loader)
 
 
 class _EmptyValues:
-    def calculate(self, namespace):
+    def calculate(self, namespace, loader):
         return []
 
@@ -286 +294 @@
 class Value(_Element):
     def parse(self):
-        self.expression = self.next_element((SimpleReference, IntegerLiteral, StringLiteral, SingleQuotedStringLiteral, ArrayLiteral))
-
-    def calculate(self, namespace):
-        return self.expression.calculate(namespace)
+        self.expression = self.next_element((SimpleReference, IntegerLiteral, StringLiteral, InterpolatedStringLiteral, ArrayLiteral))
+
+    def calculate(self, namespace, loader):
+        return self.expression.calculate(namespace, loader)
 
 
@@ -301 +309 @@
         except NoMatch: pass
 
-    def calculate(self, current_object, top_namespace):
+    def calculate(self, current_object, loader, top_namespace):
         look_in_dict = True
         if not isinstance(current_object, LocalNamespace):
@@ -317 +325 @@
             return None ## TODO: an explicit 'not found' exception?
         if self.parameters is not None:
-            result = result(*self.parameters.calculate(top_namespace))
+            result = result(*self.parameters.calculate(top_namespace, loader))
         return result
 
@@ -328 +336 @@
         self.expression = self.next_element(VariableExpression)
 
-    def calculate(self, current_object, global_namespace):
-        return self.expression.calculate(current_object, global_namespace)
+    def calculate(self, current_object, loader, global_namespace):
+        return self.expression.calculate(current_object, loader, global_namespace)
 
 
@@ -340 +348 @@
         except NoMatch: pass
 
-    def calculate(self, namespace, global_namespace=None):
+    def calculate(self, namespace, loader, global_namespace=None):
         if global_namespace == None:
             global_namespace = namespace
-        value = self.part.calculate(namespace, global_namespace)
+        value = self.part.calculate(namespace, loader, global_namespace)
         if self.subexpression:
-            value = self.subexpression.calculate(value, namespace)
+            value = self.subexpression.calculate(value, loader, namespace)
         return value
 
@@ -361 +369 @@
         self.require_match(self.END, ')')
 
-    def calculate(self, namespace):
-        return self.values.calculate(namespace)
+    def calculate(self, namespace, loader):
+        return self.values.calculate(namespace, loader)
 
 
@@ -374 +382 @@
         if self.braces: self.require_match(self.CLOSING_BRACE, '}')
 
-    def evaluate(self, namespace, stream, loader):
-        value = self.expression.calculate(namespace)
+    def evaluate(self, stream, namespace, loader):
+        value = self.expression.calculate(namespace, loader)
         if value is None:
             if self.silent: value = ''
@@ -392 +400 @@
 
 class Null:
-    def evaluate(self, namespace, stream, loader): pass
+    def evaluate(self, stream, namespace, loader): pass
 
 
@@ -428 +436 @@
         self.require_match(self.END, ') or >')
 
-    def calculate(self, namespace):
+    def calculate(self, namespace, loader):
         if self.binary_operator is None:
-            return self.value.calculate(namespace)
-        value1, value2 = self.value.calculate(namespace), self.value2.calculate(namespace)
+            return self.value.calculate(namespace, loader)
+        value1, value2 = self.value.calculate(namespace, loader), self.value2.calculate(namespace, loader)
         return self.binary_operator.apply_to(value1, value2)
 
@@ -478 +486 @@
         self.require_next_element(End, '#else, #elseif or #end')
 
-    def evaluate(self, namespace, stream, loader):
-        if self.condition.calculate(namespace):
-            self.block.evaluate(namespace, stream, loader)
+    def evaluate(self, stream, namespace, loader):
+        if self.condition.calculate(namespace, loader):
+            self.block.evaluate(stream, namespace, loader)
         else:
             for elseif in self.elseifs:
-                if elseif.calculate(namespace):
-                    elseif.evaluate(namespace, stream, loader)
+                if elseif.calculate(namespace, loader):
+                    elseif.evaluate(stream, namespace, loader)
                     return
-            self.else_block.evaluate(namespace, stream, loader)
+            self.else_block.evaluate(stream, namespace, loader)
 
 
@@ -498 +506 @@
         self.require_match(self.END, ')')
 
-    def calculate(self, namespace):
-        namespace[self.var_name] = self.value.calculate(namespace)
+    def evaluate(self, stream, namespace, loader):
+        namespace[self.var_name] = self.value.calculate(namespace, loader)
 
 
@@ -524 +532 @@
         self.require_next_element(End, 'block')
 
-    def evaluate(self, namespace, stream, loader):
+    def evaluate(self, stream, namespace, loader):
         macro_key = '#' + self.macro_name.lower()
         if macro_key in namespace:
@@ -530 +538 @@
         namespace[macro_key] = self
 
-    def execute_macro(self, namespace, stream, arg_value_elements, loader):
+    def execute_macro(self, stream, namespace, arg_value_elements, loader):
         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, loader)
+            macro_namespace[arg_name] = arg_value.calculate(namespace, loader)
+        self.block.evaluate(stream, macro_namespace, loader)
 
 
@@ -558 +566 @@
         self.require_match(self.CLOSE_PAREN, 'argument value or )')
 
-    def evaluate(self, namespace, stream, loader):
+    def evaluate(self, stream, namespace, loader):
         try: macro = namespace['#' + self.macro_name]
         except KeyError: raise Exception('no such macro: ' + self.macro_name)
-        macro.execute_macro(namespace, stream, self.args, loader)
+        macro.execute_macro(stream, namespace, self.args, loader)
 
 
@@ -572 +580 @@
         self.identity_match(self.START)
         self.require_match(self.OPEN_PAREN, '(')
-        self.name = self.require_next_element((StringLiteral, SingleQuotedStringLiteral, SimpleReference), 'template name')
+        self.name = self.require_next_element((StringLiteral, InterpolatedStringLiteral, SimpleReference), 'template name')
         self.require_match(self.CLOSE_PAREN, ')')
 
-    def evaluate(self, namespace, stream, loader):
-        stream.write(loader.load_text(self.name.calculate(namespace)))
+    def evaluate(self, stream, namespace, loader):
+        stream.write(loader.load_text(self.name.calculate(namespace, loader)))
 
 
@@ -587 +595 @@
         self.identity_match(self.START)
         self.require_match(self.OPEN_PAREN, '(')
-        self.name = self.require_next_element((StringLiteral, SingleQuotedStringLiteral, SimpleReference), 'template name')
+        self.name = self.require_next_element((StringLiteral, InterpolatedStringLiteral, SimpleReference), 'template name')
         self.require_match(self.CLOSE_PAREN, ')')
 
-    def evaluate(self, namespace, stream, loader):
-        template = loader.load_template(self.name.calculate(namespace))
+    def evaluate(self, stream, namespace, loader):
+        template = loader.load_template(self.name.calculate(namespace, loader))
         ## TODO: local namespace?
         template.merge_to(namespace, stream, loader=loader)
@@ -603 +611 @@
         self.assignment = self.require_next_element(Assignment, 'assignment')
 
-    def evaluate(self, namespace, stream, loader):
-        self.assignment.calculate(namespace)
+    def evaluate(self, stream, namespace, loader):
+        self.assignment.evaluate(stream, namespace, loader)
 
 
@@ -625 +633 @@
         self.require_next_element(End, '#end')
 
-    def evaluate(self, namespace, stream, loader):
-        iterable = self.value.calculate(namespace)
+    def evaluate(self, stream, namespace, loader):
+        iterable = self.value.calculate(namespace, loader)
         counter = 1
         try:
@@ -633 +641 @@
                 namespace['velocityCount'] = counter
                 namespace[self.loop_var_name] = item
-                self.block.evaluate(namespace, stream, loader)
+                self.block.evaluate(stream, namespace, loader)
                 counter += 1
         except TypeError:
-            print iterable
             raise
 
@@ -646 +653 @@
             raise self.syntax_error('block element')
 
-    def evaluate(self, namespace, stream, loader):
+    def evaluate(self, stream, namespace, loader):
         namespace = LocalNamespace(namespace)
-        self.block.evaluate(namespace, stream, loader)
+        self.block.evaluate(stream, namespace, loader)
 
 
@@ -658 +665 @@
             except NoMatch: break
 
-    def evaluate(self, namespace, stream, loader):
+    def evaluate(self, stream, namespace, loader):
         for child in self.children:
-            child.evaluate(namespace, stream, loader)
+            child.evaluate(stream, namespace, loader)

trunk/airspeed_test.py

@@ -179 +179 @@
         self.assertEquals("1296", template.merge(locals()))
 
-    def test_can_call_function_with_one_parameter(self):
+    def test_can_call_function_with_two_parameters(self):
         def multiply(number1, number2):
             return number1 * number2
@@ -398 +398 @@
         self.assertEquals(" $user.name ", template.merge({'user':MyObject()}))
 
+    def test_variables_expanded_in_double_quoted_strings(self):
+        template = airspeed.Template('#set($hello="hello, $name is my name")$hello')
+        self.assertEquals("hello, Steve is my name", template.merge({'name':'Steve'}))
+
+    def test_escaped_variable_references_not_expanded_in_double_quoted_strings(self):
+        template = airspeed.Template('#set($hello="hello, \\$name is my name")$hello')
+        self.assertEquals("hello, $name is my name", template.merge({'name':'Steve'}))
+
+    def test_macros_expanded_in_double_quoted_strings(self):
+        template = airspeed.Template('#macro(hi $person)$person says hello#end#set($hello="#hi($name)")$hello')
+        self.assertEquals("Steve says hello", template.merge({'name':'Steve'}))
+
 #
 # TODO:
 #
+#  Report locations for template errors in strings
 #  Math expressions
 #  Gobbling up whitespace (tricky!)
@@ -406 +419 @@
 #  Bind #macro calls at compile time?
 #  #stop ?
-#  Interpolated strings -- what about \$ etc?
-#  Directives inside string literals
 #  map literals
 #  Sub-object assignment:  #set( $customer.Behavior = $primate )