if test for $[] exports
diff --git a/reclass/errors.py b/reclass/errors.py
index b1504b8..2ee3c80 100644
--- a/reclass/errors.py
+++ b/reclass/errors.py
@@ -225,3 +225,8 @@
def _get_message(self):
msg = "Parse error: {0} : {1} at char {2}"
return msg.format(self._line, self._err, self._col - 1)
+
+class ExpressionError(ReclassException):
+
+ def __init__(self, msg, rc=posix.EX_DATAERR):
+ super(ExpressionError, self).__init__(rc=rc, msg=msg)
diff --git a/reclass/utils/dictpath.py b/reclass/utils/dictpath.py
index a7353b1..c5df56c 100644
--- a/reclass/utils/dictpath.py
+++ b/reclass/utils/dictpath.py
@@ -135,6 +135,7 @@
def drop_first(self):
del self._parts[0]
+ return self
def exists_in(self, base):
container = base
diff --git a/reclass/values/expitem.py b/reclass/values/expitem.py
index 252ba38..38e2e3d 100644
--- a/reclass/values/expitem.py
+++ b/reclass/values/expitem.py
@@ -5,16 +5,76 @@
#
import copy
+import pyparsing as pp
from item import Item
from reclass.utils.dictpath import DictPath
-from reclass.errors import UndefinedVariableError
+from reclass.errors import ExpressionError, UndefinedVariableError
+
+_VAR = 'VAR'
+_TEST = 'TEST'
+_VALUE = 'VALUE'
+
+_IF = 'IF'
+_EQUAL = '=='
+_NOT_EQUAL = '!='
class ExpItem(Item):
+ def _get_parser():
+
+ def _variable(string, location, tokens):
+ token = tokens[0]
+ tokens[0] = (_VAR, token)
+
+ def _test(string, location, tokens):
+ token = tokens[0]
+ tokens[0] = (_TEST, token)
+
+ def _if(string, location, tokens):
+ token = tokens[0]
+ tokens[0] = (_IF, token)
+
+ _EXCLUDES = '?!='
+ _END_IF = '?'
+
+ white_space = pp.White().suppress()
+ end = pp.StringEnd()
+ operator = (pp.Literal(_EQUAL) | pp.Literal(_NOT_EQUAL)).setParseAction(_test)
+ end_if = pp.Literal(_END_IF).setParseAction(_if)
+ not_operator = ~pp.Literal(_EQUAL) + ~pp.Literal(_NOT_EQUAL) + ~pp.Literal(_END_IF)
+ variable = not_operator + pp.Word(pp.printables).setParseAction(_variable)
+ item = (operator | end_if | variable) + (white_space | end)
+ expr = pp.Optional(white_space) + pp.OneOrMore(item)
+ return expr
+
+ _parser = _get_parser()
+
def __init__(self, item, delimiter):
self._delimiter = delimiter
- self._expr = item.render(None, None)
+ self._type = None
+ self._refs = []
+ self._expr = []
+ self._parse_expression(item.render(None, None))
+
+ def _parse_expression(self, expr):
+ try:
+ self._expr = ExpItem._parser.parseString(expr).asList()
+ except pp.ParseException as e:
+ raise ParseError(e.msg, e.line, e.col, e.lineno)
+
+ if len(self._expr) == 1 and self._expr[0][0] == _VAR:
+ self._type = _VALUE
+ return
+ elif len(self._expr) == 5 and self._expr[0][0] == _VAR and self._expr[1][0] == _TEST and self._expr[2][0] == _VAR and self._expr[3][0] == _IF and self._expr[4][0] == _VAR:
+ self._type = _TEST
+ export, parameter, value = self._get_vars(self._expr[0][1], None, None, None)
+ export, parameter, value = self._get_vars(self._expr[2][1], export, parameter, value)
+ if parameter != None:
+ path = DictPath(self._delimiter, parameter).drop_first()
+ self._ref.append(str(path))
+ return
+ raise ExpressionError('Failed to parse %s' % str(self))
def contents(self):
return self._expr
@@ -22,21 +82,88 @@
def has_exports(self):
return True
+ def has_references(self):
+ return len(self._refs) > 0
+
+ def get_references(self):
+ return self._refs
+
def _resolve(self, path, dictionary):
try:
return path.get_value(dictionary)
except KeyError as e:
raise UndefinedVariableError(str(path))
- def render(self, context, exports):
+ def _value_expression(self, exports):
result = []
- exp_path = DictPath(self._delimiter, self._expr)
- exp_path.drop_first()
+ path = DictPath(self._delimiter, self._expr[0][1]).drop_first()
for node, items in exports.iteritems():
- if exp_path.exists_in(items):
- value = { node: copy.deepcopy(self._resolve(exp_path, items)) }
+ if path.exists_in(items):
+ value = { node: copy.deepcopy(self._resolve(path, items)) }
result.append(value)
return result
+ def _if_expression(self, context, exports):
+ export_path = None
+ parameter_path = None
+ parameter_value = None
+ test = None
+ value_path = DictPath(self._delimiter, self._expr[4][1])
+
+ if self._expr[1][1] == _EQUAL:
+ test = _EQUAL
+ elif self._expr[1][1] == _NOT_EQUAL:
+ test = _NOT_EQUAL
+
+ export_path, parameter_path, parameter_value = self._get_vars(self._expr[0][1], export_path, parameter_path, parameter_value)
+ export_path, parameter_path, parameter_value = self._get_vars(self._expr[2][1], export_path, parameter_path, parameter_value)
+
+ if parameter_path != None:
+ parameter_path.drop_first()
+ parameter_value = str(self._resolve(parameter, context))
+
+ if export_path is None or parameter_value is None or test is None or value_path is None:
+ ExpressionError('Failed to render %s' % str(self))
+
+ export_path.drop_first()
+ value_path.drop_first()
+
+ results = []
+ for node, items in exports.iteritems():
+ if export_path.exists_in(items):
+ export_value = str(self._resolve(export_path, items))
+ test_passed = False
+ if test == _EQUAL and export_value == parameter_value:
+ test_passed = True
+ elif test == _NOT_EQUAL and export_value != parameter_value:
+ test_passed = True
+ if test_passed:
+ result = { node: copy.deepcopy(self._resolve(value_path, items)) }
+ results.append(result)
+ return results
+
+ def _get_vars(self, var, export, parameter, value):
+ if isinstance(var, str):
+ path = DictPath(self._delimiter, var)
+ if path.path[0] == 'exports':
+ export = path
+ elif path.path[0] == 'SELF':
+ parameter = path
+ else:
+ value = var
+ else:
+ value = var
+ return export, parameter, value
+
+ def render(self, context, exports):
+ if self._type == _VALUE:
+ return self._value_expression(exports)
+ elif self._type == _TEST:
+ return self._if_expression(context, exports)
+ raise ExpressionError('Failed to render %s' % str(self))
+
+ def __str__(self):
+ return ' '.join(str(j) for i,j in self._expr)
+
def __repr__(self):
- return 'ExpItem(%r)' % self._items
+ return 'ExpItem(%r)' % self._expr
diff --git a/reclass/values/value.py b/reclass/values/value.py
index 39e55c1..d9d8449 100644
--- a/reclass/values/value.py
+++ b/reclass/values/value.py
@@ -16,38 +16,13 @@
from reclass.defaults import PARAMETER_INTERPOLATION_DELIMITER, ESCAPE_CHARACTER, REFERENCE_SENTINELS, EXPORT_SENTINELS
from reclass.errors import *
-
_STR = 'STR'
_REF = 'REF'
_EXP = 'EXP'
-_ESCAPE = ESCAPE_CHARACTER
-_DOUBLE_ESCAPE = _ESCAPE + _ESCAPE
-
-_REF_OPEN = REFERENCE_SENTINELS[0]
-_REF_CLOSE = REFERENCE_SENTINELS[1]
-_REF_CLOSE_FIRST = _REF_CLOSE[0]
-_REF_ESCAPE_OPEN = _ESCAPE + _REF_OPEN
-_REF_ESCAPE_CLOSE = _ESCAPE + _REF_CLOSE
-_REF_DOUBLE_ESCAPE_OPEN = _DOUBLE_ESCAPE + _REF_OPEN
-_REF_DOUBLE_ESCAPE_CLOSE = _DOUBLE_ESCAPE + _REF_CLOSE
-_REF_EXCLUDES = _ESCAPE + _REF_OPEN + _REF_CLOSE
-
-_EXP_OPEN = EXPORT_SENTINELS[0]
-_EXP_CLOSE = EXPORT_SENTINELS[1]
-_EXP_CLOSE_FIRST = _EXP_CLOSE[0]
-_EXP_ESCAPE_OPEN = _ESCAPE + _EXP_OPEN
-_EXP_ESCAPE_CLOSE = _ESCAPE + _EXP_CLOSE
-_EXP_DOUBLE_ESCAPE_OPEN = _DOUBLE_ESCAPE + _EXP_OPEN
-_EXP_DOUBLE_ESCAPE_CLOSE = _DOUBLE_ESCAPE + _EXP_CLOSE
-_EXP_EXCLUDES = _ESCAPE + _EXP_OPEN + _EXP_CLOSE
-
-_EXCLUDES = _ESCAPE + _REF_OPEN + _REF_CLOSE + _EXP_OPEN + _EXP_CLOSE
-
-
class Value(object):
- def _getParser():
+ def _get_parser():
def _string(string, location, tokens):
token = tokens[0]
@@ -61,6 +36,29 @@
token = list(tokens[0])
tokens[0] = (_EXP, token)
+ _ESCAPE = ESCAPE_CHARACTER
+ _DOUBLE_ESCAPE = _ESCAPE + _ESCAPE
+
+ _REF_OPEN = REFERENCE_SENTINELS[0]
+ _REF_CLOSE = REFERENCE_SENTINELS[1]
+ _REF_CLOSE_FIRST = _REF_CLOSE[0]
+ _REF_ESCAPE_OPEN = _ESCAPE + _REF_OPEN
+ _REF_ESCAPE_CLOSE = _ESCAPE + _REF_CLOSE
+ _REF_DOUBLE_ESCAPE_OPEN = _DOUBLE_ESCAPE + _REF_OPEN
+ _REF_DOUBLE_ESCAPE_CLOSE = _DOUBLE_ESCAPE + _REF_CLOSE
+ _REF_EXCLUDES = _ESCAPE + _REF_OPEN + _REF_CLOSE
+
+ _EXP_OPEN = EXPORT_SENTINELS[0]
+ _EXP_CLOSE = EXPORT_SENTINELS[1]
+ _EXP_CLOSE_FIRST = _EXP_CLOSE[0]
+ _EXP_ESCAPE_OPEN = _ESCAPE + _EXP_OPEN
+ _EXP_ESCAPE_CLOSE = _ESCAPE + _EXP_CLOSE
+ _EXP_DOUBLE_ESCAPE_OPEN = _DOUBLE_ESCAPE + _EXP_OPEN
+ _EXP_DOUBLE_ESCAPE_CLOSE = _DOUBLE_ESCAPE + _EXP_CLOSE
+ _EXP_EXCLUDES = _ESCAPE + _EXP_OPEN + _EXP_CLOSE
+
+ _EXCLUDES = _ESCAPE + _REF_OPEN + _REF_CLOSE + _EXP_OPEN + _EXP_CLOSE
+
white_space = pp.White()
double_escape = pp.Combine(pp.Literal(_DOUBLE_ESCAPE) + pp.MatchFirst([pp.FollowedBy(_REF_OPEN), pp.FollowedBy(_REF_CLOSE)])).setParseAction(pp.replaceWith(_ESCAPE))
@@ -98,7 +96,7 @@
line = pp.OneOrMore(item) + pp.StringEnd()
return line
- _parser = _getParser()
+ _parser = _get_parser()
def __init__(self, val, delimiter=PARAMETER_INTERPOLATION_DELIMITER):
self._delimiter = delimiter