conan-server 2.6.0__tar.gz → 2.7.0__tar.gz

{conan-server-2.6.0 → conan-server-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conan-server
-Version: 2.6.0
+Version: 2.7.0
 Summary: Conan Server of Conan C/C++ package manager
 Home-page: https://conan.io
 Author: JFrog LTD

{conan-server-2.6.0 → conan-server-2.7.0}/conan/api/subapi/cache.py

@@ -63,6 +63,8 @@ class CacheAPI:
         app = ConanApp(self.conan_api)
         pref = _resolve_latest_pref(app, pref)
         ref_layout = app.cache.pkg_layout(pref)
+        if os.path.exists(ref_layout.finalize()):
+            return ref_layout.finalize()
         return _check_folder_existence(pref, "package", ref_layout.package())
 
     def check_integrity(self, package_list):

{conan-server-2.6.0 → conan-server-2.7.0}/conan/cli/commands/config.py

@@ -1,7 +1,7 @@
 from conan.api.output import cli_out_write
 from conan.cli.command import conan_command, conan_subcommand, OnceArgument
 from conan.cli.formatters import default_json_formatter
-from conans.util.config_parser import get_bool_from_text
+from conan.errors import ConanException
 
 
 @conan_command(group='Consumer')
@@ -39,6 +39,14 @@ def config_install(conan_api, parser, subparser, *args):
                            help='Install to that path in the conan cache')
 
     args = parser.parse_args(*args)
+
+    def get_bool_from_text(value):  # TODO: deprecate this
+        value = value.lower()
+        if value in ["1", "yes", "y", "true"]:
+            return True
+        if value in ["0", "no", "n", "false"]:
+            return False
+        raise ConanException("Unrecognized boolean value '%s'" % value)
     verify_ssl = args.verify_ssl if isinstance(args.verify_ssl, bool) \
         else get_bool_from_text(args.verify_ssl)
     conan_api.config.install(args.item, verify_ssl, args.type, args.args,

{conan-server-2.6.0 → conan-server-2.7.0}/conan/cli/commands/graph.py

@@ -133,7 +133,6 @@ def graph_build_order(conan_api, parser, subparser, *args):
             "conan_error": install_graph.get_errors()}
 
 
-
 @conan_subcommand(formatters={"text": cli_build_order, "json": json_build_order,
                               "html": format_build_order_html})
 def graph_build_order_merge(conan_api, parser, subparser, *args):

{conan-server-2.6.0 → conan-server-2.7.0}/conan/cli/printers/graph.py

@@ -1,6 +1,7 @@
 from conan.api.output import ConanOutput, Color, LEVEL_VERBOSE
-from conans.client.graph.graph import BINARY_INVALID, BINARY_MISSING, RECIPE_CONSUMER, RECIPE_VIRTUAL, CONTEXT_BUILD, BINARY_SKIP,\
-    BINARY_PLATFORM
+from conans.client.graph.graph import BINARY_INVALID, BINARY_MISSING, RECIPE_CONSUMER, \
+    RECIPE_VIRTUAL, CONTEXT_BUILD, BINARY_SKIP, \
+    BINARY_PLATFORM, BINARY_BUILD
 
 
 def print_graph_basic(graph):
@@ -129,6 +130,9 @@ def print_graph_packages(graph):
             elif status == BINARY_MISSING or status == BINARY_INVALID:
                 output.write(msg, Color.BRIGHT_CYAN)
                 output.writeln(status, Color.BRIGHT_RED)
+            elif status == BINARY_BUILD:
+                output.write(msg, Color.BRIGHT_CYAN)
+                output.writeln(status, Color.BRIGHT_YELLOW)
             else:
                 # Support python36
                 msg += status

conan-server-2.7.0/conan/cps/__init__.py

@@ -0,0 +1 @@
+from conan.cps.cps import CPS

conan-server-2.7.0/conan/cps/cps.py

