def help_test(self):
deps_env_info = DepsEnvInfo()
deps_cpp_info = DepsCppInfo()
deps_cpp_info.includedirs.append("C:/whatever")
deps_cpp_info.includedirs.append("C:/whenever")
deps_cpp_info.libdirs.append("C:/other")
deps_cpp_info.libs.extend(["math", "winsock", "boost"])
child = DepsCppInfo()
child.includedirs.append("F:/ChildrenPath")
child.cppflags.append("cxxmyflag")
deps_cpp_info._dependencies["Boost"] = child
fakeconan = namedtuple("Conanfile", "deps_cpp_info cpp_info deps_env_info env_info")
output = TXTGenerator(fakeconan(deps_cpp_info, None, deps_env_info, None)).content
deps_cpp_info2 = DepsCppInfo.loads(output)
self.assertEqual(deps_cpp_info.configs, deps_cpp_info2.configs)
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"])
def test_cpp_info_build_modules(self):
folder = temp_folder()
info = CppInfo("myname", folder)
info.build_modules.append(
"old.cmake") # Test old behavior with .cmake build modules
info.build_modules.extend(["other_old.cmake",
"file.pc"]) # .pc not considered
info.build_modules["generator"].append("my_module.cmake")
info.debug.build_modules["other_gen"] = ["mod-release.cmake"]
deps_cpp_info = DepsCppInfo()
deps_cpp_info.add("myname", DepCppInfo(info))
for gen in [
"cmake", "cmake_multi", "cmake_find_package",
"cmake_find_package_multi"
]:
self.assertListEqual([
os.path.join(folder, "old.cmake"),
os.path.join(folder, "other_old.cmake")
], list(deps_cpp_info["myname"].build_modules_paths[gen]))
self.assertListEqual(
[os.path.join(folder, "my_module.cmake")],
list(deps_cpp_info["myname"].build_modules_paths["generator"]))
self.assertListEqual([
os.path.join(folder, "mod-release.cmake")
], list(
deps_cpp_info["myname"].debug.build_modules_paths["other_gen"]))
def help_test(self):
deps_env_info = DepsEnvInfo()
deps_cpp_info = DepsCppInfo()
child = CppInfo("Boost", "F:")
child.filter_empty = False
child.includedirs.append("ChildrenPath")
child.cxxflags.append("cxxmyflag")
deps_cpp_info.add("Boost", DepCppInfo(child))
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, None, {},
defaultdict(dict))).content
deps_cpp_info2, _, _, _ = TXTGenerator.loads(output)
self.assertEqual(deps_cpp_info.configs, deps_cpp_info2.configs)
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"])
def help_test(self):
deps_env_info = DepsEnvInfo()
deps_cpp_info = DepsCppInfo()
deps_cpp_info.includedirs.append("C:/whatever")
deps_cpp_info.includedirs.append("C:/whenever")
deps_cpp_info.libdirs.append("C:/other")
deps_cpp_info.libs.extend(["math", "winsock", "boost"])
child = DepsCppInfo()
child.includedirs.append("F:/ChildrenPath")
child.cppflags.append("cxxmyflag")
deps_cpp_info._dependencies["Boost"] = child
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, None, {},
defaultdict(dict))).content
deps_cpp_info2, _ = TXTGenerator.loads(output)
self.assertEqual(deps_cpp_info.configs, deps_cpp_info2.configs)
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"])
def cpp_info_name_test(self):
folder = temp_folder()
info = CppInfo(folder)
info.name = "MyName"
deps_cpp_info = DepsCppInfo()
deps_cpp_info.update(info, "myname")
self.assertIn("MyName", deps_cpp_info["myname"].name)
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.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 cpp_info_name_test(self):
folder = temp_folder()
info = CppInfo("myname", folder)
info.name = "MyName"
info.names["my_generator"] = "MyNameForMyGenerator"
deps_cpp_info = DepsCppInfo()
deps_cpp_info.add("myname", DepCppInfo(info))
self.assertIn("MyName", deps_cpp_info["myname"].get_name("my_undefined_generator"))
self.assertIn("MyNameForMyGenerator", deps_cpp_info["myname"].get_name("my_generator"))
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 cpp_info_system_libs_test(self):
info1 = CppInfo("dep1", "folder1")
info1.system_libs = ["sysdep1"]
info2 = CppInfo("dep2", "folder2")
info2.system_libs = ["sysdep2", "sysdep3"]
deps_cpp_info = DepsCppInfo()
deps_cpp_info.add("dep1", DepCppInfo(info1))
deps_cpp_info.add("dep2", DepCppInfo(info2))
self.assertListEqual(["sysdep1", "sysdep2", "sysdep3"], list(deps_cpp_info.system_libs))
self.assertListEqual(["sysdep1"], list(deps_cpp_info["dep1"].system_libs))
self.assertListEqual(["sysdep2", "sysdep3"], list(deps_cpp_info["dep2"].system_libs))
def cpp_info_build_modules_test(self):
folder = temp_folder()
info = CppInfo(folder)
info.build_modules.append("my_module.cmake")
info.debug.build_modules = ["mod-release.cmake"]
deps_cpp_info = DepsCppInfo()
deps_cpp_info.update(info, "myname")
self.assertListEqual([os.path.join(folder, "my_module.cmake")],
deps_cpp_info["myname"].build_modules_paths)
self.assertListEqual([os.path.join(folder, "mod-release.cmake")],
deps_cpp_info["myname"].debug.build_modules_paths)
def cpp_info_system_libs_test(self):
info1 = CppInfo("folder1")
info1.system_libs = ["sysdep1"]
info2 = CppInfo("folder2")
info2.system_libs = ["sysdep2", "sysdep3"]
deps_cpp_info = DepsCppInfo()
deps_cpp_info.update(info1, "dep1")
deps_cpp_info.update(info2, "dep2")
self.assertEqual(["sysdep1", "sysdep2", "sysdep3"], deps_cpp_info.system_libs)
self.assertEqual(["sysdep1"], deps_cpp_info["dep1"].system_libs)
self.assertEqual(["sysdep2", "sysdep3"], deps_cpp_info["dep2"].system_libs)
def test_cpp_info_build_modules(self):
folder = temp_folder()
info = CppInfo("myname", folder)
info.build_modules.append("my_module.cmake")
info.debug.build_modules = ["mod-release.cmake"]
deps_cpp_info = DepsCppInfo()
deps_cpp_info.add("myname", DepCppInfo(info))
self.assertListEqual([os.path.join(folder, "my_module.cmake")],
list(deps_cpp_info["myname"].build_modules_paths))
self.assertListEqual(
[os.path.join(folder, "mod-release.cmake")],
list(deps_cpp_info["myname"].debug.build_modules_paths))
def help_test(self):
imports = DepsCppInfo()
imports.includedirs.append("C:/whatever")
imports.includedirs.append("C:/whenever")
imports.libdirs.append("C:/other")
imports.libs.extend(["math", "winsock", "boost"])
child = DepsCppInfo()
child.includedirs.append("F:/ChildrenPath")
child.cppflags.append("cxxmyflag")
imports._dependencies["Boost"] = child
output = repr(imports)
imports2 = DepsCppInfo.loads(output)
self._equal(imports, imports2)
def help_test(self):
imports = DepsCppInfo()
imports.includedirs.append("C:/whatever")
imports.includedirs.append("C:/whenever")
imports.libdirs.append("C:/other")
imports.libs.extend(["math", "winsock", "boost"])
child = DepsCppInfo()
child.includedirs.append("F:/ChildrenPath")
child.cppflags.append("cxxmyflag")
imports._dependencies["Boost"] = child
output = repr(imports)
imports2 = DepsCppInfo.loads(output)
self._equal(imports, imports2)
def test_deps_cpp_info_components_includedirs(self):
info = CppInfo("my_lib", "root")
info.components["component"].includedirs = ["include1", "include2"]
info.components["component"].filter_empty = False
dep_info = DepCppInfo(info)
expected = [
os.path.join("root", "include1"),
os.path.join("root", "include2")
]
self.assertListEqual(expected, list(dep_info.include_paths))
deps_cpp_info = DepsCppInfo()
deps_cpp_info.add("my_lib", dep_info)
self.assertListEqual(expected, list(deps_cpp_info.includedirs))
def help_test(self):
deps_cpp_info = DepsCppInfo()
deps_cpp_info.includedirs.append("C:/whatever")
deps_cpp_info.includedirs.append("C:/whenever")
deps_cpp_info.libdirs.append("C:/other")
deps_cpp_info.libs.extend(["math", "winsock", "boost"])
child = DepsCppInfo()
child.includedirs.append("F:/ChildrenPath")
child.cppflags.append("cxxmyflag")
deps_cpp_info._dependencies["Boost"] = child
fakeconan = namedtuple("Conanfile", "deps_cpp_info cpp_info")
output = TXTGenerator(fakeconan(deps_cpp_info, None)).content
deps_cpp_info2 = DepsCppInfo.loads(output)
self._equal(deps_cpp_info, deps_cpp_info2)
def deps_cpp_info_components_test(self):
folder = temp_folder()
info = CppInfo(folder)
# Create file so path is not cleared
save(os.path.join(folder, "include", "my_file.h"), "")
info.components["Component"].libs = ["libcomp"]
dep_info = DepCppInfo(info)
deps_cpp_info = DepsCppInfo()
deps_cpp_info.update(dep_info, "my_lib")
self.assertListEqual(["libcomp"], deps_cpp_info.libs)
self.assertListEqual(["libcomp"], deps_cpp_info["my_lib"].components["Component"].libs)
self.assertListEqual([os.path.join(folder, "include")], deps_cpp_info.include_paths)
self.assertListEqual([os.path.join(folder, "include")],
deps_cpp_info["my_lib"].components["Component"].include_paths)
def test_cpp_info_build_modules_old_behavior(self):
folder = temp_folder()
info = CppInfo("myname", folder)
info.build_modules = [
"old.cmake"
] # Test old behavior with .cmake build modules as list
deps_cpp_info = DepsCppInfo()
deps_cpp_info.add("myname", DepCppInfo(info))
for gen in [
"cmake", "cmake_multi", "cmake_find_package",
"cmake_find_package_multi"
]:
assert list(deps_cpp_info["myname"].build_modules_paths[gen]) ==\
[os.path.join(folder, "old.cmake")]
def component_default_dirs_deps_cpp_info_test(self):
folder = temp_folder()
info = CppInfo(folder)
info.components["Component"]
info.components["Component"].filter_empty = False # For testing purposes
dep_info = DepCppInfo(info)
deps_cpp_info = DepsCppInfo()
deps_cpp_info.update(dep_info, "my_lib")
self.assertListEqual([os.path.join(folder, "include")], deps_cpp_info.includedirs)
self.assertListEqual([], deps_cpp_info.srcdirs)
self.assertListEqual([os.path.join(folder, "lib")], deps_cpp_info.libdirs)
self.assertListEqual([os.path.join(folder, "bin")], deps_cpp_info.bindirs)
self.assertListEqual([os.path.join(folder, "")], deps_cpp_info.builddirs)
self.assertListEqual([os.path.join(folder, "res")], deps_cpp_info.resdirs)
self.assertListEqual([os.path.join(folder, "Frameworks")], deps_cpp_info.frameworkdirs)
def initialize(self, settings, env, local=None):
if isinstance(self.generators, str):
self.generators = [self.generators]
# User defined options
self.options = create_options(self)
self.requires = create_requirements(self)
self.settings = create_settings(self, settings, local)
try:
if self.settings.os_build and self.settings.os:
self.output.writeln("*"*60, front=Color.BRIGHT_RED)
self.output.writeln(" This package defines both 'os' and 'os_build' ",
front=Color.BRIGHT_RED)
self.output.writeln(" Please use 'os' for libraries and 'os_build'",
front=Color.BRIGHT_RED)
self.output.writeln(" only for build-requires used for cross-building",
front=Color.BRIGHT_RED)
self.output.writeln("*"*60, front=Color.BRIGHT_RED)
except ConanException:
pass
# needed variables to pack the project
self.cpp_info = None # Will be initialized at processing time
self.deps_cpp_info = DepsCppInfo()
# environment variables declared in the package_info
self.env_info = None # Will be initialized at processing time
self.deps_env_info = DepsEnvInfo()
# user declared variables
self.user_info = None
# Keys are the package names, and the values a dict with the vars
self.deps_user_info = DepsUserInfo()
# user specified env variables
self._conan_env_values = env.copy() # user specified -e
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 initialize(self, settings, env):
if isinstance(self.generators, str):
self.generators = [self.generators]
# User defined options
self.options = create_options(self)
self.requires = create_requirements(self)
self.settings = create_settings(self, settings)
if 'cppstd' in self.settings.fields:
conan_v2_behavior("Setting 'cppstd' is deprecated in favor of 'compiler.cppstd',"
" please update your recipe.", v1_behavior=self.output.warn)
# needed variables to pack the project
self.cpp_info = None # Will be initialized at processing time
self._conan_dep_cpp_info = None # Will be initialized at processing time
self.deps_cpp_info = DepsCppInfo()
# environment variables declared in the package_info
self.env_info = None # Will be initialized at processing time
self.deps_env_info = DepsEnvInfo()
# user declared variables
self.user_info = None
# Keys are the package names (only 'host' if different contexts)
self.deps_user_info = DepsUserInfo()
# user specified env variables
self._conan_env_values = env.copy() # user specified -e
if self.description is not None and not isinstance(self.description, six.string_types):
raise ConanException("Recipe 'description' must be a string.")
def _check_individual_deps(self, client):
self.assertIn("INCLUDE [", client.user_io.out)
self.assertIn(".conan/data/Hello0/0.1/lasote/stable",
client.user_io.out)
build_file = os.path.join(client.current_folder, BUILD_INFO)
content = load(build_file)
cmakebuildinfo = load(
os.path.join(client.current_folder, BUILD_INFO_CMAKE))
self.assertIn(
"set(CONAN_LIBS helloHello3 helloHello1 helloHello2 helloHello0",
cmakebuildinfo)
self.assertIn("set(CONAN_DEPENDENCIES Hello3 Hello1 Hello2 Hello0)",
cmakebuildinfo)
deps_cpp_info = DepsCppInfo.loads(content)
self.assertEqual(len(deps_cpp_info.include_paths), 4)
for dep in ("Hello3", "Hello2", "Hello1", "Hello0"):
self.assertEqual(len(deps_cpp_info[dep].include_paths), 1)
self.assertEqual(len(deps_cpp_info[dep].lib_paths), 1)
self.assertEqual(deps_cpp_info[dep].libs, ["hello%s" % dep])
build_file = os.path.join(client.current_folder, BUILD_INFO_CMAKE)
content = load(build_file)
for dep in ("Hello3", "Hello2", "Hello1", "Hello0"):
self.assertEqual(len(deps_cpp_info[dep].include_paths), 1)
self.assertIn("set(CONAN_INCLUDE_DIRS_%s " % dep.upper(), content)
self.assertIn("set(CONAN_LIBS_%s hello%s)" % (dep.upper(), dep),
content)
def __init__(self, output, runner, settings, conanfile_directory):
'''
param settings: Settings
'''
# User defined generators
self.generators = self.generators if hasattr(self, "generators") else ["txt"]
self.generators = [self.generators] if isinstance(self.generators, str) \
else self.generators
# User defined options
self.options = create_options(self)
self.requires = create_requirements(self)
self.settings = create_settings(self, settings)
self.exports = create_exports(self)
# needed variables to pack the project
self.cpp_info = None # Will be initialized at processing time
self.deps_cpp_info = DepsCppInfo()
self.copy = None # initialized at runtime
# an output stream (writeln, info, warn error)
self.output = output
# something that can run commands, as os.sytem
self._runner = runner
self._conanfile_directory = conanfile_directory
def config_patch_test(self):
conan_file = ConanFileMock()
conan_file.name = "MyPkg"
conan_file.settings = Settings()
conan_file.source_folder = os.path.join(self.tempdir, "src")
conan_file.build_folder = os.path.join(self.tempdir, "build")
conan_file.package_folder = os.path.join(self.tempdir, "pkg")
conan_file.deps_cpp_info = DepsCppInfo()
msg = "FOLDER: " + conan_file.package_folder
for folder in (conan_file.build_folder, conan_file.package_folder):
save(os.path.join(folder, "file1.cmake"), "Nothing")
save(os.path.join(folder, "file2"), msg)
save(os.path.join(folder, "file3.txt"), msg)
save(os.path.join(folder, "file3.cmake"), msg)
save(os.path.join(folder, "sub", "file3.cmake"), msg)
cmake = CMake(conan_file, generator="Unix Makefiles")
cmake.patch_config_paths()
for folder in (conan_file.build_folder, conan_file.package_folder):
self.assertEqual("Nothing", load(os.path.join(folder, "file1.cmake")))
self.assertEqual(msg, load(os.path.join(folder, "file2")))
self.assertEqual(msg, load(os.path.join(folder, "file3.txt")))
self.assertEqual("FOLDER: ${CONAN_MYPKG_ROOT}",
load(os.path.join(folder, "file3.cmake")))
self.assertEqual("FOLDER: ${CONAN_MYPKG_ROOT}",
load(os.path.join(folder, "sub", "file3.cmake")))
def initialize(self, settings, env):
if isinstance(self.generators, str):
self.generators = [self.generators]
# User defined options
self.options = create_options(self)
self.requires = create_requirements(self)
self.settings = create_settings(self, settings)
if 'cppstd' in self.settings.fields:
self.output.warn(
"Setting 'cppstd' is deprecated in favor of 'compiler.cppstd',"
" please update your recipe.")
# needed variables to pack the project
self.cpp_info = None # Will be initialized at processing time
self.deps_cpp_info = DepsCppInfo()
# environment variables declared in the package_info
self.env_info = None # Will be initialized at processing time
self.deps_env_info = DepsEnvInfo()
# user declared variables
self.user_info = None
# Keys are the package names, and the values a dict with the vars
self.deps_user_info = DepsUserInfo()
# user specified env variables
self._conan_env_values = env.copy() # user specified -e
def initialize(self, settings, env, buildenv=None):
self._conan_buildenv = buildenv
if isinstance(self.generators, str):
self.generators = [self.generators]
# User defined options
self.options = create_options(self)
self.requires = create_requirements(self)
self.settings = create_settings(self, settings)
conan_v2_error("Setting 'cppstd' is deprecated in favor of 'compiler.cppstd',"
" please update your recipe.", 'cppstd' in self.settings.fields)
# needed variables to pack the project
self.cpp_info = None # Will be initialized at processing time
self._conan_dep_cpp_info = None # Will be initialized at processing time
self.deps_cpp_info = DepsCppInfo()
# environment variables declared in the package_info
self.env_info = None # Will be initialized at processing time
self.deps_env_info = DepsEnvInfo()
# user declared variables
self.user_info = None
# Keys are the package names (only 'host' if different contexts)
self.deps_user_info = DepsUserInfo()
# user specified env variables
self._conan_env_values = env.copy() # user specified -e
if self.description is not None and not isinstance(self.description, six.string_types):
raise ConanException("Recipe 'description' must be a string.")
if not hasattr(self, "virtualenv"): # Allow the user to override it with True or False
self.virtualenv = True
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
fakeconan = namedtuple(
"Conanfile", "deps_cpp_info cpp_info deps_env_info env_info")
output = TXTGenerator(fakeconan(deps_cpp_info, None, None,
None)).content
deps_cpp_info2 = DepsCppInfo.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"])
def help_test(self):
deps_env_info = DepsEnvInfo()
deps_cpp_info = DepsCppInfo()
deps_cpp_info.includedirs.append("C:/whatever")
deps_cpp_info.includedirs.append("C:/whenever")
deps_cpp_info.libdirs.append("C:/other")
deps_cpp_info.libs.extend(["math", "winsock", "boost"])
child = DepsCppInfo()
child.includedirs.append("F:/ChildrenPath")
child.cppflags.append("cxxmyflag")
deps_cpp_info._dependencies["Boost"] = child
fakeconan = namedtuple(
"Conanfile", "deps_cpp_info cpp_info deps_env_info env_info")
output = TXTGenerator(
fakeconan(deps_cpp_info, None, deps_env_info, None)).content
deps_cpp_info2 = DepsCppInfo.loads(output)
self._equal(deps_cpp_info, deps_cpp_info2)
def variables_setup_test(self):
conanfile = ConanFile(None, None, Settings({}), None)
ref = ConanFileReference.loads("MyPkg/0.1@lasote/stables")
cpp_info = DepsCppInfo()
cpp_info.defines = ["MYDEFINE1"]
conanfile.deps_cpp_info.update(cpp_info, ref)
ref = ConanFileReference.loads("MyPkg2/0.1@lasote/stables")
cpp_info = DepsCppInfo()
cpp_info.defines = ["MYDEFINE2"]
conanfile.deps_cpp_info.update(cpp_info, ref)
generator = CMakeGenerator(conanfile)
content = generator.content
cmake_lines = content.splitlines()
self.assertIn("set(CONAN_DEFINES_MYPKG -DMYDEFINE1)", cmake_lines)
self.assertIn("set(CONAN_DEFINES_MYPKG2 -DMYDEFINE2)", cmake_lines)
self.assertIn("set(CONAN_COMPILE_DEFINITIONS_MYPKG MYDEFINE1)", cmake_lines)
self.assertIn("set(CONAN_COMPILE_DEFINITIONS_MYPKG2 MYDEFINE2)", cmake_lines)
def __init__(self, output, runner, settings, user=None, channel=None, local=None):
# User defined generators
self.generators = self.generators if hasattr(self, "generators") else ["txt"]
if isinstance(self.generators, str):
self.generators = [self.generators]
# User defined options
self.options = create_options(self)
self.requires = create_requirements(self)
self.settings = create_settings(self, settings, local)
try:
if self.settings.os_build and self.settings.os:
output.writeln("*"*60, front=Color.BRIGHT_RED)
output.writeln(" This package defines both 'os' and 'os_build' ",
front=Color.BRIGHT_RED)
output.writeln(" Please use 'os' for libraries and 'os_build'",
front=Color.BRIGHT_RED)
output.writeln(" only for build-requires used for cross-building",
front=Color.BRIGHT_RED)
output.writeln("*"*60, front=Color.BRIGHT_RED)
except ConanException:
pass
self.exports = create_exports(self)
self.exports_sources = create_exports_sources(self)
# needed variables to pack the project
self.cpp_info = None # Will be initialized at processing time
self.deps_cpp_info = DepsCppInfo()
# environment variables declared in the package_info
self.env_info = None # Will be initialized at processing time
self.deps_env_info = DepsEnvInfo()
# user declared variables
self.user_info = None
# Keys are the package names, and the values a dict with the vars
self.deps_user_info = DepsUserInfo()
self.copy = None # initialized at runtime
self.copy_deps = None # initialized at runtime
# an output stream (writeln, info, warn error)
self.output = output
# something that can run commands, as os.sytem
self._runner = runner
self.develop = False
# user specified env variables
self._env_values = EnvValues() # Updated at runtime, user specified -e
self._user = user
self._channel = channel
self.in_local_cache = False
self.description = None
# Vars to control the build steps (build(), package())
self.should_configure = True
self.should_build = True
self.should_install = True
def build(self, conanfile_path, current_path, test=False, filename=None, profile_name=None):
""" Call to build() method saved on the conanfile.py
param conanfile_path: the original source directory of the user containing a
conanfile.py
"""
logger.debug("Building in %s" % current_path)
logger.debug("Conanfile in %s" % conanfile_path)
if filename and filename.endswith(".txt"):
raise ConanException("A conanfile.py is needed to call 'conan build'")
conanfile_file = os.path.join(conanfile_path, filename or CONANFILE)
try:
output = ScopedOutput("Project", self._user_io.out)
conan_file = self._loader(current_path).load_conan(conanfile_file, output,
consumer=True)
except NotFoundException:
# TODO: Auto generate conanfile from requirements file
raise ConanException("'%s' file is needed for build.\n"
"Create a '%s' and move manually the "
"requirements and generators from '%s' file"
% (CONANFILE, CONANFILE, CONANFILE_TXT))
try:
build_info_file = os.path.join(current_path, BUILD_INFO)
if os.path.exists(build_info_file):
try:
deps_cpp_info = DepsCppInfo.loads(load(build_info_file))
conan_file.deps_cpp_info = deps_cpp_info
except:
pass
env_file = os.path.join(current_path, "conanenv.txt")
if os.path.exists(env_file):
try:
deps_env_info = DepsEnvInfo.loads(load(env_file))
conan_file.deps_env_info = deps_env_info
except:
pass
os.chdir(current_path)
conan_file._conanfile_directory = conanfile_path
# Append env_vars to execution environment and clear when block code ends
profile = self._read_profile(profile_name)
env_vars = self._read_profile_env_vars(profile)
with environment_append(env_vars):
conan_file.build()
if test:
conan_file.test()
except ConanException:
raise # Raise but not let to reach the Exception except (not print traceback)
except Exception:
import traceback
trace = traceback.format_exc().split('\n')
raise ConanException("Unable to build it successfully\n%s" % '\n'.join(trace[3:]))
def _loads_cpp_info(text):
pattern = re.compile(r"^\[([a-zA-Z0-9._:-]+)\]([^\[]+)", re.MULTILINE)
try:
# Parse the text
data = defaultdict(lambda: defaultdict(dict))
for m in pattern.finditer(text):
var_name = m.group(1)
lines = []
for line in m.group(2).splitlines():
line = line.strip()
if not line or line[0] == "#":
continue
lines.append(line)
if not lines:
continue
tokens = var_name.split(":")
if len(tokens) == 2: # has config
var_name, config = tokens
else:
config = None
if 'system_libs' in var_name:
tokens = var_name.split("system_libs_", 1)
field = 'system_libs'
else:
tokens = var_name.split("_", 1)
field = tokens[0]
dep = tokens[1] if len(tokens) == 2 else None
if field == "cppflags":
field = "cxxflags"
data[dep][config][field] = lines
# Build the data structures
deps_cpp_info = DepsCppInfo()
for dep, configs_cpp_info in data.items():
if dep is None:
cpp_info = deps_cpp_info
else:
cpp_info = deps_cpp_info._dependencies.setdefault(
dep, CppInfo(root_folder=""))
for config, fields in configs_cpp_info.items():
item_to_apply = cpp_info if not config else getattr(
cpp_info, config)
for key, value in fields.items():
if key in ['rootpath', 'sysroot']:
value = value[0]
setattr(item_to_apply, key, value)
return deps_cpp_info
except Exception as e:
logger.error(traceback.format_exc())
raise ConanException(
"There was an error parsing conanbuildinfo.txt: %s" % str(e))
def test_types(self):
deps_cpp_info = DepsCppInfo()
cpp_info = CppInfo("pkg", "rootpath")
cpp_info.version = "version"
cpp_info.libs = ["lib1", "lib2"]
cpp_info.includedirs = ["include1"]
deps_cpp_info.add("pkg", DepCppInfo(cpp_info))
info_for_package = deps_cpp_info["pkg"]
# Documented as list for 'self.cpp_info' object
self.assertIsInstance(info_for_package.includedirs, list)
self.assertIsInstance(info_for_package.libdirs, list)
self.assertIsInstance(info_for_package.resdirs, list)
self.assertIsInstance(info_for_package.bindirs, list)
self.assertIsInstance(info_for_package.builddirs, list)
self.assertIsInstance(info_for_package.libs, list)
self.assertIsInstance(info_for_package.defines, list)
self.assertIsInstance(info_for_package.cflags, list)
self.assertIsInstance(info_for_package.cppflags, list)
self.assertIsInstance(info_for_package.cxxflags, list)
self.assertIsInstance(info_for_package.sharedlinkflags, list)
self.assertIsInstance(info_for_package.exelinkflags, list)
self.assertIsInstance(info_for_package.frameworks, list)
self.assertIsInstance(info_for_package.frameworkdirs, list)
self.assertIsInstance(info_for_package.rootpath, six.string_types)
self.assertIsInstance(info_for_package.name, six.string_types)
self.assertIsInstance(info_for_package.system_libs, list)
self.assertIsInstance(info_for_package.build_modules, list)
self.assertIsInstance(info_for_package.components, dict)
# Documented as list for `deps_cpp_info["pkg"]`
self.assertIsInstance(info_for_package.include_paths, list)
self.assertIsInstance(info_for_package.lib_paths, list)
self.assertIsInstance(info_for_package.bin_paths, list)
self.assertIsInstance(info_for_package.build_paths, list)
self.assertIsInstance(info_for_package.res_paths, list)
self.assertIsInstance(info_for_package.framework_paths, list)
self.assertIsInstance(info_for_package.build_modules_paths, list)
self.assertIsInstance(info_for_package.get_name("generator"),
six.string_types)
self.assertIsInstance(info_for_package.version, six.string_types)
self.assertIsInstance(info_for_package.components, dict)
def __init__(self,
output,
runner,
settings,
conanfile_directory,
user=None,
channel=None):
# User defined generators
self.generators = self.generators if hasattr(
self, "generators") else ["txt"]
if isinstance(self.generators, str):
self.generators = [self.generators]
# User defined options
self.options = create_options(self)
self.requires = create_requirements(self)
self.settings = create_settings(self, settings)
self.exports = create_exports(self)
self.exports_sources = create_exports_sources(self)
# needed variables to pack the project
self.cpp_info = None # Will be initialized at processing time
self.deps_cpp_info = DepsCppInfo()
# environment variables declared in the package_info
self.env_info = None # Will be initialized at processing time
self.deps_env_info = DepsEnvInfo()
# user declared variables
self.user_info = None
# Keys are the package names, and the values a dict with the vars
self.deps_user_info = DepsUserInfo()
self.copy = None # initialized at runtime
# an output stream (writeln, info, warn error)
self.output = output
# something that can run commands, as os.sytem
self._runner = runner
self.conanfile_directory = conanfile_directory
self._scope = None
self.develop = False
# user specified env variables
self._env_values = EnvValues() # Updated at runtime, user specified -e
self._user = user
self._channel = channel
# Are we in local cache? Suggest a better name
self.in_local_cache = False
# Init a description
self.description = None
def parse_test(self):
text = """[includedirs]
C:/Whenever
[includedirs_Boost]
F:/ChildrenPath
[includedirs_My_Lib]
mylib_path
[includedirs_My_Other_Lib]
otherlib_path
"""
deps_info = DepsCppInfo.loads(text)
self.assertEqual(deps_info.includedirs, ['C:/Whenever'])
self.assertEqual(deps_info["Boost"].includedirs, ['F:/ChildrenPath'])
self.assertEqual(deps_info["My_Lib"].includedirs, ['mylib_path'])
self.assertEqual(deps_info["My_Other_Lib"].includedirs, ['otherlib_path'])
def _check_individual_deps(self, client):
self.assertIn("INCLUDE [", client.user_io.out)
self.assertIn(".conan/data/Hello0/0.1/lasote/stable", client.user_io.out)
build_file = os.path.join(client.current_folder, BUILD_INFO)
content = load(build_file)
deps_cpp_info = DepsCppInfo.loads(content)
self.assertEqual(len(deps_cpp_info.include_paths), 4)
for dep in ("Hello3", "Hello2", "Hello1", "Hello0"):
self.assertEqual(len(deps_cpp_info[dep].include_paths), 1)
self.assertEqual(len(deps_cpp_info[dep].lib_paths), 1)
self.assertEqual(deps_cpp_info[dep].libs, ["hello%s" % dep])
build_file = os.path.join(client.current_folder, BUILD_INFO_CMAKE)
content = load(build_file)
for dep in ("Hello3", "Hello2", "Hello1", "Hello0"):
self.assertEqual(len(deps_cpp_info[dep].include_paths), 1)
self.assertIn("set(CONAN_INCLUDE_DIRS_%s " % dep.upper(), content)
self.assertIn("set(CONAN_LIBS_%s hello%s)" % (dep.upper(), dep), content)
def build(self, conanfile_path, current_path, test=False):
""" Call to build() method saved on the conanfile.py
param conanfile_path: the original source directory of the user containing a
conanfile.py
"""
logger.debug("Building in %s" % current_path)
logger.debug("Conanfile in %s" % conanfile_path)
conanfile_file = os.path.join(conanfile_path, CONANFILE)
try:
conan_file = self._loader(current_path).load_conan(conanfile_file, consumer=True)
except NotFoundException:
# TODO: Auto generate conanfile from requirements file
raise ConanException("'%s' file is needed for build.\n"
"Create a '%s' and move manually the "
"requirements and generators from '%s' file"
% (CONANFILE, CONANFILE, CONANFILE_TXT))
try:
build_info_file = os.path.join(current_path, BUILD_INFO)
if os.path.exists(build_info_file):
try:
deps_cpp_info = DepsCppInfo.loads(load(build_info_file))
conan_file.deps_cpp_info = deps_cpp_info
except:
pass
os.chdir(current_path)
conan_file.build()
if test:
conan_file.test()
except ConanException:
raise # Raise but not let to reach the Exception except (not print traceback)
except Exception:
import traceback
trace = traceback.format_exc().split('\n')
raise ConanException("Unable to build it successfully\n%s" % '\n'.join(trace[3:]))
