Changeset 21 for trunk

Timestamp:

18/08/04 18:08:26 (8 years ago)

Author:

steve

Message:

avoid passing text fragments between elements: pass positions instead. make TemplateSyntaxError? aware of error positions

Location:

trunk

Files:

• airspeed.py (modified) (17 diffs)
• airspeed_test.py (modified) (1 diff)

trunk/airspeed.py

@@ -13 +13 @@
     def __init__(self, content):
         self.content = content
-        self.evaluator = None
+        self.root_element = None
 
     def merge(self, namespace):
@@ -21 +21 @@
 
     def merge_to(self, namespace, fileobj):
-        if not self.evaluator:
-            self.evaluator = TemplateBody(self.content)
-        self.evaluator.evaluate(namespace, fileobj)
+        if not self.root_element:
+            self.root_element = TemplateBody(self.content)
+        self.root_element.evaluate(namespace, fileobj)
 
 
 class TemplateSyntaxError(Exception):
-    def __init__(self, element, expected, got):
+    line = 0
+    def __init__(self, element, expected):
+        self.element = element
+        self.text_understood = element.full_text()[:element.end]
+        self.line = 1 + self.text_understood.count('\n')
+        self.column = len(self.text_understood) - self.text_understood.rfind('\n')
+        got = element.next_text()
         if len(got) > 40:
             got = got[:36] + ' ...'
-        Exception.__init__(self,"%s: expected %s, got: %s ..." % (element.__class__.__name__, expected, got))
+        Exception.__init__(self, "line %d, column %d: expected %s, got: %s ..." % (self.line, self.column, expected, got))
+
+    def get_position_strings(self):
+        error_line_start = 1 + self.text_understood.rfind('\n')
+        if '\n' in self.element.next_text():
+            error_line_end = self.element.next_text().find('\n') + self.element.end
+        else:
+            error_line_end = len(self.element.full_text())
+        error_line = self.element.full_text()[error_line_start:error_line_end]
+        caret_pos = self.column
+        return [error_line, ' ' * (caret_pos - 1) + '^']
 
 
@@ -54 +70 @@
 
 class _Element:
-    def identity_match(self, pattern, text):
-        m = pattern.match(text)
+    def __init__(self, text, start=0):
+        self._full_text = text
+        self.start = self.end = start
+        self.parse()
+
+    def next_text(self):
+        return self._full_text[self.end:]
+
+    def my_text(self):
+        return self._full_text[self.start:self.end]
+
+    def full_text(self):
+        return self._full_text
+
+    def syntax_error(self, expected):
+        return TemplateSyntaxError(self, expected)
+
+    def identity_match(self, pattern):
+        m = pattern.match(self._full_text, self.end)
         if not m: raise NoMatch()
-        return m.groups()
-
-    def require_match(self, pattern, text, expected):
-        m = pattern.match(text)
-        if not m: raise TemplateSyntaxError(self, expected, text)
-        return m.groups()
-
-    def next_element(self, element_spec, text):
+        self.end = m.start(pattern.groups)
+        return m.groups()[:-1]
+
+    def optional_match(self, pattern):
+        m = pattern.match(self._full_text, self.end)
+        if not m: return False
+        self.end = m.start(pattern.groups)
+        return True
+
+    def require_match(self, pattern, expected):
+        m = pattern.match(self._full_text, self.end)
+        if not m: raise self.syntax_error(expected)
+        self.end = m.start(pattern.groups)
+        return m.groups()[:-1]
+
+    def next_element(self, element_spec):
         if callable(element_spec):
-            element = element_spec(text)
-            return element, element.remaining_text
+            element = element_spec(self._full_text, self.end)
+            self.end = element.end
+            return element
         else:
             for element_class in element_spec:
-                try: element = element_class(text)
+                try: element = element_class(self._full_text, self.end)
                 except NoMatch: pass
-                else: return element, element.remaining_text
+                else:
+                    self.end = element.end
+                    return element
             raise NoMatch()
 
-    def require_next_element(self, element_spec, text, expected):
+    def require_next_element(self, element_spec, expected):
         if callable(element_spec):
-            try: element = element_spec(text)
-            except NoMatch: raise TemplateSyntaxError(self, expected, text)
-            else: return element, element.remaining_text
+            try: element = element_spec(self._full_text, self.end)
+            except NoMatch: raise self.syntax_error(expected)
+            else:
+                self.end = element.end
+                return element
         else:
             for element_class in element_spec:
-                try: element = element_class(text)
+                try: element = element_class(self._full_text, self.end)
                 except NoMatch: pass
