Пример #1
0
    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")
Пример #2
0
    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")
Пример #3
0
    def assign_test(self):
        env = DepsEnvInfo()
        env.foo = ["var"]
        env.foo.append("var2")
        env.foo2 = "var3"
        env.foo2 = "var4"
        env.foo63 = "other"

        self.assertEquals(env.vars, {"foo": ["var", "var2"], "foo2": "var4", "foo63": "other"})
Пример #4
0
    def assign_test(self):
        env = DepsEnvInfo()
        env.foo = ["var"]
        env.foo.append("var2")
        env.foo2 = "var3"
        env.foo2 = "var4"
        env.foo63 = "other"

        self.assertEqual(env.vars, {"foo": ["var", "var2"], "foo2": "var4", "foo63": "other"})
Пример #5
0
    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")
Пример #6
0
    def loads(text, filter_empty=False):
        user_info_host_idx = text.find("[{}_".format(TXTGenerator._USER_INFO_HOST_PREFIX))
        deps_env_info_idx = text.find("[ENV_")
        user_info_build_idx = text.find("[{}_".format(TXTGenerator._USER_INFO_BUILD_PREFIX))

        user_info_host_txt = deps_env_info_txt = ""

        # Get chunk with deps_cpp_info: from the beginning to the first one of the others
        last_idx = next((x for x in [user_info_host_idx, deps_env_info_idx, user_info_build_idx]
                         if x != -1), None)
        deps_cpp_info_txt = text[:last_idx]

        if user_info_host_idx != -1:
            last_idx = next((x for x in [deps_env_info_idx, user_info_build_idx] if x != -1), None)
            user_info_host_txt = text[user_info_host_idx:last_idx]

        if deps_env_info_idx != -1:
            last_idx = next((x for x in [user_info_build_idx] if x != -1), None)
            deps_env_info_txt = text[deps_env_info_idx:last_idx]

        user_info_build = None
        if user_info_build_idx != -1:
            user_info_build_txt = text[user_info_build_idx:]
            user_info_build = TXTGenerator._loads_user_info(user_info_build_txt,
                                                            TXTGenerator._USER_INFO_BUILD_PREFIX)

        deps_cpp_info = TXTGenerator._loads_cpp_info(deps_cpp_info_txt, filter_empty=filter_empty)
        deps_user_info = TXTGenerator._loads_user_info(user_info_host_txt,
                                                       TXTGenerator._USER_INFO_HOST_PREFIX)
        deps_env_info = DepsEnvInfo.loads(deps_env_info_txt)
        return deps_cpp_info, deps_user_info, deps_env_info, user_info_build
Пример #7
0
    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
Пример #8
0
    def loads(text):
        user_defines_index = text.find("[USER_")
        env_defines_index = text.find("[ENV_")
        if user_defines_index != -1:
            deps_cpp_info_txt = text[:user_defines_index]
            if env_defines_index != -1:
                user_info_txt = text[user_defines_index:env_defines_index]
                deps_env_info_txt = text[env_defines_index:]
            else:
                user_info_txt = text[user_defines_index:]
                deps_env_info_txt = ""
        else:
            if env_defines_index != -1:
                deps_cpp_info_txt = text[:env_defines_index]
                deps_env_info_txt = text[env_defines_index:]
            else:
                deps_cpp_info_txt = text
                deps_env_info_txt = ""

            user_info_txt = ""

        deps_cpp_info = TXTGenerator._loads_cpp_info(deps_cpp_info_txt)
        deps_user_info = TXTGenerator._loads_deps_user_info(user_info_txt)
        deps_env_info = DepsEnvInfo.loads(deps_env_info_txt)
        return deps_cpp_info, deps_user_info, deps_env_info
Пример #9
0
    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
Пример #10
0
 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()
Пример #11
0
    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.")
Пример #12
0
    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
Пример #13
0
    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
Пример #14
0
    def __init__(self, output, runner, settings, conanfile_directory):
        '''
        param settings: Settings
        '''

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

        # 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()

        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.package_folder = None  # Assigned at runtime
        self._scope = None
