def verify_rules_dict_identifier(identifier, kind, allow_keywords=[]):
"""Helper function to verify validity of identifiers used in rules dicts.
:param str identifier: the identifier to be validated
:param str kind: kind of identifier for error messages
:param list(str) allow_keywords: list of keywords that are allowed
for this identifier
:raises ValueError: if ``identifier`` is not valid
"""
rules_dict_keywords = {'any_os', 'any_version', 'default_installer',
'unset_installers', 'any_key'}
# FIXME: implement this whitelist differently (specific to where it
# might occur)
rules_dict_whitelist = {'mountain lion'}
# NOTE: 'unset_installers' is reserved for future use, not yet implemented.
if not isinstance(identifier, text_type):
raise ValueError(type_error_msg("str", identifier, what_for=kind))
if identifier in rules_dict_keywords - set(allow_keywords):
raise ValueError("{0} is disallowed keyword '{1}'.".
format(kind, identifier))
if identifier in rules_dict_whitelist:
return
if not re.match('(?u)^[\w.’+-]+$', identifier):
raise ValueError(
"{0} '{1}' has disallowed characters. Allowed are: alphanumeric, "
"dash, dot, underscore.".format(kind, identifier))
def from_yaml(self, value):
if value == UNSET_YAML:
return self.unset_value()
if not isinstance(value, list):
raise ConfigValueError(type_error_msg('list', value))
return self.verify(
[self.element_type.from_yaml(elt) for elt in value])
def __init__(self, os, version):
"""Setup the `OSOverride` with given os object and version string.
:param OS os: object of class derived from `OS` that this object
imitates
:param str version: version of the imitated OS; if None is
passed, the version is detected
:type version: `str` or ``None``
:raises UnsupportedOSError: if ``os`` is not valid
:raises UnsupportedOSVersionError: if ``version`` is not a known
version for ``os``; for ``version is None`` if the version
cannot be detected
"""
if not isinstance(os, OS):
raise UnsupportedOSError(
type_error_msg("OS", os, what_for="os override"))
self.os = os
if version is None:
self.version = os.get_version()
else:
if version not in os.known_versions:
raise UnsupportedOSVersionError(
"Cannot override OS '{}' with unknown version '{}'.".
format(os.name, version))
self.version = version
def from_yaml(self, value):
if value == UNSET_YAML:
return self.unset_value()
if not isinstance(value, dict):
raise ConfigValueError(type_error_msg("dict", value))
result = {}
for k, v in six.iteritems(value):
result[self.key_type.from_yaml(k)] = \
self.value_type.from_yaml(v)
return self.verify(result)
def verify(self, value):
if not self.is_unset(value):
if not isinstance(value, list):
raise ConfigValueError(type_error_msg('list', value))
try:
for elt in value:
self.element_type.verify(elt)
except ConfigValueError as e:
raise_from(ConfigValueError, "invalid list element", e)
return value
def verify(self, value):
if not self.is_unset(value):
if not isinstance(value, dict):
raise ConfigValueError(type_error_msg('dict', value))
try:
for k, v in six.iteritems(value):
self.key_type.verify(k)
self.value_type.verify(v)
except ConfigValueError as e:
raise_from(ConfigValueError, "invalid key or value", e)
return value
def parse_single(input):
try:
result = load_yaml(input)
except YAMLError:
result = None
if not isinstance(result, dict):
# special parsing allowing lists without enclosing `{}`
try:
result = load_yaml("{" + input + "}")
except YAMLError as e:
raise_from(ConfigValueError,
"failed to parse `{}` as dict".format(input), e)
if not isinstance(result, dict):
raise ConfigValueError(type_error_msg("dict", result))
return result
def process_config_file_yaml(config):
"""Utility for parsing yaml config files.
Handles empty files and makes sure config file is dictionary with
strings as keys.
:raises ConfigValueError: if config is not ``None`` or dictionary
with string keys
"""
if config is None:
# allow empty config file
config = dict()
if not isinstance(config, dict):
raise ConfigValueError(
"Config file cannot be interpreted as dictionary. "
"Parsed as type '{}'.".format(type_name(config)))
for key in config:
if not isinstance(key, text_type):
raise ConfigValueError(
type_error_msg('text', key, what_for="config key"))
return config
def verify(self, value):
if not self.is_unset(value):
if not isinstance(value, bool):
raise ConfigValueError(type_error_msg('bool', value))
return value
def verify(self, value):
if not self.is_unset(value):
if not isinstance(value, text_type):
raise ConfigValueError(type_error_msg('string', value))
return value
