def test_consistency(self):
def _check_equal(hs1, hs2, hs3, hs4):
opt_values1 = OptionsValues(hs1)
opt_values2 = OptionsValues(hs2)
opt_values3 = OptionsValues(hs3)
opt_values4 = OptionsValues(hs4)
self.assertEqual(opt_values1.dumps(), opt_values2.dumps())
self.assertEqual(opt_values1.dumps(), opt_values3.dumps())
self.assertEqual(opt_values1.dumps(), opt_values4.dumps())
# Check that all possible input options give the same result
_check_equal([('opt', 3)], [('opt', '3'), ], ('opt=3', ), {'opt': 3})
_check_equal([('opt', True)], [('opt', 'True'), ], ('opt=True', ), {'opt': True})
_check_equal([('opt', False)], [('opt', 'False'), ], ('opt=False', ), {'opt': False})
_check_equal([('opt', None)], [('opt', 'None'), ], ('opt=None', ), {'opt': None})
_check_equal([('opt', 0)], [('opt', '0'), ], ('opt=0', ), {'opt': 0})
_check_equal([('opt', '')], [('opt', ''), ], ('opt=', ), {'opt': ''})
# Check for leading and trailing spaces
_check_equal([(' opt ', 3)], [(' opt ', '3'), ], (' opt =3', ), {' opt ': 3})
_check_equal([('opt', ' value ')], [('opt', ' value '), ], ('opt= value ', ),
{'opt': ' value '})
# This is expected behaviour:
self.assertNotEqual(OptionsValues([('opt', ''), ]).dumps(),
OptionsValues(('opt=""', )).dumps())
def test_exceptions_repeated_value(self):
try:
OptionsValues.loads("a=2\na=12\nb=3").dumps()
OptionsValues(("a=2", "b=23", "a=12"))
OptionsValues([('a', 2), ('b', True), ('a', '12')])
except Exception as e:
self.fail("Not expected exception: {}".format(e))
def print_inspect(self, inspect, raw=False):
for k, v in inspect.items():
if k == "default_options":
if not isinstance(v, dict):
conan_v2_behavior(
"Declare 'default_options' as a dictionary")
if isinstance(v, str):
v = OptionsValues.loads(v)
elif isinstance(v, tuple):
v = OptionsValues(v)
elif isinstance(v, list):
v = OptionsValues(tuple(v))
elif isinstance(v, dict):
v = OptionsValues(v)
if raw:
self._out.write(str(v))
else:
if isinstance(v, (dict, OptionsValues)):
self._out.writeln("%s:" % k)
for ok, ov in sorted(v.items()):
self._out.writeln(" %s: %s" % (ok, ov))
else:
self._out.writeln("%s: %s" % (k, str(v)))
def test_package_with_spaces(self):
self.assertEqual(
OptionsValues([
('pck2:opt', 50),
]).dumps(),
OptionsValues([
('pck2 :opt', 50),
]).dumps())
def _check_equal(hs1, hs2, hs3, hs4):
opt_values1 = OptionsValues(hs1)
opt_values2 = OptionsValues(hs2)
opt_values3 = OptionsValues(hs3)
opt_values4 = OptionsValues(hs4)
self.assertEqual(opt_values1.dumps(), opt_values2.dumps())
self.assertEqual(opt_values1.dumps(), opt_values3.dumps())
self.assertEqual(opt_values1.dumps(), opt_values4.dumps())
def test_exceptions_empty_value(self):
emsg = "not enough values to unpack" if six.PY3 and sys.version_info.minor > 4 \
else "need more than 1 value to unpack"
with six.assertRaisesRegex(self, ValueError, emsg):
OptionsValues("a=2\nconfig\nb=3")
with six.assertRaisesRegex(self, ValueError, emsg):
OptionsValues(("a=2", "config"))
with six.assertRaisesRegex(self, ValueError, emsg):
OptionsValues([('a', 2), ('config', ), ])
def print_inspect(self, inspect):
for k, v in inspect.items():
if k == "default_options":
if isinstance(v, str):
v = OptionsValues.loads(v)
elif isinstance(v, tuple):
v = OptionsValues(v)
elif isinstance(v, list):
v = OptionsValues(tuple(v))
if isinstance(v, (dict, OptionsValues)):
self._out.writeln("%s:" % k)
for ok, ov in sorted(v.items()):
self._out.writeln(" %s: %s" % (ok, ov))
else:
self._out.writeln("%s: %s" % (k, str(v)))
def create_profile(folder,
name,
settings=None,
package_settings=None,
env=None,
package_env=None,
options=None):
package_env = package_env or {}
profile = Profile()
profile.settings = settings or {}
if package_settings:
profile.package_settings = package_settings
if options:
profile.options = OptionsValues(options)
for package_name, envs in package_env.items():
for var_name, value in envs:
profile.env_values.add(var_name, value, package_name)
for var_name, value in env or {}:
profile.env_values.add(var_name, value)
save(os.path.join(folder, name), profile.dumps())
def update_profile(self, profile_name, key, value):
first_key, rest_key = self._get_profile_keys(key)
profile, _ = read_profile(profile_name, os.getcwd(),
self._client_cache.profiles_path)
if first_key == "settings":
profile.settings[rest_key] = value
elif first_key == "options":
tmp = OptionsValues([(rest_key, value)])
profile.options.update(tmp)
elif first_key == "env":
profile.env_values.update(
EnvValues.loads("%s=%s" % (rest_key, value)))
elif first_key == "scopes":
profile.update_scopes(
Scopes.from_list(["%s=%s" % (rest_key, value)]))
elif first_key == "build_requires":
raise ConanException(
"Edit the profile manually to change the build_requires")
contents = profile.dumps()
profile_path = get_profile_path(profile_name,
self._client_cache.profiles_path,
os.getcwd())
save(profile_path, contents)
def build_graph(self,
content,
profile_build_requires=None,
ref=None,
create_ref=None,
install=True):
path = temp_folder()
path = os.path.join(path, "conanfile.py")
save(path, str(content))
self.loader.cached_conanfiles = {}
profile = Profile()
if profile_build_requires:
profile.build_requires = profile_build_requires
profile.process_settings(self.cache)
update = check_updates = False
recorder = ActionRecorder()
remotes = Remotes()
build_mode = [] # Means build all
ref = ref or ConanFileReference(None, None, None, None, validate=False)
options = OptionsValues()
graph_info = GraphInfo(profile, options, root_ref=ref)
deps_graph, _ = self.manager.load_graph(path, create_ref, graph_info,
build_mode, check_updates,
update, remotes, recorder)
if install:
self.binary_installer.install(deps_graph, None, False, graph_info)
return deps_graph
def create_profile(folder,
name,
settings=None,
package_settings=None,
env=None,
package_env=None,
options=None,
conf=None):
package_env = package_env or {}
profile = Profile()
profile.settings = settings or {}
if package_settings:
profile.package_settings = package_settings
if options:
profile.options = OptionsValues(options)
if conf:
_conf = "\n".join(conf) if isinstance(conf, list) else conf
profile.conf.loads(_conf)
for package_name, envs in package_env.items():
for var_name, value in envs:
profile.env_values.add(var_name, value, package_name)
for var_name, value in env or {}:
profile.env_values.add(var_name, value)
save(os.path.join(folder, name), profile.dumps())
def _build_graph(self, profile_host, profile_build, install=False):
path = temp_folder()
path = os.path.join(path, "conanfile.txt")
save(path, textwrap.dedent("""
[requires]
app/testing@user/channel
"""))
ref = ConanFileReference(None, None, None, None, validate=False)
options = OptionsValues()
graph_info = GraphInfo(profile_host=profile_host, profile_build=profile_build,
options=options, root_ref=ref)
recorder = ActionRecorder()
app = self._get_app()
deps_graph = app.graph_manager.load_graph(path, create_reference=None, graph_info=graph_info,
build_mode=[], check_updates=False, update=False,
remotes=Remotes(), recorder=recorder)
if install:
build_mode = [] # Means build all
binary_installer = BinaryInstaller(app, recorder)
build_mode = BuildMode(build_mode, app.out)
binary_installer.install(deps_graph, None, build_mode, update=False,
profile_host=profile_host, profile_build=profile_build,
graph_lock=None,
keep_build=False)
return deps_graph
def _loader(self,
current_path=None,
user_settings_values=None,
user_options_values=None):
# The disk settings definition, already including the default disk values
settings = self._paths.settings
options = OptionsValues()
if current_path:
conan_info_path = os.path.join(current_path, CONANINFO)
if os.path.exists(conan_info_path):
existing_info = ConanInfo.load_file(conan_info_path)
settings.values = existing_info.full_settings
options = existing_info.full_options # Take existing options from conaninfo.txt
if user_settings_values:
aux_values = Values.from_list(user_settings_values)
settings.values = aux_values
if user_options_values is not None: # Install will pass an empty list []
# Install OVERWRITES options, existing options in CONANINFO are not taken
# into account, just those from CONANFILE + user command line
options = OptionsValues.from_list(user_options_values)
return ConanFileLoader(self._runner, settings, options=options)
def __init__(self):
# Sections
self.settings = OrderedDict()
self.package_settings = defaultdict(OrderedDict)
self.env_values = EnvValues()
self.scopes = Scopes()
self.options = OptionsValues()
def build_consumer(self,
path,
profile_build_requires=None,
ref=None,
create_ref=None,
install=True):
profile = Profile()
if profile_build_requires:
profile.build_requires = profile_build_requires
profile.process_settings(self.cache)
update = check_updates = False
recorder = ActionRecorder()
remotes = Remotes()
build_mode = [] # Means build all
ref = ref or ConanFileReference(None, None, None, None, validate=False)
options = OptionsValues()
graph_info = GraphInfo(profile, options, root_ref=ref)
app = self._get_app()
deps_graph = app.graph_manager.load_graph(path, create_ref, graph_info,
build_mode, check_updates,
update, remotes, recorder)
if install:
binary_installer = BinaryInstaller(app, recorder)
build_mode = BuildMode(build_mode, app.out)
binary_installer.install(deps_graph, None, build_mode, update,
False, graph_info)
return deps_graph
def _loader(self, current_path=None, user_settings_values=None, package_settings=None,
user_options_values=None, scopes=None, env_values=None, use_conaninfo=True):
# The disk settings definition, already including the default disk values
settings = self._client_cache.settings
conaninfo_scopes = Scopes()
user_options = OptionsValues(user_options_values)
mixed_env_values = EnvValues()
mixed_env_values.update(env_values)
if current_path:
conan_info_path = os.path.join(current_path, CONANINFO)
if use_conaninfo and os.path.exists(conan_info_path):
existing_info = ConanInfo.load_file(conan_info_path)
settings.values = existing_info.full_settings
options = existing_info.full_options # Take existing options from conaninfo.txt
options.update(user_options)
user_options = options
conaninfo_scopes = existing_info.scope
# Update with info (prioritize user input)
mixed_env_values.update(existing_info.env_values)
if user_settings_values:
aux_values = Values.from_list(user_settings_values)
settings.values = aux_values
if scopes:
conaninfo_scopes.update_scope(scopes)
self._current_scopes = conaninfo_scopes
return ConanFileLoader(self._runner, settings, package_settings=package_settings,
options=user_options, scopes=conaninfo_scopes,
env_values=mixed_env_values)
def _profile_parse_args(settings, options, envs, conf):
""" return a Profile object result of parsing raw data
"""
def _get_tuples_list_from_extender_arg(items):
if not items:
return []
# Validate the pairs
for item in items:
chunks = item.split("=", 1)
if len(chunks) != 2:
raise ConanException("Invalid input '%s', use 'name=value'" %
item)
return [(item[0], item[1])
for item in [item.split("=", 1) for item in items]]
def _get_simple_and_package_tuples(items):
"""Parse items like "thing:item=value or item2=value2 and returns a tuple list for
the simple items (name, value) and a dict for the package items
{package: [(item, value)...)], ...}
"""
simple_items = []
package_items = defaultdict(list)
tuples = _get_tuples_list_from_extender_arg(items)
for name, value in tuples:
if ":" in name: # Scoped items
tmp = name.split(":", 1)
ref_name = tmp[0]
name = tmp[1]
package_items[ref_name].append((name, value))
else:
simple_items.append((name, value))
return simple_items, package_items
def _get_env_values(_env, _package_env):
_env_values = EnvValues()
for name, value in _env:
_env_values.add(name, EnvValues.load_value(value))
for package, data in _package_env.items():
for name, value in data:
_env_values.add(name, EnvValues.load_value(value), package)
return _env_values
options = _get_tuples_list_from_extender_arg(options)
env, package_env = _get_simple_and_package_tuples(envs)
env_values = _get_env_values(env, package_env)
settings, package_settings = _get_simple_and_package_tuples(settings)
result = Profile()
result.options = OptionsValues(options)
result.env_values = env_values
result.settings = OrderedDict(settings)
if conf:
result.conf = ConfDefinition()
result.conf.loads("\n".join(conf))
for pkg, values in package_settings.items():
result.package_settings[pkg] = OrderedDict(values)
return result
def __init__(self):
# Sections
self.processed_settings = None
self.settings = OrderedDict()
self.package_settings = defaultdict(OrderedDict)
self.env_values = EnvValues()
self.options = OptionsValues()
self.build_requires = OrderedDict() # ref pattern: list of ref
def __init__(self):
# Sections
self.settings = OrderedDict()
self.package_settings = defaultdict(OrderedDict)
self.env_values = EnvValues()
self.options = OptionsValues()
self.build_requires = OrderedDict(
) # conan_ref Pattern: list of conan_ref
def loads(text):
graph_json = json.loads(text)
profile = graph_json["profile"]
# FIXME: Reading private very ugly
profile, _ = _load_profile(profile, None, None)
try:
options = graph_json["options"]
except KeyError:
options = None
else:
options = OptionsValues(options)
return GraphInfo(profile=profile, options=options)
def __init__(self):
# Input sections, as defined by user profile files and command line
self.settings = OrderedDict()
self.package_settings = defaultdict(OrderedDict)
self.env_values = EnvValues()
self.options = OptionsValues()
self.build_requires = OrderedDict() # ref pattern: list of ref
# Cached processed values
self.processed_settings = None # Settings with values, and smart completion
self._user_options = None
self._package_settings_values = None
self.dev_reference = None # Reference of the package being develop
def create_options(conanfile):
try:
package_options = PackageOptions(getattr(conanfile, "options", None))
options = Options(package_options)
default_options = getattr(conanfile, "default_options", None)
if default_options:
if isinstance(default_options, dict):
default_values = OptionsValues(default_options)
elif isinstance(default_options, (list, tuple)):
conan_v2_error("Declare 'default_options' as a dictionary")
default_values = OptionsValues(default_options)
elif isinstance(default_options, six.string_types):
conan_v2_error("Declare 'default_options' as a dictionary")
default_values = OptionsValues.loads(default_options)
else:
raise ConanException("Please define your default_options as list, "
"multiline string or dictionary")
options.values = default_values
return options
except Exception as e:
raise ConanException("Error while initializing options. %s" % str(e))
def loads(text):
graph_json = json.loads(text)
try:
options = graph_json["options"]
except KeyError:
options = None
else:
options = OptionsValues(options)
root = graph_json.get("root", {"name": None, "version": None, "user": None, "channel": None})
root_ref = ConanFileReference(root["name"], root["version"], root["user"], root["channel"],
validate=False)
return GraphInfo(options=options, root_ref=root_ref)
def cmd_profile_update(profile_name, key, value, cache_profiles_path):
first_key, rest_key = _get_profile_keys(key)
profile, _ = read_profile(profile_name, get_cwd(), cache_profiles_path)
if first_key == "settings":
profile.settings[rest_key] = value
elif first_key == "options":
tmp = OptionsValues([(rest_key, value)])
profile.options.update(tmp)
elif first_key == "env":
profile.env_values.update_replace(rest_key, value)
elif first_key == "build_requires":
raise ConanException("Edit the profile manually to change the build_requires")
contents = profile.dumps()
profile_path = get_profile_path(profile_name, cache_profiles_path, get_cwd())
save(profile_path, contents)
def create_options(conanfile):
try:
package_options = PackageOptions(getattr(conanfile, "options", None))
options = Options(package_options)
default_options = getattr(conanfile, "default_options", None)
if default_options:
if isinstance(default_options, (list, tuple)):
default_values = OptionsValues(default_options)
elif isinstance(default_options, str):
default_values = OptionsValues.loads(default_options)
else:
raise ConanException("Please define your default_options as list or "
"multiline string")
options.values = default_values
return options
except Exception as e:
raise ConanException("Error while initializing options. %s" % str(e))
def loads(text):
graph_json = json.loads(text)
profile = graph_json["profile"]
# FIXME: Reading private very ugly
profile, _ = _load_profile(profile, None, None)
try:
options = graph_json["options"]
except KeyError:
options = None
else:
options = OptionsValues(options)
root = graph_json["root"]
root_ref = ConanFileReference(root["name"],
root["version"],
root["user"],
root["channel"],
validate=False)
return GraphInfo(profile=profile, options=options, root_ref=root_ref)
def test_from_list(self):
option_values = OptionsValues(self.sut.as_list())
self.assertEqual(option_values.dumps(), self.sut.dumps())
def test_from_dict(self):
options_as_dict = dict(
[item.split('=') for item in self.sut.dumps().splitlines()])
option_values = OptionsValues(options_as_dict)
self.assertEqual(option_values.dumps(), self.sut.dumps())