Пример #15
0
    def loads(text):
        user_defines_index = text.find("[USER_")
        env_defines_index = text.find("[ENV_")
        if user_defines_index != -1:
            deps_cpp_info_txt = text[:user_defines_index]
            if env_defines_index != -1:
                user_info_txt = text[user_defines_index:env_defines_index]
                deps_env_info_txt = text[env_defines_index:]
            else:
                user_info_txt = text[user_defines_index:]
                deps_env_info_txt = ""
        else:
            if env_defines_index != -1:
                deps_cpp_info_txt = text[:env_defines_index]
                deps_env_info_txt = text[env_defines_index:]
            else:
                deps_cpp_info_txt = text
                deps_env_info_txt = ""

            user_info_txt = ""

        deps_cpp_info = TXTGenerator._loads_cpp_info(deps_cpp_info_txt)
        deps_user_info = TXTGenerator._loads_deps_user_info(user_info_txt)
        deps_env_info = DepsEnvInfo.loads(deps_env_info_txt)
        return deps_cpp_info, deps_user_info, deps_env_info
Пример #16
0
    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"])
Пример #17
0
 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"])
Пример #18
0
    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
Пример #19
0
 def test_loads(self):
     # string
     text = "[ENV_libname]\nvar1=value1"
     ret = DepsEnvInfo.loads(text)
     self.assertDictEqual(ret.vars, {'var1': 'value1'})
     
     # string with spaces
     text = "[ENV_libname]\nvar1=value 1"
     ret = DepsEnvInfo.loads(text)
     self.assertDictEqual(ret.vars, {'var1': 'value 1'})
     
     # quoted string
     text = "[ENV_libname]\nvar1=\"value 1\""
     ret = DepsEnvInfo.loads(text)
     self.assertDictEqual(ret.vars, {'var1': '\"value 1\"'})
     
     # quoted string
     text = "[ENV_libname]\nvar1='value 1'"
     ret = DepsEnvInfo.loads(text)
     self.assertDictEqual(ret.vars, {'var1': '\'value 1\''})
     
     # number
     text = "[ENV_libname]\nvar1=123"
     ret = DepsEnvInfo.loads(text)
     self.assertDictEqual(ret.vars, {'var1': '123'})
     
     # empty
     text = "[ENV_libname]\nvar1="
     ret = DepsEnvInfo.loads(text)
     self.assertDictEqual(ret.vars, {'var1': ''})
     
     # mixed
     text = "[ENV_libname]\nvar1=value1\nvar2=\nvar3=\"value3\""
     ret = DepsEnvInfo.loads(text)
     self.assertDictEqual(ret.vars, {'var1': 'value1', 'var2': '', 'var3': '\"value3\"'})
Пример #20
0
    def update_test(self):
        env = DepsEnvInfo()
        env.foo = ["var"]
        env.foo.append("var2")
        env.foo2 = "var3"
        env.foo2 = "var4"
        env.foo63 = "other"

        env2 = DepsEnvInfo()
        env2.foo = "new_value"
        env2.foo2.append("not")
        env2.foo3.append("var3")

        env.update(env2, ConanFileReference.loads("pack/1.0@lasote/testing"))

        self.assertEqual(env.vars, {"foo": ["var", "var2", "new_value"],
                                     "foo2": "var4", "foo3": ["var3"],
                                     "foo63": "other"})
Пример #21
0
    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:]))
Пример #22
0
    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
Пример #23
0
    def pythonpath_test(self):
        """
        Check PYTHONPATH env variable
        """
        conanfile = ConanFile(TestBufferConanOutput(), None)
        conanfile.initialize(Settings({}), EnvValues.loads("PYTHONPATH=[1,2,three]"))
        conanfile.deps_env_info = DepsEnvInfo.loads(
            '[ENV_A]\nPYTHONPATH=["DepAPath"]\n[ENV_B]\nPYTHONPATH=["DepBPath"]'
        )
        gen = VirtualEnvPythonGenerator(conanfile)
        gen.output_path = "not-used"
        content = gen.content

        self.assertIn('PYTHONPATH="1":"2":"three":"DepAPath":"DepBPath"${PYTHONPATH+:$PYTHONPATH}',
                      content["environment_run_python.sh.env"])
