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 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_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 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)