def settings_defaults(self, settings):
default_settings = self.get_conf("settings_defaults")
values = Values.from_list(default_settings)
settings.values = values
mixed_settings = _mix_settings_with_env(default_settings)
values = Values.from_list(mixed_settings)
settings.values = values
def from_list(data):
result = OptionsValues()
by_package = defaultdict(list)
for k, v in data:
tokens = k.split(":")
if len(tokens) == 2:
package, option = tokens
by_package[package.strip()].append((option, v))
else:
by_package[None].append((k, v))
result._options = Values.from_list(by_package[None])
for k, v in by_package.items():
if k is not None:
result._reqs_options[k] = Values.from_list(v)
return result
def process_settings(self, cache, preprocess=True):
self.processed_settings = cache.settings.copy()
self.processed_settings.values = Values.from_list(
list(self.settings.items()))
if preprocess:
settings_preprocessor.preprocess(self.processed_settings)
# Redefine the profile settings values with the preprocessed ones
# FIXME: Simplify the values.as_list()
self.settings = OrderedDict(
self.processed_settings.values.as_list())
# Preprocess also scoped settings
for pkg, pkg_settings in self.package_settings.items():
pkg_profile = Profile()
pkg_profile.settings = self.settings
pkg_profile.update_settings(pkg_settings)
try:
pkg_profile.process_settings(cache=cache, preprocess=True)
except Exception as e:
pkg_profile = [
"{}={}".format(k, v)
for k, v in pkg_profile.settings.items()
]
raise ConanException(
"Error in resulting settings for package"
" '{}': {}\n{}".format(pkg, e, '\n'.join(pkg_profile)))
def _loader(self,
current_path=None,
user_settings_values=None,
user_options_values=None,
scopes=None):
# The disk settings definition, already including the default disk values
settings = self._paths.settings
options = OptionsValues()
conaninfo_scopes = Scopes()
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
conaninfo_scopes = existing_info.scope
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)
if scopes:
conaninfo_scopes.update_scope(scopes)
self._current_scopes = conaninfo_scopes
return ConanFileLoader(self._runner,
settings,
options=options,
scopes=conaninfo_scopes)
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 load_conanfile(self, conanfile_path, output, processed_profile,
consumer=False, reference=None, local=False):
""" loads a ConanFile object from the given file
"""
conanfile = self.load_basic(conanfile_path, output, reference)
if processed_profile._dev_reference and processed_profile._dev_reference == reference:
conanfile.develop = True
try:
# Prepare the settings for the loaded conanfile
# Mixing the global settings with the specified for that name if exist
tmp_settings = processed_profile._settings.copy()
if processed_profile._package_settings and conanfile.name in processed_profile._package_settings:
# Update the values, keeping old ones (confusing assign)
values_tuple = processed_profile._package_settings[conanfile.name]
tmp_settings.values = Values.from_list(values_tuple)
conanfile.initialize(tmp_settings, processed_profile._env_values, local)
if consumer:
conanfile.develop = True
processed_profile._user_options.descope_options(conanfile.name)
conanfile.options.initialize_upstream(processed_profile._user_options, local=local,
name=conanfile.name)
processed_profile._user_options.clear_unscoped_options()
return conanfile
except Exception as e: # re-raise with file name
raise ConanException("%s: %s" % (conanfile_path, str(e)))
def _loader(self, current_path=None, user_settings_values=None, user_options_values=None,
scopes=None):
# The disk settings definition, already including the default disk values
settings = self._paths.settings
options = OptionsValues()
conaninfo_scopes = Scopes()
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
conaninfo_scopes = existing_info.scope
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)
if scopes:
conaninfo_scopes.update_scope(scopes)
self._current_scopes = conaninfo_scopes
return ConanFileLoader(self._runner, settings, options=options, scopes=conaninfo_scopes)
def process_settings(self, cache, preprocess=True):
self.processed_settings = cache.settings.copy()
self.processed_settings.values = Values.from_list(list(self.settings.items()))
if preprocess:
settings_preprocessor.preprocess(self.processed_settings)
# Redefine the profile settings values with the preprocessed ones
# FIXME: Simplify the values.as_list()
self.settings = OrderedDict(self.processed_settings.values.as_list())
def _initialize_conanfile(conanfile, processed_profile):
# Prepare the settings for the loaded conanfile
# Mixing the global settings with the specified for that name if exist
tmp_settings = processed_profile._settings.copy()
if (processed_profile._package_settings
and conanfile.name in processed_profile._package_settings):
# Update the values, keeping old ones (confusing assign)
values_tuple = processed_profile._package_settings[conanfile.name]
tmp_settings.values = Values.from_list(values_tuple)
conanfile.initialize(tmp_settings, processed_profile._env_values)
def load_conan(self,
conanfile_path,
output,
consumer=False,
reference=None):
""" loads a ConanFile object from the given file
"""
loaded, filename = self._parse_file(conanfile_path)
try:
result = self._parse_module(loaded, consumer, filename)
# Prepare the settings for the loaded conanfile
# Mixing the global settings with the specified for that name if exist
tmp_settings = self._settings.copy()
if self._package_settings and result.name in self._package_settings:
# Update the values, keeping old ones (confusing assign)
values_tuple = self._package_settings[result.name]
tmp_settings.values = Values.from_list(values_tuple)
user, channel = (reference.user,
reference.channel) if reference else (None, None)
# Instance the conanfile
result = result(output, self._runner, tmp_settings,
os.path.dirname(conanfile_path), user, channel)
# Prepare the env variables mixing global env vars with the
# package ones if name match
tmp_env = []
# Copy only the global variables not present in package level vars
for var_name, value in self._env:
if result.name in self._package_env:
if var_name not in self._package_env[result.name]:
tmp_env.append((var_name, value))
else:
tmp_env.append((var_name, value))
tmp_env.extend(self._package_env.get(result.name, []))
result.env = tmp_env
if consumer:
self._user_options.descope_options(result.name)
result.options.initialize_upstream(self._user_options)
# If this is the consumer project, it has no name
result.scope = self._scopes.package_scope()
else:
result.scope = self._scopes.package_scope(result.name)
return result
except Exception as e: # re-raise with file name
raise ConanException("%s: %s" % (conanfile_path, str(e)))
def load_conan(self,
conanfile_path,
output,
consumer=False,
reference=None):
""" loads a ConanFile object from the given file
"""
result = load_conanfile_class(conanfile_path)
try:
# Prepare the settings for the loaded conanfile
# Mixing the global settings with the specified for that name if exist
tmp_settings = self._settings.copy()
if self._package_settings and result.name in self._package_settings:
# Update the values, keeping old ones (confusing assign)
values_tuple = self._package_settings[result.name]
tmp_settings.values = Values.from_list(values_tuple)
if reference:
result.name = reference.name
result.version = reference.version
user, channel = reference.user, reference.channel
else:
user, channel = None, None
# Instance the conanfile
result = result(output, self._runner, tmp_settings,
os.path.dirname(conanfile_path), user, channel)
# Assign environment
result._env_values.update(self._env_values)
if consumer:
self._user_options.descope_options(result.name)
result.options.initialize_upstream(self._user_options)
self._user_options.clear_unscoped_options()
# If this is the consumer project, it has no name
result.scope = self._scopes.package_scope()
else:
result.scope = self._scopes.package_scope(result.name)
result.in_local_cache = True
if consumer or (self.dev_reference
and self.dev_reference == reference):
result.develop = True
return result
except Exception as e: # re-raise with file name
raise ConanException("%s: %s" % (conanfile_path, str(e)))
def _initialize_conanfile(conanfile, profile):
# Prepare the settings for the loaded conanfile
# Mixing the global settings with the specified for that name if exist
tmp_settings = profile.processed_settings.copy()
package_settings_values = profile.package_settings_values
if package_settings_values:
pkg_settings = package_settings_values.get(conanfile.name)
if pkg_settings is None:
# FIXME: This seems broken for packages without user/channel
ref = "%s/%s@%s/%s" % (conanfile.name, conanfile.version,
conanfile._conan_user, conanfile._conan_channel)
for pattern, settings in package_settings_values.items():
if fnmatch.fnmatchcase(ref, pattern):
pkg_settings = settings
break
if pkg_settings:
tmp_settings.values = Values.from_list(pkg_settings)
conanfile.initialize(tmp_settings, profile.env_values)
def simple_test(self):
v = Values()
self.assertEqual(v.compiler, None)
v.compiler = 3
self.assertTrue(v.compiler == "3")
self.assertEqual(v.compiler.version, None)
v.compiler.version = "asfaf"
self.assertEqual(v.compiler.version, "asfaf")
my_list = v.as_list()
self.assertEqual(my_list, [("compiler", "3"), ("compiler.version", "asfaf")])
values = Values.from_list(my_list)
self.assertEqual(values.dumps(), v.dumps())
v.compiler = None
self.assertEqual(v.as_list(), [("compiler", "None")])
self.assertEqual(v.dumps(), "compiler=None")
def simple_test(self):
v = Values()
self.assertEqual(v.compiler, None)
v.compiler = 3
self.assertTrue(v.compiler == "3")
self.assertEqual(v.compiler.version, None)
v.compiler.version = "asfaf"
self.assertEqual(v.compiler.version, "asfaf")
my_list = v.as_list()
self.assertEqual(my_list, [('compiler', '3'),
('compiler.version', 'asfaf')])
values = Values.from_list(my_list)
self.assertEqual(values.dumps(), v.dumps())
v.compiler = None
self.assertEqual(v.as_list(), [('compiler', 'None')])
self.assertEqual(v.dumps(), "compiler=None")
def load_conan(self, conanfile_path, output, consumer=False, reference=None, local=False):
""" loads a ConanFile object from the given file
"""
result = load_conanfile_class(conanfile_path)
try:
# Prepare the settings for the loaded conanfile
# Mixing the global settings with the specified for that name if exist
tmp_settings = self._settings.copy()
if self._package_settings and result.name in self._package_settings:
# Update the values, keeping old ones (confusing assign)
values_tuple = self._package_settings[result.name]
tmp_settings.values = Values.from_list(values_tuple)
if reference:
result.name = reference.name
result.version = reference.version
user, channel = reference.user, reference.channel
else:
user, channel = None, None
# Instance the conanfile
result = result(output, self._runner, tmp_settings, user, channel, local)
# Assign environment
result._env_values.update(self._env_values)
if consumer:
self._user_options.descope_options(result.name)
result.options.initialize_upstream(self._user_options, local=local)
self._user_options.clear_unscoped_options()
else:
result.in_local_cache = True
if consumer or (self.dev_reference and self.dev_reference == reference):
result.develop = True
return result
except Exception as e: # re-raise with file name
raise ConanException("%s: %s" % (conanfile_path, str(e)))
def values(self):
result = OptionsValues()
result._options = Values.from_list(self._options.values_list)
for k, v in self._reqs_options.items():
result._reqs_options[k] = v.copy()
return result
def settings_defaults(self):
default_settings = self.get_conf("settings_defaults")
values = Values.from_list(default_settings)
return values
def generate_default_config_file():
default_settings = detect_defaults_settings(self._output)
default_setting_values = Values.from_list(default_settings)
client_conf = default_client_conf + default_setting_values.dumps()
save(self.conan_conf_path, normalize(client_conf))
def settings_values(self):
return Values.from_list(list(self.settings.items()))
def values(self):
return Values.from_list(self.values_list)
def settings_values(self):
return Values.from_list(list(self.settings.items()))
def values(self):
result = OptionsValues()
result._options = Values.from_list(self._options.values_list)
for k, v in self._reqs_options.items():
result._reqs_options[k] = v.copy()
return result
def settings_defaults(self):
default_settings = self.get_conf("settings_defaults")
default_settings = self._mix_settings_with_env(default_settings)
values = Values.from_list(default_settings)
return values
def settings_defaults(self):
default_settings = self.get_conf("settings_defaults")
values = Values.from_list(default_settings)
return values
def generate_default_config_file():
default_settings = detect_defaults_settings(self._output)
default_setting_values = Values.from_list(default_settings)
client_conf = default_client_conf + default_setting_values.dumps()
save(self.conan_conf_path, client_conf)
def values(self):
return Values.from_list(self.values_list)