Пример #24
0
    def update_test(self):
        env = DepsEnvInfo()
        env.foo = ["var"]
        env.foo.append("var2")
        env.foo2 = "var3"
        env.foo2 = "var4"
        env.foo63 = "other"

        env2 = DepsEnvInfo()
        env2.foo = "new_value"
        env2.foo2.append("not")
        env2.foo3.append("var3")

        env.update(env2, ConanFileReference.loads("pack/1.0@lasote/testing"))

        self.assertEquals(env.vars, {"foo": ["var", "var2", "new_value"],
                                     "foo2": "var4", "foo3": ["var3"],
                                     "foo63": "other"})
Пример #25
0
    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 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)
Пример #27
0
    def __init__(self, *args):
        if len(args) == 2:
            deps_cpp_info = args[0]
            deps_env_info = DepsEnvInfo()
            settings = args[1]
            self.output = ConanOutput(sys.stdout)
        elif len(args) == 1:  # conanfile (new interface)
            self.conanfile = args[0]
            self.output = self.conanfile.output
            deps_cpp_info = self.conanfile.deps_cpp_info
            deps_env_info = self.conanfile.deps_env_info
            settings = self.conanfile.settings

        assert isinstance(settings, Settings)

        self._settings = settings
        self._deps_cpp_info = deps_cpp_info
        self._deps_env_info = deps_env_info
        try:
            self.compiler = str(self._settings.compiler)
        except:
            self.compiler = None

        try:
            self.arch = str(self._settings.arch)
        except:
            self.arch = None

        try:
            self.os = str(self._settings.os)
        except:
            self.os = None

        try:
            self.build_type = str(self._settings.build_type)
        except:
            self.build_type = None

        try:
            self.libcxx = str(self.compiler.libcxx)
        except:
            self.libcxx = None
Пример #28
0
    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
Пример #29
0
    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)
Пример #30
0
    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']
        }))
Пример #31
0
 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()
Пример #32
0
    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.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']}))
Пример #33
0
    def _load_deps_info(self, current_path, conanfile, output):
        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))
                conanfile.deps_cpp_info = deps_cpp_info
            except:
                output.error("Parse error in '%s' file in %s" % (BUILD_INFO, current_path))
        else:
            output.warn("%s file not found in %s\nIt is recommended for source, build and package "
                        "commands\nYou can generate it using 'conan install -g env -g txt'"
                        % (BUILD_INFO, current_path))

        env_file = os.path.join(current_path, CONANENV)
        if os.path.exists(env_file):
            try:
                deps_env_info = DepsEnvInfo.loads(load(env_file))
                conanfile.deps_env_info = deps_env_info
            except:
                output.error("Parse error in '%s' file in %s" % (CONANENV, current_path))
        else:
            output.warn("%s file not found in %s\nIt is recommended for source, build and package "
                        "commands\nYou can generate it using 'conan install -g env -g txt'"
                        % (CONANENV, current_path))
Пример #34
0
    def __init__(self, *args):
        if len(args) == 2:
            deps_cpp_info = args[0]
            deps_env_info = DepsEnvInfo()
            settings = args[1]
            self.output = ConanOutput(sys.stdout)
        elif len(args) == 1:  # conanfile (new interface)
            self.conanfile = args[0]
            self.output = self.conanfile.output
            deps_cpp_info = self.conanfile.deps_cpp_info
            deps_env_info = self.conanfile.deps_env_info
            settings = self.conanfile.settings

        assert isinstance(settings, Settings)

        self.output.warn("""
***********************************************************************

    WARNING!!!

    ConfigureEnvironment class is deprecated and will be removed soon.
    With ConfigureEnvironment, env variables from profiles and/or
    command line are not applied.

    Replace it with the right one according your needs:
      - AutoToolsBuildEnvironment
      - VisualStudioBuildEnvironment

    Check docs.conan.io


***********************************************************************
        """)

        self._settings = settings
        self._deps_cpp_info = deps_cpp_info
        self._deps_env_info = deps_env_info
        try:
            self.compiler = str(self._settings.compiler)
        except:
            self.compiler = None

        try:
            self.arch = str(self._settings.arch)
        except:
            self.arch = None

        try:
            self.os = str(self._settings.os)
        except:
            self.os = None

        try:
            self.build_type = str(self._settings.build_type)
        except:
            self.build_type = None

        try:
            self.libcxx = str(self._settings.compiler.libcxx)
        except:
            self.libcxx = None
Пример #35
0
 def deps_env_info(self):
     return DepsEnvInfo()