Alternative way of setting properties that depend on generator specific features.

conans/client/generators/text.py

@@ -185,6 +185,7 @@ def _populate_cpp_info(_cpp_info, _data, _rootpath):
                     cpp_info_config = getattr(dep_cpp_info, config)
                     _populate_cpp_info(cpp_info_config, config_data, rootpath)
 
+                dep_cpp_info.update_generator_properties()
                 # Add to the dependecy list
                 deps_cpp_info.add(dep, DepCppInfo(dep_cpp_info))
 

conans/client/installer.py

@@ -637,6 +637,7 @@ def _call_package_info(self, conanfile, package_folder, ref):
                                 conanfile.name, conanfile.requires)
                         except ConanException as e:
                             raise ConanException("%s package_info(): %s" % (str(conanfile), e))
+                        conanfile.cpp_info.update_generator_properties()
                         conanfile._conan_dep_cpp_info = DepCppInfo(conanfile.cpp_info)
                     self._hook_manager.execute("post_package_info", conanfile=conanfile,
                                                reference=ref)

conans/model/build_info.py

@@ -104,6 +104,7 @@ class _CppInfo(object):
 
     def __init__(self):
         self._name = None
+        self._generator_properties = {}
         self.names = {}
         self.system_libs = []  # Ordered list of system libraries
         self.includedirs = []  # Ordered list of include paths
@@ -209,14 +210,44 @@ def name(self):
     def name(self, value):
         self._name = value
 
-    def get_name(self, generator):
-        return self.names.get(generator, self._name)
+    def set_generator_property(self, property_name, value, generator=None):
+        generator = generator or "conan_default_generators_value"
+        gen_dict = self._generator_properties.get(generator)
+        if gen_dict:
+            gen_dict.update({property_name: value})
+        else:
+            self._generator_properties.update({generator: {property_name: value}})
 
-    def get_filename(self, generator):
-        result = self.filenames.get(generator)
-        if result:
-            return result
-        return self.get_name(generator)
+    def get_generator_property(self, property_name, generator=None):
+        generator = generator or "conan_default_generators_value"
+        try:
+            gen_dict = self._generator_properties.get(generator)
+            if gen_dict:
+                return gen_dict.get(property_name)
+            elif self._generator_properties.get("conan_default_generators_value"):
+                return self._generator_properties.get("conan_default_generators_value").get(property_name)
+        except KeyError:
+            return None
+
+    def update_generator_properties(self):
+        for _, component in self.components.items():
+            for generator, value in component.names.items():
+                component.set_generator_property("names", value, generator=generator)
+                component.set_generator_property("filenames", value, generator=generator)
+            for generator, value in component.filenames.items():
+                component.set_generator_property("filenames", value, generator=generator)
+
+        for generator, value in self.names.items():
+            self.set_generator_property("names", value, generator=generator)
+            self.set_generator_property("filenames", value, generator=generator)
+        for generator, value in self.filenames.items():
+            self.set_generator_property("filenames", value, generator=generator)
+
+    def get_name(self, generator=None):
+        return self.get_generator_property("names", generator) or self._name
+
+    def get_filename(self, generator=None):
+        return self.get_generator_property("filenames", generator) or self._name
 
     # Compatibility for 'cppflags' (old style property to allow decoration)
     def get_cppflags(self):

conans/test/functional/generators/cpp_info_set_generator_properties_test.py

