def test_substitute_escaped(self):
self.assertEqual(
r'X and c:\tmp\foo.txt',
variable.substitute('${foo} and ${bar}', {
'foo': 'X',
'bar': r'c:\tmp\foo.txt'
}))
def test_substitute_nested(self):
self.assertEqual(
'X and ZY and Z',
variable.substitute('${foo} and ${bar} and ${kiwi}', {
'foo': 'X',
'bar': '${kiwi}Y',
'kiwi': 'Z'
}))
def test_substitute_word_boundary(self):
self.assertEqual(
'X and Y and Z',
variable.substitute('$foo and $foo_bar and $foo_bar_baz', {
'foo': 'X',
'foo_bar': 'Y',
'foo_bar_baz': 'Z'
}))
def test_substitute_mixed(self):
self.assertEqual(
'X and Y and Z and A',
variable.substitute('$foo and ${bar} and ${baz} and $PIP', {
'foo': 'X',
'bar': 'Y',
'baz': 'Z',
'PIP': 'A'
}))
def resolve_env_vars(clazz, value):
if not check.is_string(value):
return value
variables = variable.find_variables(value)
substitutions = {}
for var in variables:
os_var = os_env_var(var)
if not os_var.is_set:
raise ValueError('not set in the current environment: {}'.format(var))
substitutions[var] = os_var.value
return variable.substitute(value, substitutions)
def test_substitute(self):
self.assertEqual(
'X and Y',
variable.substitute('$foo and $bar', {
'foo': 'X',
'bar': 'Y'
}))
self.assertEqual(
'XY', variable.substitute('$foo$bar', {
'foo': 'X',
'bar': 'Y'
}))
self.assertEqual('X',
variable.substitute('$foo', {
'foo': 'X',
'bar': 'Y'
}))
self.assertEqual('Y',
variable.substitute('$bar', {
'foo': 'X',
'bar': 'Y'
}))
self.assertEqual('$not',
variable.substitute('$not', {
'foo': 'X',
'bar': 'Y'
}))
self.assertEqual(
'', variable.substitute('$foo$bar$foo$bar', {
'foo': '',
'bar': ''
}))
def test_substitute_brackets(self):
self.assertEqual(
'X and Y',
variable.substitute('${foo} and ${bar}', {
'foo': 'X',
'bar': 'Y'
}))
self.assertEqual(
'XY', variable.substitute('${foo}${bar}', {
'foo': 'X',
'bar': 'Y'
}))
self.assertEqual(
'X', variable.substitute('${foo}', {
'foo': 'X',
'bar': 'Y'
}))
self.assertEqual(
'Y', variable.substitute('${bar}', {
'foo': 'X',
'bar': 'Y'
}))
self.assertEqual(
'${not}', variable.substitute('${not}', {
'foo': 'X',
'bar': 'Y'
}))
self.assertEqual(
'',
variable.substitute('${foo}${bar}${foo}${bar}', {
'foo': '',
'bar': ''
}))
def copy_with_substitute(clazz, src, dst, replacements, backup=True):
assert isinstance(replacements, dict)
content = file_util.read(src, 'utf-8')
new_content = variable.substitute(content, replacements)
old_content = None
if path.exists(dst):
old_content = file_util.read(dst, 'utf-8')
if old_content == new_content:
return False
if backup:
file_util.backup(dst)
file_util.save(dst, content=new_content, mode=file_util.mode(src))
return True
def parse_expression(self, expression):
variables = {
'system': self.system,
'arch': self._arch_to_string(self.arch),
'level': self.level,
'distro': self.distro or 'None',
}
dict_util.quote_strings(variables)
exp_with_vars = variable.substitute(expression, variables)
constants = {
'MACOS': 'macos',
'LINUX': 'linux',
'RELEASE': 'release',
'DEBUG': 'debug',
'RASPBIAN': 'raspbian',
}
dict_util.quote_strings(constants)
exp_with_consts = text_replace.replace(exp_with_vars,
constants,
word_boundary=True)
return eval(exp_with_consts)
def test_substitute_single_var_percent(self):
self.assertEqual('X', variable.substitute('%foo%', {'foo': 'X'}))
self.assertEqual('X', variable.substitute('%f%', {'f': 'X'}))
self.assertEqual('%foo%', variable.substitute('%foo%', {}))
def test_substitute_single_var_at_sign(self):
self.assertEqual('X', variable.substitute('@foo@', {'foo': 'X'}))
self.assertEqual('X', variable.substitute('@f@', {'f': 'X'}))
self.assertEqual('@foo@', variable.substitute('@foo@', {}))
def test_substitute_single_var_parentesis(self):
self.assertEqual('X', variable.substitute('$(foo)', {'foo': 'X'}))
self.assertEqual('X', variable.substitute('$(f)', {'f': 'X'}))
self.assertEqual('$(foo)', variable.substitute('$(foo)', {}))
def test_substitute_single_var_bracket(self):
self.assertEqual('X', variable.substitute('${foo}', {'foo': 'X'}))
self.assertEqual('X', variable.substitute('${f}', {'f': 'X'}))
self.assertEqual('${foo}', variable.substitute('${foo}', {}))
def test_invalid_key(self):
with self.assertRaises(TypeError) as context:
variable.substitute('$foo and $bar', {'foo': ['x'], 'bar': 'Y'})
def _resolve_seach_path_part(clazz, part):
substituted_part = variable.substitute(part, dict(os.environ),
variable.BRACKET)
return path.expanduser(substituted_part)
def substitute_variables(self, d, patterns=None):
for i, kv in enumerate(self._values):
self._values[i] = key_value(
kv.key, variable.substitute(kv.value, d, patterns=patterns))
def test_substitute_single_var_dollar_only(self):
self.assertEqual('X', variable.substitute('$foo', {'foo': 'X'}))
self.assertEqual('X', variable.substitute('$f', {'f': 'X'}))
self.assertEqual('$foo', variable.substitute('$foo', {}))
def _resolve_variables(self, value, origin):
variables = variable.find_variables(value)
if variables:
substitutions = self._substitutions_for_value(value, variables, origin)
return variable.substitute(value, substitutions)
return value
def substitute_variables(self, d):
self._values = [variable.substitute(s, d) for s in self._values]