@@ -0,0 +1,302 @@
+import glob
+import json
+import os
+from enum import Enum
+
+from conan.api.output import ConanOutput
+from conans.model.build_info import CppInfo
+from conans.model.pkg_type import PackageType
+from conans.util.files import save, load
+
+
+class CPSComponentType(Enum):
+    DYLIB = "dylib"
+    ARCHIVE = "archive"
+    INTERFACE = "interface"
+    EXE = "exe"
+    JAR = "jar"
+    UNKNOWN = "unknown"
+
+    def __str__(self):
+        return self.value
+
+    def __eq__(self, other):
+        # This is useful for comparing with string type at user code, like ``type == "xxx"``
+        return super().__eq__(CPSComponentType(other))
+
+    @staticmethod
+    def from_conan(pkg_type):
+        _package_type_map = {
+            "shared-library": "dylib",
+            "static-library": "archive",
+            "header-library": "interface",
+            "application": "executable"
+        }
+        return CPSComponentType(_package_type_map.get(str(pkg_type), "unknown"))
+
+
+def deduce_full_lib_info(libname, full_lib, cpp_info, pkg_type):
+    if full_lib.get("type") is not None:
+        assert "location" in full_lib, f"If 'type' is specified in library {libname}, 'location' too"
+        return
+
+    # Recipe didn't specify things, need to auto deduce
+    libdirs = [x.replace("\\", "/") for x in cpp_info.libdirs]
+    bindirs = [x.replace("\\", "/") for x in cpp_info.bindirs]
+
+    static_patterns = [f"{libname}.lib", f"{libname}.a", f"lib{libname}.a"]
+    shared_patterns = [f"lib{libname}.so", f"lib{libname}.so.*", f"lib{libname}.dylib",
+                       f"lib{libname}.*dylib"]
+    dll_patterns = [f"{libname}.dll"]
+
+    def _find_matching(patterns, dirs):
+        matches = set()
+        for pattern in patterns:
+            for d in dirs:
+                matches.update(glob.glob(f"{d}/{pattern}"))
+        if len(matches) == 1:
+            return next(iter(matches))
+
+    static_location = _find_matching(static_patterns, libdirs)
+    shared_location = _find_matching(shared_patterns, libdirs)
+    dll_location = _find_matching(dll_patterns, bindirs)
+    if static_location:
+        if shared_location:
+            ConanOutput().warning(f"Lib {libname} has both static {static_location} and "
+                                  f"shared {shared_location} in the same package")
+            if pkg_type is PackageType.STATIC:
+                full_lib["location"] = static_location
+                full_lib["type"] = PackageType.STATIC
+            else:
+                full_lib["location"] = shared_location
+                full_lib["type"] = PackageType.SHARED
+        elif dll_location:
+            full_lib["location"] = dll_location
+            full_lib["link_location"] = static_location
+            full_lib["type"] = PackageType.SHARED
+        else:
+            full_lib["location"] = static_location
+            full_lib["type"] = PackageType.STATIC
+    elif shared_location:
+        full_lib["location"] = shared_location
+        full_lib["type"] = PackageType.SHARED
+    elif dll_location:
+        # Only .dll but no link library
+        full_lib["location"] = dll_location
+        full_lib["type"] = PackageType.SHARED
+    if full_lib.get("type") != pkg_type:
+        ConanOutput().warning(f"Lib {libname} deduced as '{full_lib.get('type')}, "
+                              f"but 'package_type={pkg_type}'")
+
+
+class CPSComponent:
+    def __init__(self, component_type=None):
+        self.includes = []
+        self.type = component_type or "unknown"
+        self.definitions = []
+        self.requires = []
+        self.location = None
+        self.link_location = None
+        self.link_libraries = None  # system libraries
+
+    def serialize(self):
+        component = {"type": str(self.type)}
+        if self.requires:
+            component["requires"] = self.requires
+        if self.includes:
+            component["includes"] = [x.replace("\\", "/") for x in self.includes]
+        if self.definitions:
+            component["definitions"] = self.definitions
+        if self.location:  # TODO: @prefix@
+            component["location"] = self.location
+        if self.link_location:
+            component["link_location"] = self.link_location
+        if self.link_libraries:
+            component["link_libraries"] = self.link_libraries
+        return component
+
+    @staticmethod
+    def deserialize(data):
+        comp = CPSComponent()
+        comp.type = CPSComponentType(data.get("type"))
+        comp.requires = data.get("requires")
+        comp.includes = data.get("includes")
+        comp.definitions = data.get("definitions")
+        comp.location = data.get("location")
+        comp.link_location = data.get("link_location")
+        comp.link_libraries = data.get("link_libraries")
+        return comp
+
+    @staticmethod
+    def from_cpp_info(cpp_info, pkg_type, libname=None):
+        cps_comp = CPSComponent()
+        if not libname:
+            cps_comp.definitions = cpp_info.defines
+            cps_comp.includes = [x.replace("\\", "/") for x in cpp_info.includedirs]
+
+        if not cpp_info.libs:
+            cps_comp.type = CPSComponentType.INTERFACE
+            return cps_comp
+
+        if len(cpp_info.libs) > 1 and not libname:  # Multi-lib pkg without components defined
+            cps_comp.type = CPSComponentType.INTERFACE
+            return cps_comp
+
+        libname = libname or next(iter(cpp_info.full_libs))
+        full_lib = cpp_info.full_libs[libname]
+        deduce_full_lib_info(libname, full_lib, cpp_info, pkg_type)
+        cps_comp.type = CPSComponentType.from_conan(full_lib.get("type"))
+        cps_comp.location = full_lib.get("location")
+        cps_comp.link_location = full_lib.get("link_location")
+        cps_comp.link_libraries = cpp_info.system_libs
+        required = cpp_info.requires
+        cps_comp.requires = [f":{c}" if "::" not in c else c.replace("::", ":") for c in required]
+        return cps_comp
+
+
+class CPS:
+    """ represents the CPS file for 1 package
+    """
+    def __init__(self, name=None, version=None):
+        self.name = name
+        self.version = version
+        self.default_components = []
+        self.components = {}
+        self.configurations = []
+        self.requires = []
+        # Supplemental
+        self.description = None
+        self.license = None
+        self.website = None
+
+    def serialize(self):
+        cps = {"cps_version": "0.12.0",
+               "name": self.name,
+               "version": self.version}
+
+        # Supplemental
+        for data in "license", "description", "website":
+            if getattr(self, data, None):
+                cps[data] = getattr(self, data)
+
+        if self.requires:
+            cps["requires"] = self.requires
+
+        if self.configurations:
+            cps["configurations"] = self.configurations
+
+        cps["default_components"] = self.default_components
+        cps["components"] = {}
+        for name, comp in self.components.items():
+            cps["components"][name] = comp.serialize()
+
+        return cps
+
+    @staticmethod
+    def deserialize(data):
+        cps = CPS()
+        cps.name = data.get("name")
+        cps.version = data.get("version")
+        cps.license = data.get("license")
+        cps.description = data.get("description")
+        cps.website = data.get("website")
+        cps.requires = data.get("requires")
+        cps.configurations = data.get("configurations")
+        cps.default_components = data.get("default_components")
+        cps.components = {k: CPSComponent.deserialize(v)
+                          for k, v in data.get("components", {}).items()}
+        return cps
+
+    @staticmethod
+    def from_conan(dep):
+        cps = CPS(dep.ref.name, str(dep.ref.version))
+        # supplemental
+        cps.license = dep.license
+        cps.description = dep.description
+        cps.website = dep.homepage
+
+        cps.requires = {d.ref.name: None for d in dep.dependencies.host.values()}
+        if dep.settings.get_safe("build_type"):
+            cps.configurations = [str(dep.settings.build_type).lower()]
+
+        if not dep.cpp_info.has_components:
+            if dep.cpp_info.libs and len(dep.cpp_info.libs) > 1:
+                comp = CPSComponent.from_cpp_info(dep.cpp_info, dep.package_type)  # base
+                base_name = f"_{cps.name}"
+                cps.components[base_name] = comp
+                for lib in dep.cpp_info.libs:
+                    comp = CPSComponent.from_cpp_info(dep.cpp_info, dep.package_type, lib)
+                    comp.requires.insert(0, f":{base_name}")  # dep to the common one
+                    cps.components[lib] = comp
+                cps.default_components = dep.cpp_info.libs
+                # FIXME: What if one lib is named equal to the package?
+            else:
+                # single component, called same as library
+                component = CPSComponent.from_cpp_info(dep.cpp_info, dep.package_type)
+                if not component.requires and dep.dependencies:
+                    for transitive_dep in dep.dependencies.host.items():
+                        dep_name = transitive_dep[0].ref.name
+                        component.requires.append(f"{dep_name}:{dep_name}")
+
+                # the component will be just the package name
+                cps.default_components = [f"{dep.ref.name}"]
+                cps.components[f"{dep.ref.name}"] = component
+        else:
+            sorted_comps = dep.cpp_info.get_sorted_components()
+            for comp_name, comp in sorted_comps.items():
+                component = CPSComponent.from_cpp_info(comp, dep.package_type)
+                cps.components[comp_name] = component
+            # Now by default all are default_components
+            cps.default_components = [comp_name for comp_name in sorted_comps]
+
+        return cps
+
+    def to_conan(self):
+        def strip_prefix(dirs):
+            return [d.replace("@prefix@/", "") for d in dirs]
+
+        cpp_info = CppInfo()
+        if len(self.components) == 1:
+            comp = next(iter(self.components.values()))
+            cpp_info.includedirs = strip_prefix(comp.includes)
+            cpp_info.defines = comp.definitions
+            if comp.type is CPSComponentType.ARCHIVE:
+                location = comp.location
+                location = location.replace("@prefix@/", "")
+                cpp_info.libdirs = [os.path.dirname(location)]
+                filename = os.path.basename(location)
+                basefile, ext = os.path.splitext(filename)
+                if basefile.startswith("lib") and ext != ".lib":
+                    basefile = basefile[3:]
+                cpp_info.libs = [basefile]
+                # FIXME: Missing requires
+            cpp_info.system_libs = comp.link_libraries
+        else:
+            for comp_name, comp in self.components.items():
+                cpp_comp = cpp_info.components[comp_name]
+                cpp_comp.includedirs = strip_prefix(comp.includes)
+                cpp_comp.defines = comp.definitions
+                if comp.type is CPSComponentType.ARCHIVE:
+                    location = comp.location
+                    location = location.replace("@prefix@/", "")
+                    cpp_comp.libdirs = [os.path.dirname(location)]
+                    filename = os.path.basename(location)
+                    basefile, ext = os.path.splitext(filename)
+                    if basefile.startswith("lib") and ext != ".lib":
+                        basefile = basefile[3:]
+                    cpp_comp.libs = [basefile]
+                for r in comp.requires:
+                    cpp_comp.requires.append(r[1:] if r.startswith(":") else r.replace(":", "::"))
+                cpp_comp.system_libs = comp.link_libraries
+
+        return cpp_info
+
+    def save(self, folder):
+        filename = os.path.join(folder, f"{self.name}.cps")
+        save(filename, json.dumps(self.serialize(), indent=2))
+        return filename
+
+    @staticmethod
+    def load(file):
+        contents = load(file)
+        return CPS.deserialize(json.loads(contents))