-                else: return element, element.remaining_text
+                else:
+                    self.end = element.end
+                    return element
             expected = ', '.join([cls.__name__ for cls in element_spec])
-            raise TemplateSyntaxError(self, 'one of: ' + expected, text)
+            raise self.syntax_error(self, 'one of: ' + expected)
 
 
 class Text(_Element):
-    MY_PATTERN = re.compile(r'^((?:[^\\\$#]|\\[\$#])+|\$[^!\{a-z0-9_]|\$$|\\\\)(.*)$', re.S + re.I)
+    MY_PATTERN = re.compile(r'((?:[^\\\$#]|\\[\$#])+|\$[^!\{a-z0-9_]|\$$|\\\\)(.*)$', re.S + re.I)
     ESCAPED_CHAR = re.compile(r'\\([\\\$#])')
-    def __init__(self, text):
-        text, self.remaining_text = self.identity_match(self.MY_PATTERN, text)
+    def parse(self):
+        text, = self.identity_match(self.MY_PATTERN)
         def unescape(match):
             return match.group(1)
@@ -103 +151 @@
 
 class IntegerLiteral(_Element):
-    MY_PATTERN = re.compile(r'^(\d+)(.*)', re.S)
-    def __init__(self, text):
-        self.value, self.remaining_text = self.identity_match(self.MY_PATTERN, text)
+    MY_PATTERN = re.compile(r'(\d+)(.*)', re.S)
+    def parse(self):
+        self.value, = self.identity_match(self.MY_PATTERN)
         self.value = int(self.value)
 
@@ -113 +161 @@
 
 class StringLiteral(_Element):
-    MY_PATTERN = re.compile(r'^"((?:\\["nrbt\\\\]|[^"\n\r"\\])+)"(.*)', re.S)
+    MY_PATTERN = re.compile(r'"((?:\\["nrbt\\\\]|[^"\n\r"\\])+)"(.*)', re.S)
     ESCAPED_CHAR = re.compile(r'\\([nrbt"\\])')
-    def __init__(self, text):
-        value, self.remaining_text = self.identity_match(self.MY_PATTERN, text)
+    def parse(self):
+        value, = self.identity_match(self.MY_PATTERN)
         def unescape(match):
             return {'n': '\n', 'r': '\r', 'b': '\b', 't': '\t', '"': '"', '\\': '\\'}[match.group(1)]
@@ -126 +174 @@
 
 class Value(_Element):
-    def __init__(self, text):
-        self.expression, self.remaining_text = self.next_element((PlainReference, IntegerLiteral, StringLiteral), text)
+    def parse(self):
+        self.expression = self.next_element((SimpleReference, IntegerLiteral, StringLiteral))
 
     def calculate(self, namespace):
@@ -134 +182 @@
 
 class NameOrCall(_Element):
-    NAME_PATTERN = re.compile(r'^([a-zA-Z_][a-zA-Z0-9_]*)(.*)$', re.S)
+    NAME_PATTERN = re.compile(r'([a-zA-Z_][a-zA-Z0-9_]*)(.*)$', re.S)
     parameters = None
-    def __init__(self, text):
-        self.name, text = self.identity_match(self.NAME_PATTERN, text)
-        try: self.parameters, text = self.next_element(ParameterList, text)
+    def parse(self):
+        self.name, = self.identity_match(self.NAME_PATTERN)
+        try: self.parameters = self.next_element(ParameterList)
         except NoMatch: pass
-        self.remaining_text = text
 
     def calculate(self, namespace, top_namespace):
@@ -156 +203 @@
 
 class Expression(_Element):
-    def __init__(self, text):
-        self.names_and_calls = []
-        part, text = self.require_next_element(NameOrCall, text, 'name')
-        self.names_and_calls.append(part)
-        while text.startswith('.'):
+    DOT = re.compile('\.(.*)', re.S)
+    def parse(self):
+        self.parts = []
+        self.parts.append(self.require_next_element(NameOrCall, 'name'))
+        while self.optional_match(self.DOT):
             try:
-                part, text = self.next_element(NameOrCall, text[1:])
-                self.names_and_calls.append(part)
-            except NoMatch: break  # for the '$name. blah' case
-        self.remaining_text = text
+                self.parts.append(self.next_element(NameOrCall))
+            except NoMatch:
+                self.end -= 1  ### HACK
+                break  # for the '$name. blah' case
 
     def calculate(self, namespace):
         value = namespace
-        for part in self.names_and_calls:
+        for part in self.parts:
             value = part.calculate(value, namespace)
             if value is None: return None
