[Checkins] SVN: Sandbox/malthe/chameleon.genshi/src/chameleon/genshi/expressions.py Use interpolation expression parsing capabilities in core package.

[Malthe Borch]

Log message for revision 91349:
  Use interpolation expression parsing capabilities in core package.

Changed:
  U   Sandbox/malthe/chameleon.genshi/src/chameleon/genshi/expressions.py

-=-
Modified: Sandbox/malthe/chameleon.genshi/src/chameleon/genshi/expressions.py
===================================================================
--- Sandbox/malthe/chameleon.genshi/src/chameleon/genshi/expressions.py	2008-09-22 16:01:58 UTC (rev 91348)
+++ Sandbox/malthe/chameleon.genshi/src/chameleon/genshi/expressions.py	2008-09-22 16:02:44 UTC (rev 91349)
@@ -5,6 +5,7 @@
 from zope import component
 
 from chameleon.core import types
+from chameleon.core import parsing
 
 class ExpressionTranslator(object):
     """Genshi expression translation."""
@@ -12,8 +13,6 @@
     re_method = re.compile(r'^(?P<name>[A-Za-z0-9_]+)'
                            '(\((?P<args>[A-Za-z0-9_]+\s*(,\s*[A-Za-z0-9_]+)*)\))?')
 
-    re_interpolation = re.compile(r'(?P<prefix>[^\\]\$|^\$)({((?P<expression>.*)})?|'
-                                  '(?P<variable>[A-Za-z][A-Za-z0-9_]*))')
 
     def declaration(self, string):
         """Variable declaration.
@@ -311,130 +310,6 @@
         return types.value(string.strip())
 
     def split(self, string):
-        """Split up an interpolation string expression into parts that
-        are either unicode strings or ``value``-tuples.
-
-        >>> class MockTranslator(ExpressionTranslator):
-        ...     def expression(self, string):
-        ...         return types.value(string)
+        return parsing.interpolate(string, self.expression)
         
-        >>> split = MockTranslator().split
-
-        >>> split("${abc}")
-        (value('abc'),)
-
-        >>> split(" ${abc}")
-        (' ', value('abc'))
-
-        >>> split("abc${def}")
-        ('abc', value('def'))
-
-        >>> split("${def}abc")
-        (value('def'), 'abc')
-
-        >>> split("abc${def}ghi")
-        ('abc', value('def'), 'ghi')
-
-        >>> split("abc${def}ghi${jkl}")
-        ('abc', value('def'), 'ghi', value('jkl'))
-
-        >>> split("abc${def}")
-        ('abc', value('def'))
-
-        >>> print split(u"abc${ghi}")
-        (u'abc', value('ghi'))
-        
-        """
-
-        m = self.interpolate(string)
-        if m is None:
-            return (string,)
-
-        prefix = m.group('prefix')
-        parts = []
-        
-        start = m.start() + len(prefix) - 1
-        if start > 0:
-            text = string[:start]
-            parts.append(text)
-
-        expression = m.group('expression')
-        variable = m.group('variable')
-
-        if expression:
-            parts.append(self.expression(expression))
-        elif variable:
-            parts.append(self.expression(variable))
-                
-        rest = string[m.end():]
-        if len(rest):
-            parts.extend(self.split(rest))
-
-        return tuple(parts)
-
-    def interpolate(self, string):
-        """Search for an interpolation and return a match.
-
-        >>> class MockTranslator(ExpressionTranslator):
-        ...     def expression(self, string):
-        ...         return types.parts((types.value(string),))
-
-        >>> interpolate = MockTranslator().interpolate
-        
-        >>> interpolate('${abc}').group('expression')
-        'abc'
-
-        >>> interpolate(' ${abc}').group('expression')
-        'abc'
-
-        >>> interpolate('abc${def}').group('expression')
-        'def'
-
-        >>> interpolate('abc${def}ghi${jkl}').group('expression')
-        'def'
-
-        >>> interpolate('$abc').group('variable')
-        'abc'
-
-        >>> interpolate('${abc')
-        Traceback (most recent call last):
-          ...
-        SyntaxError: Interpolation expressions must be of the form ${<expression>} (${abc)
-        
-        """
-
-        m = self.re_interpolation.search(string)
-        if m is None:
-            return None
-
-        expression = m.group('expression')
-        variable = m.group('variable')
-        
-        if expression:
-            left = m.start()+len(m.group('prefix'))+1
-            right = string.find('}')
-
-            while right != -1:
-                match = string[left:right]
-                try:
-                    exp = self.expression(match)
-                    break
-                except SyntaxError:
-                    right = string.find('}', right)
-            else:
-                raise
-
-            string = string[:right+1]
-            return self.re_interpolation.search(string)
-
-        if m is None or (expression is None and variable is None):
-            raise SyntaxError(
-                "Interpolation expressions must be of the "
-                "form ${<expression>} (%s)" % string)
-
-        if expression and not m.group('expression'):
-            raise SyntaxError(expression)
-
-        return m
-
 translator = ExpressionTranslator()