{conan-server-2.6.0 → conan-server-2.7.0}/conan/internal/api/detect_api.py

@@ -5,6 +5,7 @@ import tempfile
 import textwrap
 
 from conan.api.output import ConanOutput
+from conan.errors import ConanException
 from conans.model.version import Version
 from conans.util.files import load, save
 from conans.util.runners import check_output_runner, detect_runner
@@ -568,6 +569,9 @@ def default_compiler_version(compiler, version):
     of the minor or patch digits, that do not affect binary compatibility
     """
     output = ConanOutput(scope="detect_api")
+    if not version:
+        raise ConanException(
+            f"No version provided to 'detect_api.default_compiler_version()' for {compiler} compiler")
     tokens = version.main
     major = tokens[0]
     minor = tokens[1] if len(tokens) > 1 else 0

{conan-server-2.6.0 → conan-server-2.7.0}/conan/internal/api/install/generators.py

@@ -30,7 +30,9 @@ _generators = {"CMakeToolchain": "conan.tools.cmake",
                "PremakeDeps": "conan.tools.premake",
                "MakeDeps": "conan.tools.gnu",
                "SConsDeps": "conan.tools.scons",
-               "QbsDeps": "conan.tools.qbs"
+               "QbsDeps": "conan.tools.qbs",
+               "QbsProfile": "conan.tools.qbs",
+               "CPSDeps": "conan.tools.cps"
                }
 
 

{conan-server-2.6.0 → conan-server-2.7.0}/conan/internal/cache/conan_reference_layout.py

@@ -10,6 +10,7 @@ from conans.util.files import set_dirty, clean_dirty, is_dirty, rmdir
 SRC_FOLDER = "s"
 BUILD_FOLDER = "b"
 PACKAGES_FOLDER = "p"
+FINALIZE_FOLDER = "f"
 EXPORT_FOLDER = "e"
 EXPORT_SRC_FOLDER = "es"
 DOWNLOAD_EXPORT_FOLDER = "d"
@@ -55,7 +56,7 @@ class RecipeLayout(LayoutBase):
         return os.path.join(self._base_folder, EXPORT_SRC_FOLDER)
 
     def metadata(self):
-        return os.path.join(self.download_export(), "metadata")
+        return os.path.join(self.download_export(), METADATA)
 
     def download_export(self):
         return os.path.join(self._base_folder, DOWNLOAD_EXPORT_FOLDER)
@@ -99,11 +100,14 @@ class PackageLayout(LayoutBase):
     def package(self):
         return os.path.join(self._base_folder, PACKAGES_FOLDER)
 
+    def finalize(self):
+        return os.path.join(self._base_folder, FINALIZE_FOLDER)
+
     def download_package(self):
         return os.path.join(self._base_folder, DOWNLOAD_EXPORT_FOLDER)
 
     def metadata(self):
-        return os.path.join(self.download_package(), "metadata")
+        return os.path.join(self.download_package(), METADATA)
 
     def package_manifests(self):
         package_folder = self.package()

{conan-server-2.6.0 → conan-server-2.7.0}/conan/internal/deploy.py

@@ -18,7 +18,10 @@ def _find_deployer(d, cache_deploy_folder):
     """
     def _load(path):
         mod, _ = load_python_file(path)