@@ -0,0 +1,142 @@
+import os
+import textwrap
+
+import pytest
+
+from conans.test.assets.genconanfile import GenConanfile
+from conans.test.utils.tools import TestClient
+
+
+@pytest.fixture(scope="module")
+def setup_client():
+    client = TestClient()
+    custom_generator = textwrap.dedent("""
+        from conans.model import Generator
+        from conans import ConanFile
+        from conans.model.conan_generator import GeneratorComponentsMixin
+        import textwrap
+        import os
+
+        class custom_generator(GeneratorComponentsMixin, Generator):
+            name = "custom_generator"
+            @property
+            def filename(self):
+                return "my-generator.txt"
+
+            def _get_components(self, pkg_name, cpp_info):
+                components = super(custom_generator, self)._get_components(pkg_name, cpp_info)
+                ret = []
+                for comp_genname, comp, comp_requires_gennames in components:
+                    ret.append("{}:{}".format(comp.name, comp_genname))
+                return ret
+
+            @property
+            def content(self):
+                info = []
+                for pkg_name, cpp_info in self.deps_build_info.dependencies:
+                    info.append("{}:{}".format(pkg_name, cpp_info.get_generator_property("names", self.name)))
+                    info.extend(self._get_components(pkg_name, cpp_info))
+                return os.linesep.join(info)
+        """)
+    client.save({"custom_generator.py": custom_generator})
+    client.run("config install custom_generator.py -tf generators")
+
+    client.save({"consumer.py": GenConanfile("consumer", "1.0").with_requires("mypkg/1.0").
+                with_generator("custom_generator").with_generator("cmake_find_package")})
+    return client
+
+
+@pytest.mark.tool_cmake
+def test_same_results_components(setup_client):
+    client = setup_client
+    mypkg = textwrap.dedent("""
+        import os
+        from conans import ConanFile, CMake, tools
+        class MyPkg(ConanFile):
+            name = "mypkg"
+            version = "1.0"
+            def package_info(self):
+                self.cpp_info.components["mycomponent"].libs = ["mycomponent-lib"]
+                self.cpp_info.components["mycomponent"].set_generator_property("names", "mycomponent-name")
+        """)
+
+    client.save({"mypkg.py": mypkg})
+    client.run("export mypkg.py")
+
+    client.run("install consumer.py --build missing")
+
+    with open(os.path.join(client.current_folder, "my-generator.txt")) as custom_gen_file:
+        assert "mycomponent:mycomponent-name" in custom_gen_file.read()
+
+    with open(os.path.join(client.current_folder, "Findmypkg.cmake")) as properties_package_file:
+        properties_find_package_content = properties_package_file.read()
+
+    mypkg = textwrap.dedent("""
+        import os
+        from conans import ConanFile, CMake, tools
+        class MyPkg(ConanFile):
+            name = "mypkg"
+            version = "1.0"
+            def package_info(self):
+                self.cpp_info.components["mycomponent"].libs = ["mycomponent-lib"]
+                self.cpp_info.components["mycomponent"].names["cmake_find_package"] = "mycomponent-name"
+                self.cpp_info.components["mycomponent"].names["custom_generator"] = "mycomponent-name"
+        """)
+    client.save({"mypkg.py": mypkg})
+    client.run("create mypkg.py")
+    client.run("install consumer.py")
+
+    with open(os.path.join(client.current_folder, "my-generator.txt")) as custom_gen_file:
+        assert "mycomponent:mycomponent-name" in custom_gen_file.read()
+
+    with open(os.path.join(client.current_folder, "Findmypkg.cmake")) as find_package_file:
+        normal_find_package_content = find_package_file.read()
+
+    assert properties_find_package_content == normal_find_package_content
+
+
+@pytest.mark.tool_cmake
+def test_same_results_without_components(setup_client):
+    client = setup_client
+    mypkg = textwrap.dedent("""
+        import os
+        from conans import ConanFile, CMake, tools
+        class MyPkg(ConanFile):
+            name = "mypkg"
+            version = "1.0"
+            def package_info(self):
+                self.cpp_info.set_generator_property("names", "mypkg-name")
+        """)
+
+    client.save({"mypkg.py": mypkg})
+    client.run("export mypkg.py")
+
+    client.run("install consumer.py --build missing")
+
+    with open(os.path.join(client.current_folder, "my-generator.txt")) as custom_gen_file:
+        assert "mypkg:mypkg-name" in custom_gen_file.read()
+
+    with open(os.path.join(client.current_folder, "Findmypkg.cmake")) as properties_package_file:
+        properties_find_package_content = properties_package_file.read()
+
+    mypkg = textwrap.dedent("""
+        import os
+        from conans import ConanFile, CMake, tools
+        class MyPkg(ConanFile):
+            name = "mypkg"
+            version = "1.0"
+            def package_info(self):
+                self.cpp_info.names["cmake_find_package"] = "mypkg-name"
+                self.cpp_info.names["custom_generator"] = "mypkg-name"
+        """)
+    client.save({"mypkg.py": mypkg})
+    client.run("create mypkg.py")
+    client.run("install consumer.py")
+
+    with open(os.path.join(client.current_folder, "my-generator.txt")) as custom_gen_file:
+        assert "mypkg:mypkg-name" in custom_gen_file.read()
+
+    with open(os.path.join(client.current_folder, "Findmypkg.cmake")) as find_package_file:
+        normal_find_package_content = find_package_file.read()
+
+    assert properties_find_package_content == normal_find_package_content