@@ -176 +223 @@
 
 class ParameterList(_Element):
-    OPENING_PATTERN = re.compile(r'^\(\s*(.*)$', re.S)
-    CLOSING_PATTERN = re.compile(r'^\s*\)(.*)$', re.S)
-    COMMA_PATTERN = re.compile(r'^\s*,\s*(.*)$', re.S)
-
-    def __init__(self, text):
+    OPENING_PATTERN = re.compile(r'\(\s*(.*)$', re.S)
+    CLOSING_PATTERN = re.compile(r'\s*\)(.*)$', re.S)
+    COMMA_PATTERN = re.compile(r'\s*,\s*(.*)$', re.S)
+
+    def parse(self):
         self.values = []
-        text, = self.identity_match(self.OPENING_PATTERN, text)
-        try: value, text = self.next_element(Value, text)
+        self.identity_match(self.OPENING_PATTERN)
+        try: value = self.next_element(Value)
         except NoMatch:
             pass
         else:
             self.values.append(value)
-            while True:
-                m = self.COMMA_PATTERN.match(text)
-                if not m: break
-                value, text = self.require_next_element(Value, m.group(1), 'value')
+            while self.optional_match(self.COMMA_PATTERN):
+                value = self.require_next_element(Value, 'value')
                 self.values.append(value)
-        self.remaining_text, = self.require_match(self.CLOSING_PATTERN, text, ')')
+        self.require_match(self.CLOSING_PATTERN, ')')
 
 
 class Placeholder(_Element):
-    MY_PATTERN = re.compile(r'^\$(!?)(\{?)(.*)$', re.S)
-    CLOSING_BRACE_PATTERN = re.compile(r'^\}(.*)$', re.S)
-    def __init__(self, text):
-        self.silent, self.braces, text = self.identity_match(self.MY_PATTERN, text)
-        self.expression, text = self.require_next_element(Expression, text, 'expression')
-        if self.braces:
-            text, = self.require_match(self.CLOSING_BRACE_PATTERN, text, '}')
-        self.remaining_text = text
+    MY_PATTERN = re.compile(r'\$(!?)(\{?)(.*)$', re.S)
+    CLOSING_BRACE_PATTERN = re.compile(r'\}(.*)$', re.S)
+    def parse(self):
+        self.silent, self.braces = self.identity_match(self.MY_PATTERN)
+        self.expression = self.require_next_element(Expression, 'expression')
+        if self.braces: self.require_match(self.CLOSING_BRACE_PATTERN, '}')
 
     def evaluate(self, namespace, stream):
@@ -210 +253 @@
         if value is None:
             if self.silent: value = ''
-            else:
-                value_as_str = '.'.join([name.name for name in self.expression.names_and_calls])
-                if self.braces: value = '${%s}' % value_as_str
-                else: value = '$%s' % value_as_str
+            else: value = self.my_text()
         stream.write(str(value))
 
 
-class PlainReference(_Element):
-    def __init__(self, text):
-        if not text.startswith('$'): raise NoMatch()
-        self.expression, self.remaining_text = self.require_next_element(Expression, text[1:], 'name')
+class SimpleReference(_Element):
+    LEADING_DOLLAR = re.compile('\$(.*)', re.S)
+    def parse(self):
+        self.identity_match(self.LEADING_DOLLAR)
+        self.expression = self.require_next_element(Expression, 'name')
         self.calculate = self.expression.calculate
 
@@ -229 +270 @@
 
 class Comment(_Element, Null):
-    COMMENT_PATTERN = re.compile('^#(?:#.*?(?:\n|$)|\*.*?\*#(?:[ \t]*\n)?)(.*)$', re.M + re.S)
-    def __init__(self, text):
-        self.remaining_text, = self.identity_match(self.COMMENT_PATTERN, text)
+    COMMENT_PATTERN = re.compile('#(?:#.*?(?:\n|$)|\*.*?\*#(?:[ \t]*\n)?)(.*)$', re.M + re.S)
+    def parse(self):
+        self.identity_match(self.COMMENT_PATTERN)
 
 
 class Condition(_Element):