-        return mod.deploy
+        try:
+            return mod.deploy
+        except AttributeError:
+            raise ConanException(f"Deployer does not contain 'deploy()' function: {path}")
 
     if not d.endswith(".py"):
         d += ".py"  # Deployers must be python files

{conan-server-2.6.0 → conan-server-2.7.0}/conan/test/assets/genconanfile.py

@@ -27,6 +27,7 @@ class GenConanfile(object):
         self._provides = None
         self._deprecated = None
         self._package_lines = None
+        self._finalize_lines = None
         self._package_files = None
         self._package_files_env = None
         self._package_files_link = None
@@ -48,6 +49,8 @@ class GenConanfile(object):
         self._cmake_build = False
         self._class_attributes = None
 
+        self._is_tested_ref_build_require = None
+
     def with_package_type(self, value):
         self._package_type = value
         return self
@@ -143,6 +146,10 @@ class GenConanfile(object):
             self._test_requires.append(ref_str)
         return self
 
+    def with_test_reference_as_build_require(self):
+        self._is_tested_ref_build_require = True
+        return self
+
     def with_build_requirement(self, ref, **kwargs):
         self._build_requirements = self._build_requirements or []
         ref_str = self._get_full_ref_str(ref)
@@ -155,9 +162,10 @@ class GenConanfile(object):
         self._tool_requirements.append((ref_str, kwargs))
         return self
 