conans/test/unittests/client/generators/cmake_paths_test.py

@@ -76,6 +76,7 @@ def test_cpp_info_names(self):
         cpp_info = CppInfo("pkg_reference_name", tmp)
         cpp_info.name = "PkgCMakeName"
         cpp_info.names["cmake_paths"] = "MyCMakePathsPkgName"
+        cpp_info.update_generator_properties()
         conanfile.deps_cpp_info.add("pkg_reference_name", cpp_info)
         generator = CMakePathsGenerator(conanfile)
         self.assertIn('set(CONAN_MYCMAKEPATHSPKGNAME_ROOT', generator.content)

conans/test/unittests/client/generators/cmake_test.py

@@ -479,6 +479,7 @@ def setUp(self):
         cpp_info.names["cmake_multi"] = "MyCMakeMultiName"
         cpp_info.names["cmake_find_package"] = "MyCMakeFindPackageName"
         cpp_info.names["cmake_find_package_multi"] = "MyCMakeFindPackageMultiName"
+        cpp_info.update_generator_properties()
         self.conanfile.deps_cpp_info.add(ref.name, cpp_info)
         ref = ConanFileReference.loads("my_pkg2/0.1@lasote/stables")
         cpp_info = CppInfo(ref.name, "dummy_root_folder2")
@@ -488,6 +489,7 @@ def setUp(self):
         cpp_info.names["cmake_find_package"] = "MyCMakeFindPackageName2"
         cpp_info.names["cmake_find_package_multi"] = "MyCMakeFindPackageMultiName2"
         cpp_info.public_deps = ["my_pkg"]
+        cpp_info.update_generator_properties()
         self.conanfile.deps_cpp_info.add(ref.name, cpp_info)
 
     def test_cmake(self):

conans/test/unittests/client/generators/txt/test_dump_load.py

@@ -20,13 +20,14 @@ def test_names_per_generator(self):
         cpp_info.names["txt"] = "txt_name"
         cpp_info.names["cmake_find_package"] = "SpecialName"
         cpp_info.filenames["cmake_find_package"] = "SpecialFileName"
+        cpp_info.update_generator_properties()
         conanfile = ConanFile(Mock(), None)
         conanfile.initialize(Settings({}), EnvValues())
         conanfile.deps_cpp_info.add("pkg_name", DepCppInfo(cpp_info))
         content = TXTGenerator(conanfile).content
         parsed_deps_cpp_info, _, _, _ = TXTGenerator.loads(content, filter_empty=False)
-
         parsed_cpp_info = parsed_deps_cpp_info["pkg_name"]
+        parsed_cpp_info.update_generator_properties()
         self.assertEqual(parsed_cpp_info.get_name("txt"), "txt_name")
         self.assertEqual(parsed_cpp_info.get_name("cmake_find_package"), "SpecialName")
         self.assertEqual(parsed_cpp_info.get_filename("cmake_find_package"), "SpecialFileName")
@@ -45,13 +46,15 @@ def test_idempotent(self):
         cpp_info.cxxflags = ["-cxxflag_parent"]
         cpp_info.includedirs = ["mypkg1/include"]
         cpp_info.filter_empty = False
+        cpp_info.update_generator_properties()
         conanfile.deps_cpp_info.add(ref.name, cpp_info)
 
         ref = ConanFileReference.loads("MyPkg2/0.1@lasote/stables")
         cpp_info = CppInfo(ref.name, "dummy_root_folder2")
         cpp_info.defines = ["MYDEFINE2"]
         cpp_info.cxxflags = ["-cxxflag_dep"]
         cpp_info.filter_empty = False
+        cpp_info.update_generator_properties()
         conanfile.deps_cpp_info.add(ref.name, cpp_info)
 
         # Add env_info

conans/test/unittests/model/build_info_test.py

@@ -233,6 +233,7 @@ def test_cpp_info_name(self):
         info = CppInfo("myname", folder)
         info.name = "MyName"
         info.names["my_generator"] = "MyNameForMyGenerator"
+        info.update_generator_properties()
         deps_cpp_info = DepsCppInfo()
         deps_cpp_info.add("myname", DepCppInfo(info))
         self.assertIn("MyName", deps_cpp_info["myname"].get_name("my_undefined_generator"))