-    OPENING_PATTERN = re.compile(r'^\(\s*(.*)$', re.S)
-    CLOSING_PATTERN = re.compile(r'^\s*\)(.*)$', re.S)
-    def __init__(self, text):
-        text, = self.require_match(self.OPENING_PATTERN, text, '(')
-        self.expression, text = self.next_element(Value, text)
-        self.remaining_text, = self.require_match(self.CLOSING_PATTERN, text, ')')
+    OPENING_PATTERN = re.compile(r'\(\s*(.*)$', re.S)
+    CLOSING_PATTERN = re.compile(r'\s*\)(.*)$', re.S)
+    def parse(self):
+        self.require_match(self.OPENING_PATTERN, '(')
+        self.expression = self.next_element(Value)
+        self.require_match(self.CLOSING_PATTERN, ')')
         self.calculate = self.expression.calculate
 
 
 class End(_Element):
-    END = re.compile(r'^#end(.*)', re.I + re.S)
-    def __init__(self, text):
-        self.remaining_text, = self.identity_match(self.END, text)
+    END = re.compile(r'#end(.*)', re.I + re.S)
+    def parse(self):
+        self.identity_match(self.END)
 
 
 class ElseBlock(_Element):
-    START = re.compile(r'^#else(.*)$', re.S + re.I)
-    def __init__(self, text):
-        text, = self.identity_match(self.START, text)
-        self.block, self.remaining_text = self.require_next_element(Block, text, 'block')
+    START = re.compile(r'#else(.*)$', re.S + re.I)
+    def parse(self):
+        self.identity_match(self.START)
+        self.block = self.require_next_element(Block, 'block')
         self.evaluate = self.block.evaluate
 
 
 class ElseifBlock(_Element):
-    START = re.compile(r'^#elseif\b\s*(.*)$', re.S + re.I)
-    def __init__(self, text):
-        text, = self.identity_match(self.START, text)
-        self.condition, text = self.require_next_element(Condition, text, 'condition')
-        self.block, self.remaining_text = self.require_next_element(Block, text, 'block')
+    START = re.compile(r'#elseif\b\s*(.*)$', re.S + re.I)
+    def parse(self):
+        self.identity_match(self.START)
+        self.condition = self.require_next_element(Condition, 'condition')
+        self.block = self.require_next_element(Block, 'block')
         self.calculate = self.condition.calculate
         self.evaluate = self.block.evaluate
@@ -269 +310 @@
 
 class IfDirective(_Element):
-    START = re.compile(r'^#if\b\s*(.*)$', re.S + re.I)
-    START_ELSEIF = re.compile(r'^#elseif\b\s*(.*)$', re.S + re.I)
+    START = re.compile(r'#if\b\s*(.*)$', re.S + re.I)
+    START_ELSEIF = re.compile(r'#elseif\b\s*(.*)$', re.S + re.I)
     else_block = Null()
 
-    def __init__(self, text):
-        text, = self.identity_match(self.START, text)
-        self.condition, text = self.next_element(Condition, text)
-        self.block, text = self.next_element(Block, text)
+    def parse(self):
+        self.identity_match(self.START)
+        self.condition = self.next_element(Condition)
+        self.block = self.next_element(Block)
         self.elseifs = []
         while True:
             try:
-                elseif_block, text = self.next_element(ElseifBlock, text)
+                elseif_block = self.next_element(ElseifBlock)
                 self.elseifs.append(elseif_block)
             except NoMatch:
                 break
-        try: self.else_block, text = self.next_element(ElseBlock, text)
+        try: self.else_block = self.next_element(ElseBlock)
         except NoMatch: pass
-        end, self.remaining_text = self.require_next_element(End, text, '#else, #elseif or #end')
+        end = self.require_next_element(End, '#else, #elseif or #end')
 
     def evaluate(self, namespace, stream):
@@ -300 +341 @@
 
 class Assignment(_Element):
-    START = re.compile(r'^\s*\(\s*\$([a-z_][a-z0-9_]*)\s*=\s*(.*)$', re.S)
-    CLOSING_PATTERN = re.compile(r'^\s*\)(?:[ \t]*\r?\n)?(.*)$', re.S + re.M)
-    def __init__(self, text):
-        self.var_name, text = self.identity_match(self.START, text)
-        self.value, text = self.next_element(Value, text)
-        self.remaining_text, = self.require_match(self.CLOSING_PATTERN, text, ')')
+    START = re.compile(r'\s*\(\s*\$([a-z_][a-z0-9_]*)\s*=\s*(.*)$', re.S)
+    CLOSING_PATTERN = re.compile(r'\s*\)(?:[ \t]*\r?\n)?(.*)$', re.S + re.M)
+    def parse(self):
+        self.var_name, = self.identity_match(self.START)
+        self.value = self.next_element(Value)
+        self.require_match(self.CLOSING_PATTERN, ')')
 
     def calculate(self, namespace):
@@ -312 +353 @@
 
 class SetDirective(_Element):