-    def with_import(self, i):
-        if i not in self._imports:
-            self._imports.append(i)
+    def with_import(self, *imports):
+        for i in imports:
+            if i not in self._imports:
+                self._imports.append(i)
         return self
 
     def with_setting(self, setting):
@@ -207,6 +215,12 @@ class GenConanfile(object):
             self._package_lines.append(line)
         return self
 
+    def with_finalize(self, *lines):
+        self._finalize_lines = self._finalize_lines or []
+        for line in lines:
+            self._finalize_lines.append(line)
+        return self
+
     def with_build_msg(self, msg):
         self._build_messages = self._build_messages or []
         self._build_messages.append(msg)
@@ -222,14 +236,16 @@ class GenConanfile(object):
             self._package_info["env_info"] = env_info
         return self
 
-    def with_package_id(self, line):
+    def with_package_id(self, *lines):
         self._package_id_lines = self._package_id_lines or []
-        self._package_id_lines.append(line)
+        for line in lines:
+            self._package_id_lines.append(line)
         return self
 
-    def with_test(self, line):
+    def with_test(self, *lines):
         self._test_lines = self._test_lines or []
-        self._test_lines.append(line)
+        for line in lines:
+            self._test_lines.append(line)
         return self
 
     def with_cmake_build(self):
@@ -360,6 +376,10 @@ class GenConanfile(object):
         return (self._package_lines or self._package_files or self._package_files_env or
                 self._package_files_link)
 
+    @property
+    def _finalize_method(self):
+        return self._finalize_lines
+
     @property
     def _package_method_render(self):
         lines = []
@@ -388,6 +408,19 @@ class GenConanfile(object):
 {}
     """.format("\n".join(lines))
 
+    @property
+    def _finalize_method_render(self):
+        lines = []
+        if self._finalize_lines:
+            lines.extend("        {}".format(line) for line in self._finalize_lines)
+
+        if not lines:
+            return ""
+        return """
+    def finalize(self):
+{}
+        """.format("\n".join(lines))
+
     @property
     def _build_render(self):
         if not self._build_messages and not self._cmake_build:
@@ -432,11 +465,20 @@ class GenConanfile(object):
 
     @property
     def _test_lines_render(self):
-        lines = ["",
-                 "    def requirements(self):",
-                 '         self.requires(self.tested_reference_str)',
-                 "",
-                 '    def test(self):'] + ['        %s' % m for m in self._test_lines]
+        if self._is_tested_ref_build_require:
+            lines = ["",
+                     "    def build_requirements(self):",
+                     '         self.tool_requires(self.tested_reference_str)',
+                     "",
+                     '    def test(self):']
+        else:
+            lines = ["",
+                     "    def requirements(self):",
+                     '         self.requires(self.tested_reference_str)',
+                     "",
+                     '    def test(self):']
+
+        lines += ['        %s' % m for m in self._test_lines]
         return "\n".join(lines)
 
     @property
@@ -463,7 +505,8 @@ class GenConanfile(object):
                        "exports_sources", "exports", "generators", "requires", "build_requires",
                        "tool_requires", "test_requires", "requirements", "python_requires",
                        "revision_mode", "settings", "options", "default_options", "build",
-                       "package_method", "package_info", "package_id_lines", "test_lines"
+                       "package_method", "package_info", "package_id_lines", "test_lines",
+                       "finalize_method"
                        ):
             if member == "requirements":
                 # FIXME: This seems exclusive, but we could mix them?

{conan-server-2.6.0 → conan-server-2.7.0}/conan/test/assets/visual_project_files.py

@@ -1,6 +1,6 @@
 # All harcoded (names, paths etc), refactor it if needed
 
-sln_file = '''
+sln_file = r'''
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 2013
 VisualStudioVersion = 12.0.31101.0
@@ -38,7 +38,7 @@ EndGlobal
 
 '''
 
-vcxproj_file = '''<?xml version="1.0" encoding="utf-8"?>
+vcxproj_file = r'''<?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|ARM">
@@ -282,6 +282,8 @@ def get_vs_project_files(std=False):
         main = main_file_17_2015
     elif std == "cpp17_2017":
         main = main_file_17_2017
+    else:
+        raise Exception("Incorrect std")
 
     return {"MyProject.sln": sln_file,
             "MyProject/MyProject.vcxproj": vcxproj_file,

{conan-server-2.6.0 → conan-server-2.7.0}/conan/tools/build/flags.py

@@ -40,6 +40,8 @@ def architecture_flag(settings):
             return '-m32'
         elif arch in ['s390']:
             return '-m31'
+        elif arch in ['tc131', 'tc16', 'tc161', 'tc162', 'tc18']:
+            return '-m{}'.format(arch)
         elif the_os == 'AIX':
             if arch in ['ppc32']:
                 return '-maix32'

{conan-server-2.6.0 → conan-server-2.7.0}/conan/tools/cmake/cmakedeps/cmakedeps.py

@@ -149,7 +149,7 @@ class CMakeDeps(object):
         build_suffix = "&build" if build_context else ""
         self._properties.setdefault(f"{dep}{build_suffix}", {}).update({prop: value})
 
-    def get_property(self, prop, dep, comp_name=None):
+    def get_property(self, prop, dep, comp_name=None, check_type=None):
         dep_name = dep.ref.name
         build_suffix = "&build" if str(
             dep_name) in self.build_context_activated and dep.context == "build" else ""
@@ -157,8 +157,8 @@ class CMakeDeps(object):
         try:
             return self._properties[f"{dep_comp}{build_suffix}"][prop]
         except KeyError:
-            return dep.cpp_info.get_property(prop) if not comp_name else dep.cpp_info.components[
-                comp_name].get_property(prop)
+            return dep.cpp_info.get_property(prop, check_type=check_type) if not comp_name \
+                else dep.cpp_info.components[comp_name].get_property(prop, check_type=check_type)
 
     def get_cmake_package_name(self, dep, module_mode=None):
         """Get the name of the file for the find_package(XXX)"""

{conan-server-2.6.0 → conan-server-2.7.0}/conan/tools/cmake/cmakedeps/templates/config.py

@@ -25,7 +25,7 @@ class ConfigTemplate(CMakeDepsFileTemplate):
     @property
     def additional_variables_prefixes(self):
         prefix_list = (
-            self.cmakedeps.get_property("cmake_additional_variables_prefixes", self.conanfile) or [])
+            self.cmakedeps.get_property("cmake_additional_variables_prefixes", self.conanfile, check_type=list) or [])
         return list(set([self.file_name] + prefix_list))
 
     @property

{conan-server-2.6.0 → conan-server-2.7.0}/conan/tools/cmake/cmakedeps/templates/target_configuration.py

@@ -28,7 +28,7 @@ class TargetConfigurationTemplate(CMakeDepsFileTemplate):
 
         is_win = self.conanfile.settings.get_safe("os") == "Windows"
         auto_link = self.cmakedeps.get_property("cmake_set_interface_link_directories",
-                                                self.conanfile)
+                                                self.conanfile, check_type=bool)
         return {"pkg_name": self.pkg_name,
                 "root_target_name": self.root_target_name,
                 "config_suffix": self.config_suffix,