Open Build Service

_service:tar_scm:python-airspeed.spec Changed

@@ -1,11 +1,11 @@
 %global _empty_manifest_terminate_build 0
 Name:		python-airspeed
-Version:	0.5.17
+Version:	0.5.20
 Release:	1
 Summary:	Airspeed is a powerful and easy-to-use templating engine for Python that aims for a high level of compatibility with the popular Velocity library for Java.
 License:	BSD
 URL:		https://github.com/purcell/airspeed/
-Source0:	https://files.pythonhosted.org/packages/7d/f8/d69f29f5533f79c64637b469c2d967f36fd376d3f6ccd8d5be948bf15ef3/airspeed-0.5.17.tar.gz
+Source0:	https://files.pythonhosted.org/packages/b3/23/812b8ffea500acfa38463c291e85e78f7270e80be9d669fd79055ff2606b/airspeed-0.5.20.tar.gz
 BuildArch:	noarch
 
 %description
@@ -26,7 +26,7 @@
 Airspeed is a powerful and easy-to-use templating engine for Python that aims for a high level of compatibility with the popular Velocity library for Java.
 
 %prep
-%autosetup -n airspeed-0.5.17
+%autosetup -n airspeed-%{version}
 
 %build
 %py3_build
@@ -66,6 +66,9 @@
 %{_docdir}/*
 
 %changelog
+* Tue Oct 25 2022 liqiuyu <liqiuyu@kylinos.cn> - 0.5.20-1
+- Upgrade package to version 0.5.20
+
 * Thu Jul 22 2021 Xu Jin <jinxu@kylinos.cn> - 0.5.17-1
 - Update package to 0.5.17

_service:tar_scm:airspeed-0.5.17.tar.gz/PKG-INFO -> _service:tar_scm:airspeed-0.5.20.tar.gz/PKG-INFO Changed

_service:tar_scm:airspeed-0.5.17.tar.gz/README.md -> _service:tar_scm:airspeed-0.5.20.tar.gz/README.md Changed

_service:tar_scm:airspeed-0.5.17.tar.gz/airspeed.egg-info/PKG-INFO -> _service:tar_scm:airspeed-0.5.20.tar.gz/airspeed.egg-info/PKG-INFO Changed

_service:tar_scm:airspeed-0.5.17.tar.gz/airspeed/__init__.py -> _service:tar_scm:airspeed-0.5.20.tar.gz/airspeed/__init__.py Changed

@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 from __future__ import print_function
 
 import re
@@ -37,7 +36,8 @@
         'add': lambda self, value: self.append(value)
     },
     dict: {
-        'put': lambda self, key, value: self.update({key: value})
+        'put': lambda self, key, value: self.update({key: value}),
+        'keySet': lambda self: self.keys()
     }
 }
 
@@ -607,6 +607,11 @@
                 result = lambda *args: methods_for_type[self.name](current_object, *args)
         if result is None:
             return None  # TODO: an explicit 'not found' exception?
+        if isinstance(result, _FunctionDefinition):
+            params = self.parameters and self.parameters.calculate(top_namespace, loader) or []
+            stream = StoppableStream()
+            result.execute_function(stream, top_namespace, params, loader)
+            return stream.getvalue()
         if self.parameters is not None:
             result = result(*self.parameters.calculate(top_namespace, loader))
         elif self.index is not None:
@@ -629,14 +634,26 @@
     DOT = re.compile(r'\.(.*)', re.S)
 
     def parse(self):
-        self.identity_match(self.DOT)
-        self.expression = self.next_element(VariableExpression)
+        try:
+            self.identity_match(self.DOT)
+            self.expression = self.next_element(VariableExpression)
+        except NoMatch:
+            self.expression = self.next_element(ArrayIndex)
+            self.subexpression = None
+            try:
+                self.subexpression = self.next_element(SubExpression)
+            except NoMatch:
+                pass
 
     def calculate(self, current_object, loader, global_namespace):
-        return self.expression.calculate(
-            current_object,
-            loader,
-            global_namespace)
+        args = [current_object, loader]
+        if not isinstance(self.expression, ArrayIndex):
+            return self.expression.calculate(*(args + [global_namespace]))
+        index = self.expression.calculate(*args)
+        result = current_object[index]
+        if self.subexpression:
+            result = self.subexpression.calculate(result, loader, global_namespace)
+        return result
 
 
 class VariableExpression(_Element):
@@ -1002,29 +1019,20 @@
         val = self.value.calculate(namespace, loader)
         Template(val, "#evaluate").merge_to(namespace, stream, loader)
 
-class MacroDefinition(_Element):
-    START = re.compile(r'#macro\b(.*)', re.S + re.I)
+
+
+class _FunctionDefinition(_Element):
+    # Must be overridden to provide START and NAME patterns
     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')
+    RESERVED_NAMES = []
 
     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:
+        self.function_name, = self.require_match(self.NAME, 'function name')
+        if self.function_name.lower() in self.RESERVED_NAMES:
             raise self.syntax_error('non-reserved name')
         self.arg_names = []
         while True:
@@ -1037,27 +1045,39 @@
         self.block = self.require_next_element(Block, 'block')
         self.require_next_element(End, 'block')
 
+    def execute_function(self, stream, namespace, arg_values, loader):
+        if len(arg_values) != len(self.arg_names):
+            raise Exception(
+                "function %s expected %d arguments, got %d" %
+                (self.function_name, len(self.arg_names), len(arg_values)))
+        local_namespace = LocalNamespace(namespace)
+        local_namespace.update(zip(self.arg_names, arg_values))
+        self.block.evaluate(stream, local_namespace, loader)
+
+class MacroDefinition(_FunctionDefinition):
+    START = re.compile(r'#macro\b(.*)', re.S + re.I)
+    NAME = re.compile(r'\s*([a-z][a-z_0-9]*)\b(.*)', re.S + re.I)
+    RESERVED_NAMES = (
+        'if',
+        'else',
+        'elseif',
+        'set',
+        'macro',
+        'foreach',
+        'parse',
+        'include',
+        'stop',
+        'end',
+        'define')
+
     def evaluate_raw(self, stream, namespace, loader):
         global_ns = namespace.top()
-        macro_key = '#' + self.macro_name.lower()
+        macro_key = '#' + self.function_name.lower()
         if macro_key in global_ns:
             raise Exception("cannot redefine macro {0}".format(macro_key))
 
         global_ns[macro_key] = self
 
-    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, loader)
-        self.block.evaluate(stream, macro_namespace, loader)
-
-
 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)
@@ -1068,15 +1088,10 @@
         macro_name, = self.identity_match(self.START)
         self.macro_name = macro_name.lower()
         self.args = []
-        if self.macro_name in MacroDefinition.RESERVED_NAMES or \
-                self.macro_name.startswith('end'):
+        if self.macro_name in MacroDefinition.RESERVED_NAMES:
             raise NoMatch()
         if not self.optional_match(self.OPEN_PAREN):
-            # It's not really a macro call,
-            # it's just a spare pound sign with text after it,
-            # the typical example being a color spec: "#ffffff"
-            # call it not-a-match and then let another thing catch it
-            raise NoMatch()
+            raise NoMatch() # Typically a hex colour literal
         while True:
             try:
                 self.args.append(self.next_element(Value))
@@ -1091,8 +1106,15 @@
             macro = namespace['#' + self.macro_name]
         except KeyError:
             raise Exception('no such macro: ' + self.macro_name)
-        macro.execute_macro(stream, namespace, self.args, loader)
+        arg_values = [arg.calculate(namespace, loader) for arg in self.args]
+        macro.execute_function(stream, namespace, arg_values, loader)
 
+class DefineDefinition(_FunctionDefinition):
+    START = re.compile(r'#define\b(.*)', re.S + re.I)
+    NAME = re.compile(r'\s*\$([a-z][a-z_0-9]*)\b(.*)', re.S + re.I)
+
+    def evaluate_raw(self, stream, namespace, loader):
+        namespace[self.function_name] = self
 
 class IncludeDirective(_Element):
     START = re.compile(r'#include\b(.*)', re.S + re.I)
@@ -1247,6 +1269,7 @@
                          IncludeDirective,
                          ParseDirective,
                          MacroDefinition,
+                         DefineDefinition,
                          StopDirective,
                          UserDefinedDirective,
                          EvaluateDirective,

_service:tar_scm:airspeed-0.5.17.tar.gz/setup.py -> _service:tar_scm:airspeed-0.5.20.tar.gz/setup.py Changed

_service:tar_scm:python-airspeed-1666839265.9538242.tar Renamed

Changes of Revision 180