-    START = re.compile(r'^#set\b(.*)', re.S + re.I)
-    def __init__(self, text):
-        text, = self.identity_match(self.START, text)
-        self.assignment, self.remaining_text = self.require_next_element(Assignment, text, 'assignment')
+    START = re.compile(r'#set\b(.*)', re.S + re.I)
+    def parse(self):
+        self.identity_match(self.START)
+        self.assignment = self.require_next_element(Assignment, 'assignment')
 
     def evaluate(self, namespace, stream):
@@ -322 +363 @@
 
 class ForeachDirective(_Element):
-    START = re.compile(r'^#foreach\s*\(\s*\$([a-z_][a-z0-9_]*)\s*in\s*(.*)$', re.S + re.I)
-    CLOSING_PATTERN = re.compile(r'^\s*\)(.*)$', re.S)
-    def __init__(self, text):
+    START = re.compile(r'#foreach\s*\(\s*\$([a-z_][a-z0-9_]*)\s*in\s*(.*)$', re.S + re.I)
+    CLOSING_PATTERN = re.compile(r'\s*\)(.*)$', re.S)
+    def parse(self):
         ## Could be cleaner b/c syntax error if no '('
-        self.loop_var_name, text = self.identity_match(self.START, text)
-        self.value, text = self.next_element(Value, text)
-        text, = self.require_match(self.CLOSING_PATTERN, text, ')')
-        self.block, text = self.next_element(Block, text)
-        end, self.remaining_text = self.require_next_element(End, text, '#end')
+        self.loop_var_name, = self.identity_match(self.START)
+        self.value = self.next_element(Value)
+        self.require_match(self.CLOSING_PATTERN, ')')
+        self.block = self.next_element(Block)
+        self.require_next_element(End, '#end')
 
     def evaluate(self, namespace, stream):
@@ -344 +385 @@
 
 class TemplateBody(_Element):
-    def __init__(self, text):
-        self.block, text = self.next_element(Block, text)
-        if text:
-            raise TemplateSyntaxError(self, 'block element', self.block.remaining_text)
+    def parse(self):
+        self.block = self.next_element(Block)
+        if self.next_text():
+            raise self.syntax_error('block element')
 
     def evaluate(self, namespace, stream):
@@ -355 +396 @@
 
 class Block(_Element):
-    def __init__(self, text):
+    def parse(self):
         self.children = []
-        while text:
+        while True:
             try:
-                child, text = self.next_element((Text, Placeholder, Comment, IfDirective, SetDirective, ForeachDirective), text)
-                self.children.append(child)
+                self.children.append(self.next_element((Text, Placeholder, Comment, IfDirective, SetDirective, ForeachDirective)))
             except NoMatch:
                 break
-        self.remaining_text = text
 
     def evaluate(self, namespace, stream):
         for child in self.children:
             child.evaluate(namespace, stream)
+

trunk/airspeed_test.py

@@ -234 +234 @@
         value1, value2 = False, False
         self.assertEquals(' three ', template.merge(locals()))
+
+    def test_syntax_error_contains_line_and_column_pos(self):
+        try: airspeed.Template('#if ( $hello )\n\n#elseif blah').merge({})
+        except airspeed.TemplateSyntaxError, e:
+            self.assertEquals((3, 9), (e.line, e.column))
+        else: self.fail('expected error')
+        try: airspeed.Template('#else blah').merge({})
+        except airspeed.TemplateSyntaxError, e:
+            self.assertEquals((1, 1), (e.line, e.column))
+        else: self.fail('expected error')
+
+    def test_get_position_strings_in_syntax_error(self):
+        try: airspeed.Template('#else whatever').merge({})
+        except airspeed.TemplateSyntaxError, e:
+            self.assertEquals(['#else whatever',
+                               '^'], e.get_position_strings())
+        else: self.fail('expected error')
+
+    def test_get_position_strings_in_syntax_error_when_newline_after_error(self):
+        try: airspeed.Template('#else whatever\n').merge({})
+        except airspeed.TemplateSyntaxError, e:
+            self.assertEquals(['#else whatever',
+                               '^'], e.get_position_strings())
+        else: self.fail('expected error')
+
+    def test_get_position_strings_in_syntax_error_when_newline_before_error(self):
+        try: airspeed.Template('foobar\n  #else whatever\n').merge({})
+        except airspeed.TemplateSyntaxError, e:
+            self.assertEquals(['  #else whatever',
+                               '  ^'], e.get_position_strings())
+        else: self.fail('expected error')
+
+
 #
 # TODO: