class SetVariables(object):
def __init__(self):
self._test = NormalizedDict(ignore='_')
self._scopes = [self._test]
def end_test(self):
self._test.clear()
def start_keyword(self):
self._scopes.append(self._scopes[-1].copy())
def end_keyword(self):
self._scopes.pop()
def set_test(self, name, value):
for scope in self._scopes:
scope[name] = value
def set_keyword(self, name, value):
self._scopes[-1][name] = value
def update_keyword(self, kw):
for name, value in self._scopes[-1].items():
kw[name] = value
class VariableStore(object):
def __init__(self, variables):
self.store = NormalizedDict(ignore='_')
self._variables = variables
def resolve_delayed(self):
for name, value in self.store.items():
try:
self._resolve_delayed(name, value)
except DataError:
pass
def _resolve_delayed(self, name, value):
if not isinstance(value, DelayedVariable):
return value
self.store[name] = value.resolve(name, self._variables)
return self.store[name]
def find(self, name):
return self._resolve_delayed(name, self.store[name])
def __getitem__(self, name):
return self.find(name) # TODO: __getitem__ vs find
def clear(self):
self.store.clear()
def add(self, name, value, overwrite=True):
if overwrite or name not in self.store:
self.store[name] = value
def remove(self, name):
if name in self.store:
self.store.pop(name)
def __len__(self):
return len(self.store)
def __iter__(self):
return iter(self.store)
def __contains__(self, name):
return name in self.store
class VariableStore(object):
def __init__(self, variables):
self.store = NormalizedDict(ignore='_')
self._variables = variables
def resolve_delayed(self):
for name, value in self.store.items():
try:
self._resolve_delayed(name, value)
except DataError:
pass
def _resolve_delayed(self, name, value):
if not isinstance(value, DelayedVariable):
return value
self.store[name] = value.resolve(name, self._variables)
return self.store[name]
def find(self, name):
return self._resolve_delayed(name, self.store[name])
def __getitem__(self, name):
return self.find(name) # TODO: __getitem__ vs find
def clear(self):
self.store.clear()
def add(self, name, value, overwrite=True):
if overwrite or name not in self.store:
self.store[name] = value
def remove(self, name):
if name in self.store:
self.store.pop(name)
def __len__(self):
return len(self.store)
def __iter__(self):
return iter(self.store)
def __contains__(self, name):
return name in self.store
class VariableStore(object):
def __init__(self, variables):
self.data = NormalizedDict(ignore='_')
self._variables = variables
def resolve_delayed(self):
for name, value in self.data.items():
try:
self._resolve_delayed(name, value)
except DataError:
pass
def _resolve_delayed(self, name, value):
if not isinstance(value, VariableTableValueBase):
return value
try:
self.data[name] = value.resolve(self._variables)
except DataError as err:
# Recursive resolving may have already removed variable.
if name in self:
self.remove(name)
value.report_error(err)
raise_not_found('${%s}' % name, self.data,
"Variable '${%s}' not found." % name)
return self.data[name]
def __getitem__(self, name):
return self._resolve_delayed(name, self.data[name])
def update(self, store):
self.data.update(store.data)
def clear(self):
self.data.clear()
def add(self, name, value, overwrite=True, decorated=True):
if decorated:
name, value = self._undecorate(name, value)
if overwrite or name not in self.data:
self.data[name] = value
def _undecorate(self, name, value):
validate_var(name)
if name[0] == '@':
if not is_list_like(value):
self._raise_cannot_set_type(name, value, 'list')
value = list(value)
if name[0] == '&':
if not is_dict_like(value):
self._raise_cannot_set_type(name, value, 'dictionary')
value = DotDict(value)
return name[2:-1], value
def _raise_cannot_set_type(self, name, value, expected):
raise DataError("Cannot set variable '%s': Expected %s-like value, "
"got %s." % (name, expected, type_name(value)))
def remove(self, name):
if name in self.data:
self.data.pop(name)
def __len__(self):
return len(self.data)
def __iter__(self):
return iter(self.data)
def __contains__(self, name):
return name in self.data
def as_dict(self):
variables = (self._decorate(name, self[name]) for name in self)
return NormalizedDict(variables, ignore='_')
def _decorate(self, name, value):
if is_dict_like(value):
name = '&{%s}' % name
elif is_list_like(value):
name = '@{%s}' % name
else:
name = '${%s}' % name
return name, value
def test_clear(self):
nd = NormalizedDict({'a': 1, 'B': 2})
nd.clear()
assert_equal(nd._data, {})
assert_equal(nd._keys, {})
class VariableStore(object):
def __init__(self, variables):
self.data = NormalizedDict(ignore='_')
self._variables = variables
def resolve_delayed(self, item=None):
if item:
return self._resolve_delayed(*item)
for name, value in list(self.data.items()):
try:
self._resolve_delayed(name, value)
except DataError:
pass
def _resolve_delayed(self, name, value):
if not self._is_resolvable(value):
return value
try:
self.data[name] = value.resolve(self._variables)
except DataError as err:
# Recursive resolving may have already removed variable.
if name in self:
self.remove(name)
value.report_error(err)
variable_not_found('${%s}' % name, self.data,
"Variable '${%s}' not found." % name)
return self.data[name]
def _is_resolvable(self, value):
try: # isinstance can throw an exception in ironpython and jython
return isinstance(value, VariableTableValueBase)
except Exception:
return False
def __getitem__(self, name):
return self._resolve_delayed(name, self.data[name])
def update(self, store):
self.data.update(store.data)
def clear(self):
self.data.clear()
def add(self, name, value, overwrite=True, decorated=True):
if decorated:
name, value = self._undecorate(name, value)
if overwrite or name not in self.data:
self.data[name] = value
def _undecorate(self, name, value):
validate_var(name)
if name[0] == '@':
if not is_list_like(value):
self._raise_cannot_set_type(name, value, 'list')
value = list(value)
if name[0] == '&':
if not is_dict_like(value):
self._raise_cannot_set_type(name, value, 'dictionary')
value = DotDict(value)
return name[2:-1], value
def _raise_cannot_set_type(self, name, value, expected):
raise VariableError("Cannot set variable '%s': Expected %s-like value, "
"got %s." % (name, expected, type_name(value)))
def remove(self, name):
if name in self.data:
self.data.pop(name)
def __len__(self):
return len(self.data)
def __iter__(self):
return iter(self.data)
def __contains__(self, name):
return name in self.data
def as_dict(self, decoration=True):
if decoration:
variables = (self._decorate(name, self[name]) for name in self)
else:
variables = self.data
return NormalizedDict(variables, ignore='_')
def _decorate(self, name, value):
if is_dict_like(value):
name = '&{%s}' % name
elif is_list_like(value):
name = '@{%s}' % name
else:
name = '${%s}' % name
return name, value
def test_clear(self):
nd = NormalizedDict({'a': 1, 'B': 2})
nd.clear()
assert_equals(nd.data, {})
assert_equals(nd._keys, {})
class VariableStore(object):
def __init__(self, variables):
self.data = NormalizedDict(ignore='_')
self._variables = variables
def resolve_delayed(self):
for name, value in self.data.items():
try:
self._resolve_delayed(name, value)
except DataError:
pass
def _resolve_delayed(self, name, value):
if not isinstance(value, VariableTableValueBase):
return value
try:
self.data[name] = value.resolve(self._variables)
except DataError as err:
# Recursive resolving may have already removed variable.
if name in self:
self.remove(name)
value.report_error(err)
raise_not_found('${%s}' % name, self.data,
"Variable '${%s}' not found." % name)
return self.data[name]
def find(self, name):
return self._resolve_delayed(name, self.data[name])
def __getitem__(self, name):
return self.find(name) # TODO: __getitem__ vs find
def clear(self):
self.data.clear()
def add(self, name, value, overwrite=True, decorated=True):
if decorated:
name, value = self._undecorate(name, value)
if overwrite or name not in self.data:
self.data[name] = value
def _undecorate(self, name, value):
validate_var(name)
if name[0] == '@':
if not is_list_like(value):
self._raise_cannot_set_type(name, value, 'list')
value = list(value)
if name[0] == '&':
if not is_dict_like(value):
self._raise_cannot_set_type(name, value, 'dictionary')
value = DotDict(value)
return name[2:-1], value
def _raise_cannot_set_type(self, name, value, expected):
raise DataError("Cannot set variable '%s': Expected %s-like value, "
"got %s." % (name, expected, type_name(value)))
def remove(self, name):
if name in self.data:
self.data.pop(name)
def __len__(self):
return len(self.data)
def __iter__(self):
return iter(self.data)
def __contains__(self, name):
return name in self.data
def test_clear(self):
nd = NormalizedDict({"a": 1, "B": 2})
nd.clear()
assert_equals(nd.data, {})
assert_equals(nd._keys, {})
class VariableStore:
def __init__(self, variables):
self.data = NormalizedDict(ignore='_')
self._variables = variables
def resolve_delayed(self, item=None):
if item:
return self._resolve_delayed(*item)
for name, value in list(self.data.items()):
try:
self._resolve_delayed(name, value)
except DataError:
pass
def _resolve_delayed(self, name, value):
if not self._is_resolvable(value):
return value
try:
self.data[name] = value.resolve(self._variables)
except DataError as err:
# Recursive resolving may have already removed variable.
if name in self.data:
self.data.pop(name)
value.report_error(err)
variable_not_found('${%s}' % name, self.data)
return self.data[name]
def _is_resolvable(self, value):
try:
return isinstance(value, Resolvable)
except Exception:
return False
def __getitem__(self, name):
if name not in self.data:
variable_not_found('${%s}' % name, self.data)
return self._resolve_delayed(name, self.data[name])
def get(self, name, default=NOT_SET, decorated=True):
try:
if decorated:
name = self._undecorate(name)
return self[name]
except VariableError:
if default is NOT_SET:
raise
return default
def update(self, store):
self.data.update(store.data)
def clear(self):
self.data.clear()
def add(self, name, value, overwrite=True, decorated=True):
if decorated:
name, value = self._undecorate_and_validate(name, value)
if (overwrite or name not in self.data
or isinstance(self.data[name], GlobalVariableValue)):
self.data[name] = value
def _undecorate(self, name):
if not is_assign(name):
raise VariableError("Invalid variable name '%s'." % name)
return name[2:-1]
def _undecorate_and_validate(self, name, value):
undecorated = self._undecorate(name)
if name[0] == '@':
if not is_list_like(value):
self._raise_cannot_set_type(name, value, 'list')
value = list(value)
if name[0] == '&':
if not is_dict_like(value):
self._raise_cannot_set_type(name, value, 'dictionary')
value = DotDict(value)
return undecorated, value
def _raise_cannot_set_type(self, name, value, expected):
raise VariableError(
"Cannot set variable '%s': Expected %s-like value, got %s." %
(name, expected, type_name(value)))
def __len__(self):
return len(self.data)
def __iter__(self):
return iter(self.data)
def __contains__(self, name):
return name in self.data
def as_dict(self, decoration=True):
if decoration:
variables = (self._decorate(name, self[name]) for name in self)
else:
variables = self.data
return NormalizedDict(variables, ignore='_')
def _decorate(self, name, value):
if is_dict_like(value):
name = '&{%s}' % name
elif is_list_like(value):
name = '@{%s}' % name
else:
name = '${%s}' % name
return name, value
