def _propagate_info(self, node, using_build_profile):
# it is necessary to recompute
# the node transitive information necessary to compute the package_id
# as it will be used by reevaluate_node() when package_revision_mode is used and
# PACKAGE_ID_UNKNOWN happens due to unknown revisions
self._binaries_analyzer.package_id_transitive_reqs(node)
# Get deps_cpp_info from upstream nodes
node_order = [
n for n in node.public_closure if n.binary != BINARY_SKIP
]
# List sort is stable, will keep the original order of the closure, but prioritize levels
conan_file = node.conanfile
# FIXME: Not the best place to assign the _conan_using_build_profile
conan_file._conan_using_build_profile = using_build_profile
transitive = [it for it in node.transitive_closure.values()]
br_host = []
for it in node.dependencies:
if it.require.build_require_context == CONTEXT_HOST:
br_host.extend(it.dst.transitive_closure.values())
# Initialize some members if we are using different contexts
if using_build_profile:
conan_file.user_info_build = DepsUserInfo()
for n in node_order:
if n not in transitive:
conan_file.output.info("Applying build-requirement: %s" %
str(n.ref))
dep_cpp_info = n.conanfile._conan_dep_cpp_info
if not using_build_profile: # Do not touch anything
conan_file.deps_user_info[n.ref.name] = n.conanfile.user_info
conan_file.deps_cpp_info.add(n.ref.name, dep_cpp_info)
conan_file.deps_env_info.update(n.conanfile.env_info,
n.ref.name)
else:
if n in transitive or n in br_host:
conan_file.deps_user_info[
n.ref.name] = n.conanfile.user_info
conan_file.deps_cpp_info.add(n.ref.name, dep_cpp_info)
else:
conan_file.user_info_build[
n.ref.name] = n.conanfile.user_info
env_info = EnvInfo()
env_info._values_ = n.conanfile.env_info._values_.copy()
# Add cpp_info.bin_paths/lib_paths to env_info (it is needed for runtime)
env_info.DYLD_LIBRARY_PATH.extend(dep_cpp_info.lib_paths)
env_info.DYLD_FRAMEWORK_PATH.extend(
dep_cpp_info.framework_paths)
env_info.LD_LIBRARY_PATH.extend(dep_cpp_info.lib_paths)
env_info.PATH.extend(dep_cpp_info.bin_paths)
conan_file.deps_env_info.update(env_info, n.ref.name)
# Update the info but filtering the package values that not apply to the subtree
# of this current node and its dependencies.
subtree_libnames = [node.ref.name for node in node_order]
add_env_conaninfo(conan_file, subtree_libnames)
def configs_test(self):
deps_cpp_info = DepsCppInfo()
deps_cpp_info.includedirs.append("C:/whatever")
deps_cpp_info.debug.includedirs.append("C:/whenever")
deps_cpp_info.libs.extend(["math"])
deps_cpp_info.debug.libs.extend(["debug_Lib"])
child = DepsCppInfo()
child.includedirs.append("F:/ChildrenPath")
child.debug.includedirs.append("F:/ChildrenDebugPath")
child.cppflags.append("cxxmyflag")
child.debug.cppflags.append("cxxmydebugflag")
deps_cpp_info._dependencies["Boost"] = child
deps_env_info = DepsEnvInfo()
env_info_lib1 = EnvInfo()
env_info_lib1.var = "32"
env_info_lib1.othervar.append("somevalue")
deps_env_info.update(env_info_lib1, "LIB1")
deps_user_info = DepsUserInfo()
deps_user_info["LIB2"].myuservar = "23"
fakeconan = namedtuple("Conanfile", "deps_cpp_info cpp_info deps_env_info env_info user_info deps_user_info")
output = TXTGenerator(fakeconan(deps_cpp_info, None, deps_env_info, deps_user_info, {}, defaultdict(dict))).content
deps_cpp_info2, _, deps_env_info2 = TXTGenerator.loads(output)
self.assertEqual(deps_cpp_info.includedirs, deps_cpp_info2.includedirs)
self.assertEqual(deps_cpp_info.libdirs, deps_cpp_info2.libdirs)
self.assertEqual(deps_cpp_info.bindirs, deps_cpp_info2.bindirs)
self.assertEqual(deps_cpp_info.libs, deps_cpp_info2.libs)
self.assertEqual(len(deps_cpp_info._dependencies),
len(deps_cpp_info2._dependencies))
self.assertEqual(deps_cpp_info["Boost"].includedirs,
deps_cpp_info2["Boost"].includedirs)
self.assertEqual(deps_cpp_info["Boost"].cppflags,
deps_cpp_info2["Boost"].cppflags)
self.assertEqual(deps_cpp_info["Boost"].cppflags, ["cxxmyflag"])
self.assertEqual(deps_cpp_info.debug.includedirs, deps_cpp_info2.debug.includedirs)
self.assertEqual(deps_cpp_info.debug.includedirs, ["C:/whenever"])
self.assertEqual(deps_cpp_info.debug.libs, deps_cpp_info2.debug.libs)
self.assertEqual(deps_cpp_info.debug.libs, ["debug_Lib"])
self.assertEqual(deps_cpp_info["Boost"].debug.includedirs,
deps_cpp_info2["Boost"].debug.includedirs)
self.assertEqual(deps_cpp_info["Boost"].debug.includedirs,
["F:/ChildrenDebugPath"])
self.assertEqual(deps_cpp_info["Boost"].debug.cppflags,
deps_cpp_info2["Boost"].debug.cppflags)
self.assertEqual(deps_cpp_info["Boost"].debug.cppflags, ["cxxmydebugflag"])
self.assertEqual(deps_env_info["LIB1"].var, "32")
self.assertEqual(deps_env_info["LIB1"].othervar, ["somevalue"])
self.assertEqual(deps_user_info["LIB2"].myuservar, "23")
def configs_test(self):
deps_cpp_info = DepsCppInfo()
deps_cpp_info.filter_empty = False
child = CppInfo("Boost", "F:/")
child.filter_empty = False
child.version = "<version>"
child.includedirs.append("ChildrenPath")
child.debug.includedirs.append("ChildrenDebugPath")
child.cxxflags.append("cxxmyflag")
child.debug.cxxflags.append("cxxmydebugflag")
child.libs.extend(["math"])
child.debug.libs.extend(["debug_Lib"])
deps_cpp_info.add("Boost", DepCppInfo(child))
deps_env_info = DepsEnvInfo()
env_info_lib1 = EnvInfo()
env_info_lib1.var = "32"
env_info_lib1.othervar.append("somevalue")
deps_env_info.update(env_info_lib1, "LIB1")
deps_user_info = DepsUserInfo()
deps_user_info["LIB2"].myuservar = "23"
fakeconan = namedtuple("Conanfile", "deps_cpp_info cpp_info deps_env_info env_info user_info deps_user_info")
output = TXTGenerator(fakeconan(deps_cpp_info, None, deps_env_info, deps_user_info, {}, defaultdict(dict))).content
deps_cpp_info2, _, deps_env_info2, _ = TXTGenerator.loads(output, filter_empty=False)
self.assertEqual(deps_cpp_info.includedirs, deps_cpp_info2.includedirs)
self.assertEqual(deps_cpp_info.libdirs, deps_cpp_info2.libdirs)
self.assertEqual(deps_cpp_info.bindirs, deps_cpp_info2.bindirs)
self.assertEqual(deps_cpp_info.libs, deps_cpp_info2.libs)
self.assertEqual(len(deps_cpp_info._dependencies),
len(deps_cpp_info2._dependencies))
self.assertEqual(deps_cpp_info["Boost"].includedirs,
deps_cpp_info2["Boost"].includedirs)
self.assertEqual(deps_cpp_info["Boost"].cxxflags,
deps_cpp_info2["Boost"].cxxflags)
self.assertEqual(deps_cpp_info["Boost"].cxxflags, ["cxxmyflag"])
self.assertEqual(deps_cpp_info.debug.includedirs, deps_cpp_info2.debug.includedirs)
self.assertEqual(deps_cpp_info.debug.includedirs, ['F:/include', 'F:/ChildrenDebugPath'])
self.assertEqual(deps_cpp_info.debug.libs, deps_cpp_info2.debug.libs)
self.assertEqual(deps_cpp_info.debug.libs, ["debug_Lib"])
self.assertEqual(deps_cpp_info["Boost"].debug.includedirs,
deps_cpp_info2["Boost"].debug.includedirs)
self.assertEqual(deps_cpp_info["Boost"].debug.includedirs, ['include', 'ChildrenDebugPath'])
self.assertEqual(deps_cpp_info["Boost"].debug.cxxflags,
deps_cpp_info2["Boost"].debug.cxxflags)
self.assertEqual(deps_cpp_info["Boost"].debug.cxxflags, ["cxxmydebugflag"])
self.assertEqual(deps_env_info["LIB1"].var, "32")
self.assertEqual(deps_env_info["LIB1"].othervar, ["somevalue"])
self.assertEqual(deps_user_info["LIB2"].myuservar, "23")
def _init_package_info(deps_graph, paths, current_path):
for node in deps_graph.nodes:
conan_ref, conan_file = node
if conan_ref:
package_id = conan_file.info.package_id()
package_reference = PackageReference(conan_ref, package_id)
package_folder = paths.package(package_reference,
conan_file.short_paths)
conan_file.package_folder = package_folder
conan_file.cpp_info = CppInfo(package_folder)
conan_file.env_info = EnvInfo(package_folder)
else:
conan_file.cpp_info = CppInfo(current_path)
conan_file.env_info = EnvInfo(current_path)
def _propagate_info(node, using_build_profile):
# Get deps_cpp_info from upstream nodes
node_order = [
n for n in node.public_closure if n.binary != BINARY_SKIP
]
# List sort is stable, will keep the original order of the closure, but prioritize levels
conan_file = node.conanfile
conan_file._conan_using_build_profile = using_build_profile # FIXME: Not the best place to assign it
transitive = [it for it in node.transitive_closure.values()]
br_host = []
for it in node.dependencies:
if it.require.build_require_context == CONTEXT_HOST:
br_host.extend(it.dst.transitive_closure.values())
for n in node_order:
if n not in transitive:
conan_file.output.info("Applying build-requirement: %s" %
str(n.ref))
if not using_build_profile: # Do not touch anything
conan_file.deps_user_info[n.ref.name] = n.conanfile.user_info
conan_file.deps_cpp_info.update(
n.conanfile._conan_dep_cpp_info, n.ref.name)
conan_file.deps_env_info.update(n.conanfile.env_info,
n.ref.name)
else:
if n in transitive or n in br_host:
conan_file.deps_cpp_info.update(
n.conanfile._conan_dep_cpp_info, n.ref.name)
else:
env_info = EnvInfo()
env_info._values_ = n.conanfile.env_info._values_.copy()
# Add cpp_info.bin_paths/lib_paths to env_info (it is needed for runtime)
env_info.DYLD_LIBRARY_PATH.extend(
n.conanfile._conan_dep_cpp_info.lib_paths)
env_info.DYLD_LIBRARY_PATH.extend(
n.conanfile._conan_dep_cpp_info.framework_paths)
env_info.LD_LIBRARY_PATH.extend(
n.conanfile._conan_dep_cpp_info.lib_paths)
env_info.PATH.extend(
n.conanfile._conan_dep_cpp_info.bin_paths)
conan_file.deps_env_info.update(env_info, n.ref.name)
# Update the info but filtering the package values that not apply to the subtree
# of this current node and its dependencies.
subtree_libnames = [node.ref.name for node in node_order]
add_env_conaninfo(conan_file, subtree_libnames)
def _get_graph(self, reference, current_path, remote, options, settings,
filename, update, check_updates, manifest_manager, scopes,
package_settings, env, package_env):
loader = self._loader(current_path, settings, package_settings,
options, scopes, env, package_env)
# Not check for updates for info command, it'll be checked when dep graph is built
remote_proxy = ConanProxy(self._client_cache,
self._user_io,
self._remote_manager,
remote,
update=update,
check_updates=check_updates,
manifest_manager=manifest_manager)
if isinstance(reference, ConanFileReference):
project_reference = None
conanfile = loader.load_virtual(reference, current_path)
is_txt = True
else:
conanfile_path = reference
project_reference = "PROJECT"
output = ScopedOutput(project_reference, self._user_io.out)
try:
if filename and filename.endswith(".txt"):
raise NotFoundException("")
conan_file_path = os.path.join(conanfile_path, filename
or CONANFILE)
conanfile = loader.load_conan(conan_file_path,
output,
consumer=True)
is_txt = False
if conanfile.name is not None and conanfile.version is not None:
project_reference = "%s/%s@" % (conanfile.name,
conanfile.version)
project_reference += "PROJECT"
except NotFoundException: # Load requirements.txt
conan_path = os.path.join(conanfile_path, filename
or CONANFILE_TXT)
conanfile = loader.load_conan_txt(conan_path, output)
is_txt = True
# build deps graph and install it
local_search = None if update else self._search_manager
resolver = RequireResolver(self._user_io.out, local_search,
remote_proxy)
builder = DepsGraphBuilder(remote_proxy, self._user_io.out, loader,
resolver)
deps_graph = builder.load(None, conanfile)
# These lines are so the conaninfo stores the correct complete info
if is_txt:
conanfile.info.settings = loader._settings.values
conanfile.info.full_settings = loader._settings.values
conanfile.info.scope = self._current_scopes
conanfile.cpp_info = CppInfo(current_path)
conanfile.env_info = EnvInfo(current_path)
registry = RemoteRegistry(self._client_cache.registry,
self._user_io.out)
return (builder, deps_graph, project_reference, registry, conanfile,
remote_proxy, loader)
def _get_conanfile(settings, frameworks=False, system_libs=False):
conan_file = ConanFileMock()
conan_file.settings = settings
conan_file.source_folder = "my_cache_source_folder"
conan_file.build_folder = "my_cache_build_folder"
conan_file.deps_env_info = DepsEnvInfo()
conan_file.deps_user_info = DepsUserInfo()
conan_file.deps_cpp_info = DepsCppInfo()
cpp_info = CppInfo("/root")
cpp_info.include_paths.append("path/to/include1")
cpp_info.lib_paths.append("path/to/lib1")
cpp_info.libs.append("mylib")
cpp_info.bindirs = "path/to/bin1"
cpp_info.cflags.append("c_flag1")
cpp_info.cxxflags.append("cxx_flag1")
cpp_info.defines.append("mydefine1")
if system_libs:
cpp_info.system_libs.append("system_lib1")
if frameworks:
cpp_info.frameworks = ["AVFoundation", "VideoToolbox"]
cpp_info.framework_paths.extend(['path/to/Frameworks1', 'path/to/Frameworks2'])
conan_file.deps_cpp_info.update(cpp_info, "zlib")
conan_file.env_info = EnvInfo()
return conan_file
def _call_package_info(conanfile, package_folder):
conanfile.cpp_info = CppInfo(package_folder)
conanfile.cpp_info.version = conanfile.version
conanfile.cpp_info.description = conanfile.description
conanfile.env_info = EnvInfo()
conanfile.user_info = UserInfo()
# Get deps_cpp_info from upstream nodes
public_deps = [
name for name, req in conanfile.requires.items() if not req.private
]
conanfile.cpp_info.public_deps = public_deps
# Once the node is build, execute package info, so it has access to the
# package folder and artifacts
with pythonpath(
conanfile
): # Minimal pythonpath, not the whole context, make it 50% slower
with tools.chdir(package_folder):
with conanfile_exception_formatter(str(conanfile),
"package_info"):
conanfile.package_folder = package_folder
conanfile.source_folder = None
conanfile.build_folder = None
conanfile.install_folder = None
conanfile.package_info()
def _call_package_info(self, conanfile, package_folder, ref):
conanfile.cpp_info = CppInfo(conanfile.name, package_folder)
conanfile.cpp_info.version = conanfile.version
conanfile.cpp_info.description = conanfile.description
conanfile.env_info = EnvInfo()
conanfile.user_info = UserInfo()
# Get deps_cpp_info from upstream nodes
public_deps = [name for name, req in conanfile.requires.items() if not req.private
and not req.override]
conanfile.cpp_info.public_deps = public_deps
# Once the node is build, execute package info, so it has access to the
# package folder and artifacts
conan_v2 = get_env(CONAN_V2_MODE_ENVVAR, False)
with pythonpath(conanfile) if not conan_v2 else no_op(): # Minimal pythonpath, not the whole context, make it 50% slower
with tools.chdir(package_folder):
with conanfile_exception_formatter(str(conanfile), "package_info"):
conanfile.package_folder = package_folder
conanfile.source_folder = None
conanfile.build_folder = None
conanfile.install_folder = None
self._hook_manager.execute("pre_package_info", conanfile=conanfile,
reference=ref)
conanfile.package_info()
if conanfile._conan_dep_cpp_info is None:
try:
conanfile.cpp_info._raise_incorrect_components_definition(
conanfile.name, conanfile.requires)
except ConanException as e:
raise ConanException("%s package_info(): %s" % (str(conanfile), e))
conanfile._conan_dep_cpp_info = DepCppInfo(conanfile.cpp_info)
self._hook_manager.execute("post_package_info", conanfile=conanfile,
reference=ref)
def __init__(self, shared=None, options=None, options_values=None):
options = options or ""
self.command = None
self.path = None
self.source_folder = self.build_folder = "."
self.settings = None
self.options = Options(PackageOptions.loads(options))
if options_values:
for var, value in options_values.items():
self.options._data[var] = value
self.deps_cpp_info = MockDepsCppInfo(
) # ("deps_cpp_info", "sysroot")("/path/to/sysroot")
self.deps_cpp_info.sysroot = "/path/to/sysroot"
self.output = TestBufferConanOutput()
self.in_local_cache = False
self.install_folder = "myinstallfolder"
if shared is not None:
self.options = namedtuple("options", "shared")(shared)
self.should_configure = True
self.should_build = True
self.should_install = True
self.should_test = True
self.generators = []
self.captured_env = {}
self.deps_env_info = DepsEnvInfo()
self.env_info = EnvInfo()
self.deps_user_info = DepsUserInfo()
self._conan_env_values = EnvValues()
def test_env_info(self):
conanfile = ConanFile(Mock(), None)
conanfile.initialize(Settings({}), EnvValues())
env_info = EnvInfo()
env_info.VAR1 = "value1"
env_info.PATH.append("path-extended")
conanfile.deps_env_info.update(env_info, "my_pkg")
env_info = EnvInfo()
env_info.VAR1 = "other-value1"
env_info.PATH.append("other-path-extended")
conanfile.deps_env_info.update(env_info, "other-pkg")
generator = TXTGenerator(conanfile)
txt_out = generator.content
self.assertIn(
textwrap.dedent("""
[ENV_my_pkg]
PATH=["path-extended"]
VAR1=value1
[ENV_other-pkg]
PATH=["other-path-extended"]
VAR1=other-value1"""), txt_out)
def init_package_info(deps_graph, paths):
""" Made external so it is independent of installer and can called
in testing too
"""
# Assign export root folders
for node in deps_graph.nodes:
conan_ref, conan_file = node
if conan_ref:
package_id = conan_file.info.package_id()
package_reference = PackageReference(conan_ref, package_id)
package_folder = paths.package(package_reference, conan_file.short_paths)
conan_file.package_folder = package_folder
conan_file.cpp_info = CppInfo(package_folder)
conan_file.env_info = EnvInfo(package_folder)
def write_generators(conanfile, path, output):
""" produces auxiliary files, required to build a project or a package.
"""
from conans.model.build_info import CppInfo
conanfile.cpp_info = CppInfo(path)
conanfile.cpp_info.dependencies = []
conanfile.env_info = EnvInfo(path)
conanfile.package_info()
for generator_name in conanfile.generators:
if generator_name not in registered_generators:
output.warn(
"Invalid generator '%s'. Available types: %s" %
(generator_name, ", ".join(registered_generators.available)))
else:
generator_class = registered_generators[generator_name]
try:
generator = generator_class(conanfile)
except TypeError:
# To allow old-style generator packages to work (e.g. premake)
output.warn(
"Generator %s failed with new __init__(), trying old one")
generator = generator_class(conanfile.deps_cpp_info,
conanfile.cpp_info)
try:
content = generator.content
if isinstance(content, dict):
if generator.filename:
output.warn(
"Generator %s is multifile. Property 'filename' not used"
% (generator_name, ))
for k, v in content.items():
v = normalize(v)
output.info("Generated %s created %s" %
(generator_name, k))
save(join(path, k), v)
else:
content = normalize(content)
output.info("Generated %s created %s" %
(generator_name, generator.filename))
save(join(path, generator.filename), content)
except Exception as e:
output.error("Generator %s(file:%s) failed\n%s" %
(generator_name, generator.filename, str(e)))
def _init_package_info(deps_graph, paths):
for node in deps_graph.nodes:
conan_ref, conan_file = node
if conan_ref:
package_id = conan_file.info.package_id()
package_reference = PackageReference(conan_ref, package_id)
package_folder = paths.package(package_reference,
conan_file.short_paths)
conan_file.package_folder = package_folder
conan_file.cpp_info = CppInfo(package_folder)
else:
conan_file.cpp_info = CppInfo("")
conan_file.cpp_info.version = conan_file.version
conan_file.cpp_info.description = conan_file.description
conan_file.env_info = EnvInfo()
conan_file.user_info = UserInfo()
def test_update_concat(self):
env_info = EnvInfo()
env_info.path.append("SOME/PATH")
deps_info = DepsEnvInfo()
deps_info.update(env_info, "lib")
deps_info2 = DepsEnvInfo()
deps_info2.update(env_info, "lib2")
env = EnvValues()
env.add("PATH", ["MYPATH"])
env.update(deps_info)
self.assertEqual(env.env_dicts(None), ({}, {'PATH': ['MYPATH', 'SOME/PATH']}))
env.update(deps_info2)
self.assertEqual(env.env_dicts(None), ({}, {'PATH': ['MYPATH', 'SOME/PATH', 'SOME/PATH']}))
def init_info_objects(deps_graph, paths):
""" Made external so it is independent of installer and can called
in testing too
"""
# Assign export root folders
for node in deps_graph.nodes:
conan_ref, conan_file = node
if conan_ref:
package_id = conan_file.info.package_id()
package_reference = PackageReference(conan_ref, package_id)
package_folder = paths.package(package_reference)
conan_file.package_folder = package_folder
conan_file.cpp_info = CppInfo(package_folder)
conan_file.env_info = EnvInfo(package_folder)
try:
conan_file.package_info()
except Exception as e:
raise ConanException("Error in %s\n\tpackage_info()\n\t%s" %
(conan_ref, str(e)))
def _get_conanfile(self, settings):
conan_file = ConanFileMock()
conan_file.settings = settings
conan_file.source_folder = "my_cache_source_folder"
conan_file.build_folder = "my_cache_build_folder"
conan_file.deps_env_info = DepsEnvInfo()
conan_file.deps_user_info = DepsUserInfo()
conan_file.deps_cpp_info = DepsCppInfo()
cpp_info = CppInfo("/root")
cpp_info.include_paths.append("path/to/include1")
cpp_info.lib_paths.append("path/to/lib1")
cpp_info.libs.append("mylib")
cpp_info.bindirs = "path/to/bin1"
cpp_info.cflags.append("c_flag1")
cpp_info.cppflags.append("cxx_flag1")
cpp_info.defines.append("mydefine1")
conan_file.deps_cpp_info.update(cpp_info, "zlib")
conan_file.env_info = EnvInfo()
return conan_file
def _call_package_info(self, conanfile, package_folder, ref):
conanfile.cpp_info = CppInfo(conanfile.name, package_folder)
conanfile.cpp_info.version = conanfile.version
conanfile.cpp_info.description = conanfile.description
conanfile.env_info = EnvInfo()
conanfile.user_info = UserInfo()
# Get deps_cpp_info from upstream nodes
public_deps = [
name for name, req in conanfile.requires.items()
if not req.private and not req.override
]
conanfile.cpp_info.public_deps = public_deps
# Once the node is build, execute package info, so it has access to the
# package folder and artifacts
# Minimal pythonpath, not the whole context, make it 50% slower
# FIXME Conan 2.0, Remove old ways of reusing python code
with pythonpath(conanfile):
with tools.chdir(package_folder):
with conanfile_exception_formatter(str(conanfile),
"package_info"):
conanfile.layout.set_base_package_folder(package_folder)
conanfile.layout.set_base_source_folder(None)
conanfile.layout.set_base_build_folder(None)
conanfile.layout.set_base_install_folder(None)
self._hook_manager.execute("pre_package_info",
conanfile=conanfile,
reference=ref)
conanfile.package_info()
if conanfile._conan_dep_cpp_info is None:
try:
conanfile.cpp_info._raise_incorrect_components_definition(
conanfile.name, conanfile.requires)
except ConanException as e:
raise ConanException("%s package_info(): %s" %
(str(conanfile), e))
conanfile._conan_dep_cpp_info = DepCppInfo(
conanfile.cpp_info)
self._hook_manager.execute("post_package_info",
conanfile=conanfile,
reference=ref)
def visual_studio_extensions_test(self):
settings = Settings.loads(get_default_settings_yml())
settings.os = "Windows"
settings.compiler = "Visual Studio"
settings.compiler.version = "15"
settings.arch = "x86"
settings.build_type = "Release"
conan_file = ConanFileMock()
conan_file.settings = settings
conan_file.deps_env_info = DepsEnvInfo()
conan_file.deps_user_info = DepsUserInfo()
conan_file.deps_cpp_info = DepsCppInfo()
cpp_info = CppInfo("/root")
cpp_info.libs.append("mylib")
cpp_info.libs.append("other.lib")
conan_file.deps_cpp_info.update(cpp_info, "zlib")
conan_file.env_info = EnvInfo()
gen = CompilerArgsGenerator(conan_file)
self.assertEqual('-O2 -Ob2 -DNDEBUG -link mylib.lib other.lib', gen.content)
def __init__(self, shared=None, options=None, options_values=None):
options = options or ""
self.command = None
self.path = None
self.settings = None
self.options = Options(PackageOptions.loads(options))
if options_values:
for var, value in options_values.items():
self.options._data[var] = value
self.deps_cpp_info = MockDepsCppInfo(
) # ("deps_cpp_info", "sysroot")("/path/to/sysroot")
self.deps_cpp_info.sysroot = "/path/to/sysroot"
self.output = TestBufferConanOutput()
self.in_local_cache = False
if shared is not None:
self.options = namedtuple("options", "shared")(shared)
self.should_configure = True
self.should_build = True
self.should_install = True
self.should_test = True
self.generators = []
self.captured_env = {}
self.deps_env_info = DepsEnvInfo()
self.env_info = EnvInfo()
self.deps_user_info = DepsUserInfo()
self._conan_env_values = EnvValues()
self.folders = Folders()
self.folders.set_base_source(".")
self.folders.set_base_export_sources(".")
self.folders.set_base_build(".")
self.folders.set_base_install("myinstallfolder")
self.folders.set_base_generators(".")
self._conan_user = None
self._conan_channel = None
self.env_scripts = {}
self.win_bash = None
self.conf = ConfDefinition().get_conanfile_conf(None)
self.cpp = Infos()
def test_update_concat(self):
env_info = EnvInfo()
env_info.path.append("SOME/PATH")
deps_info = DepsEnvInfo()
deps_info.update(env_info,
ConanFileReference.loads("lib/1.0@lasote/stable"))
deps_info2 = DepsEnvInfo()
deps_info2.update(env_info,
ConanFileReference.loads("lib2/1.0@lasote/stable"))
env = EnvValues()
env.add("PATH", ["MYPATH"])
env.update(deps_info)
self.assertEquals(env.env_dicts(None), ({}, {
'PATH': ['MYPATH', 'SOME/PATH']
}))
env.update(deps_info2)
self.assertEquals(env.env_dicts(None), ({}, {
'PATH': ['MYPATH', 'SOME/PATH', 'SOME/PATH']
}))
def test_idempotent(self):
conanfile = ConanFile(Mock(), None)
conanfile.initialize(Settings({}), EnvValues())
# Add some cpp_info
ref = ConanFileReference.loads("MyPkg/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder1")
cpp_info.names["txt"] = "mypkg1-txt"
cpp_info.version = ref.version
cpp_info.defines = ["MYDEFINE1"]
cpp_info.cxxflags = ["-cxxflag_parent"]
cpp_info.includedirs = ["mypkg1/include"]
cpp_info.filter_empty = False
conanfile.deps_cpp_info.add(ref.name, cpp_info)
ref = ConanFileReference.loads("MyPkg2/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder2")
cpp_info.defines = ["MYDEFINE2"]
cpp_info.cxxflags = ["-cxxflag_dep"]
cpp_info.filter_empty = False
conanfile.deps_cpp_info.add(ref.name, cpp_info)
# Add env_info
env_info = EnvInfo()
env_info.VAR1 = "value1"
env_info.PATH.append("path-extended")
conanfile.deps_env_info.update(env_info, "my_pkg")
env_info = EnvInfo()
env_info.VAR1 = "other-value1"
env_info.PATH.append("other-path-extended")
conanfile.deps_env_info.update(env_info, "other-pkg")
# Add user_info for HOST
user_info = UserInfo()
user_info.VAR1 = "value1"
conanfile.deps_user_info["my_pkg"] = user_info
user_info = UserInfo()
user_info.VAR1 = "other-value1"
conanfile.deps_user_info["other-pkg"] = user_info
# Add user_info for BUILD
conanfile.user_info_build = DepsUserInfo()
user_info = UserInfo()
user_info.VAR1 = "value1"
conanfile.user_info_build["build_pkg"] = user_info
user_info = UserInfo()
user_info.VAR1 = "other-value1"
conanfile.user_info_build["other-build-pkg"] = user_info
master_content = TXTGenerator(conanfile).content
after_cpp_info, after_user_info, after_env_info, after_user_info_build = \
TXTGenerator.loads(master_content, filter_empty=False)
# Assign them to a different conanfile
other_conanfile = ConanFile(Mock(), None)
other_conanfile.initialize(Settings({}), EnvValues())
other_conanfile.deps_cpp_info = after_cpp_info
other_conanfile.deps_env_info = after_env_info
other_conanfile.deps_user_info = after_user_info
other_conanfile.user_info_build = after_user_info_build
after_content = TXTGenerator(other_conanfile).content
self.assertListEqual(master_content.splitlines(),
after_content.splitlines())
def variables_setup_test(self):
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(Settings({}), EnvValues())
# Add some cpp_info for dependencies
ref = ConanFileReference.loads("MyPkg/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder1")
cpp_info.defines = ["MYDEFINE1"]
cpp_info.cflags.append("-Flag1=23")
cpp_info.version = "1.3"
cpp_info.description = "My cool description"
conanfile.deps_cpp_info.add(ref.name, cpp_info)
ref = ConanFileReference.loads("MyPkg2/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder2")
cpp_info.defines = ["MYDEFINE2"]
cpp_info.version = "2.3"
cpp_info.exelinkflags = ["-exelinkflag"]
cpp_info.sharedlinkflags = ["-sharedlinkflag"]
cpp_info.cxxflags = ["-cxxflag"]
cpp_info.public_deps = ["MyPkg"]
conanfile.deps_cpp_info.add(ref.name, cpp_info)
# Add env_info
env_info = EnvInfo()
env_info.VAR1 = "env_info-value1"
env_info.PATH.append("path-extended")
conanfile.deps_env_info.update(env_info, "env_info_pkg")
# Add user_info
user_info = UserInfo()
user_info.VAR1 = "user_info-value1"
conanfile.deps_user_info["user_info_pkg"] = user_info
# Add user_info_build
conanfile.user_info_build = DepsUserInfo()
user_info = UserInfo()
user_info.VAR1 = "user_info_build-value1"
conanfile.user_info_build["user_info_build_pkg"] = user_info
generator = JsonGenerator(conanfile)
json_out = generator.content
parsed = json.loads(json_out)
# Check dependencies
dependencies = parsed["dependencies"]
self.assertEqual(len(dependencies), 2)
my_pkg = dependencies[0]
self.assertEqual(my_pkg["name"], "MyPkg")
self.assertEqual(my_pkg["description"], "My cool description")
self.assertEqual(my_pkg["defines"], ["MYDEFINE1"])
# Check env_info
env_info = parsed["deps_env_info"]
self.assertListEqual(sorted(env_info.keys()), sorted(["VAR1", "PATH"]))
self.assertEqual(env_info["VAR1"], "env_info-value1")
self.assertListEqual(env_info["PATH"], ["path-extended"])
# Check user_info
user_info = parsed["deps_user_info"]
self.assertListEqual(list(user_info.keys()), ["user_info_pkg"])
self.assertListEqual(list(user_info["user_info_pkg"].keys()), ["VAR1"])
self.assertEqual(user_info["user_info_pkg"]["VAR1"],
"user_info-value1")
# Check user_info_build
user_info_build = parsed["user_info_build"]
self.assertListEqual(list(user_info_build.keys()),
["user_info_build_pkg"])
self.assertListEqual(
list(user_info_build["user_info_build_pkg"].keys()), ["VAR1"])
self.assertEqual(user_info_build["user_info_build_pkg"]["VAR1"],
"user_info_build-value1")
def _call_package_info(self, conanfile, package_folder, ref, is_editable):
conanfile.cpp_info = CppInfo(conanfile.name, package_folder)
conanfile.cpp_info.version = conanfile.version
conanfile.cpp_info.description = conanfile.description
conanfile.env_info = EnvInfo()
conanfile.user_info = UserInfo()
# Get deps_cpp_info from upstream nodes
public_deps = [
name for name, req in conanfile.requires.items()
if not req.private and not req.override
]
conanfile.cpp_info.public_deps = public_deps
# Once the node is build, execute package info, so it has access to the
# package folder and artifacts
# Minimal pythonpath, not the whole context, make it 50% slower
# FIXME Conan 2.0, Remove old ways of reusing python code
with pythonpath(conanfile):
with tools.chdir(package_folder):
with conanfile_exception_formatter(str(conanfile),
"package_info"):
self._hook_manager.execute("pre_package_info",
conanfile=conanfile,
reference=ref)
if hasattr(conanfile, "layout"):
# Old cpp info without defaults (the defaults are in the new one)
conanfile.cpp_info = CppInfo(
conanfile.name,
package_folder,
default_values=CppInfoDefaultValues())
if not is_editable:
conanfile.cpp.package.set_relative_base_folder(
conanfile.package_folder)
# Copy the infos.package into the old cppinfo
fill_old_cppinfo(conanfile.cpp.package,
conanfile.cpp_info)
else:
conanfile.cpp_info.filter_empty = False
conanfile.package_info()
if hasattr(conanfile, "layout") and is_editable:
# Adjust the folders of the layout to consolidate the rootfolder of the
# cppinfos inside
# convert directory entries to be relative to the declared folders.build
conanfile.cpp.build.set_relative_base_folder(
conanfile.build_folder)
# convert directory entries to be relative to the declared folders.source
conanfile.cpp.source.set_relative_base_folder(
conanfile.source_folder)
full_editable_cppinfo = NewCppInfo()
full_editable_cppinfo.merge(conanfile.cpp.source)
full_editable_cppinfo.merge(conanfile.cpp.build)
# Paste the editable cpp_info but prioritizing it, only if a
# variable is not declared at build/source, the package will keep the value
fill_old_cppinfo(full_editable_cppinfo,
conanfile.cpp_info)
if conanfile._conan_dep_cpp_info is None:
try:
if not is_editable and not hasattr(
conanfile, "layout"):
# FIXME: The default for the cppinfo from build are not the same
# so this check fails when editable
# FIXME: Remove when new cppinfo model. If using the layout method
# the cppinfo object is filled from self.cpp.package new
# model and we cannot check if the defaults have been modified
# because it doesn't exist in the new model where the defaults
# for the components are always empty
conanfile.cpp_info._raise_incorrect_components_definition(
conanfile.name, conanfile.requires)
except ConanException as e:
raise ConanException("%s package_info(): %s" %
(str(conanfile), e))
conanfile._conan_dep_cpp_info = DepCppInfo(
conanfile.cpp_info)
self._hook_manager.execute("post_package_info",
conanfile=conanfile,
reference=ref)