libsigcpp: conan v2 support

recipes/libsigcpp/2.x.x/conanfile.py

@@ -1,20 +1,23 @@
-from conans import ConanFile, Meson, tools
-from conan.tools.files import rename
-from conans.errors import ConanInvalidConfiguration
+from conan import ConanFile
+from conan.tools.apple import fix_apple_shared_install_name
+from conan.tools.build import check_min_cppstd
+from conan.tools.env import VirtualBuildEnv
+from conan.tools.files import copy, get, rename, replace_in_file, rm, rmdir
+from conan.tools.layout import basic_layout
+from conan.tools.meson import Meson, MesonToolchain
 import glob
 import os
-import shutil
 
-required_conan_version = ">=1.43.0"
+required_conan_version = ">=1.53.0"
 
 
-class LibSigCppConanV2(ConanFile):
+class LibSigCppConan(ConanFile):
     name = "libsigcpp"
     homepage = "https://github.com/libsigcplusplus/libsigcplusplus"
     url = "https://github.com/conan-io/conan-center-index"
-    license = "LGPL-3.0"
+    license = "LGPL-3.0-only"
     description = "libsigc++ implements a typesafe callback system for standard C++."
-    topics = ("libsigcpp", "callback")
+    topics = ("callback")
 
     settings = "os", "arch", "compiler", "build_type"
     options = {
@@ -26,88 +29,81 @@ class LibSigCppConanV2(ConanFile):
         "fPIC": True,
     }
 
-    generators = "pkg_config"
-    short_paths = True
-
-    def validate(self):
-        if hasattr(self, "settings_build") and tools.cross_building(self):
-            raise ConanInvalidConfiguration("Cross-building not implemented")
-        if self.settings.compiler.get_safe("cppstd"):
-            tools.check_min_cppstd(self, 11)
-
-    @property
-    def _source_subfolder(self):
-        return "source_subfolder"
-
-    @property
-    def _build_subfolder(self):
-        return "build_subfolder"
-
     def config_options(self):
         if self.settings.os == "Windows":
             del self.options.fPIC
 
     def configure(self):
         if self.options.shared:
-            del self.options.fPIC
+            self.options.rm_safe("fPIC")
+
+    def layout(self):
+        basic_layout(self, src_folder="src")
+
+    def validate(self):
+        if self.settings.compiler.get_safe("cppstd"):
+            check_min_cppstd(self, 11)
 
     def build_requirements(self):
-        self.build_requires("meson/0.59.1")
-        self.build_requires("pkgconf/1.7.4")
+        self.tool_requires("meson/0.64.1")
 
     def source(self):
-        tools.get(
-            **self.conan_data["sources"][self.version],
-            strip_root=True,
-            destination=self._source_subfolder
-        )
+        get(self, **self.conan_data["sources"][self.version],
+            destination=self.source_folder, strip_root=True)
+
+    def generate(self):
+        env = VirtualBuildEnv(self)
+        env.generate()
+        tc = MesonToolchain(self)
+        tc.project_options["build-examples"] = "false"
+        tc.project_options["build-documentation"] = "false"
+        tc.generate()
+
+    def _patch_sources(self):
+        if not self.options.shared:
+            replace_in_file(
+                self, os.path.join(self.source_folder, "sigc++config.h.meson"),
+                "define SIGC_DLL 1", "undef SIGC_DLL",
+            )
 
     def build(self):
-        if not self.options.shared:
-            tools.replace_in_file(
-                os.path.join(self._source_subfolder, "sigc++config.h.meson"),
-                "define SIGC_DLL 1", "undef SIGC_DLL")
-        with tools.environment_append(tools.RunEnvironment(self).vars):
-            meson = self._configure_meson()
-            meson.build()
-
-    def _configure_meson(self):
+        self._patch_sources()
         meson = Meson(self)
-        defs = {}
-        defs["build-examples"] = "false"
-        defs["build-documentation"] = "false"
-        defs["default_library"] = "shared" if self.options.shared else "static"
-        meson.configure(
-            defs=defs,
-            build_folder=self._build_subfolder,
-            source_folder=self._source_subfolder,
-            pkg_config_paths=[self.install_folder],
-        )
-        return meson
+        meson.configure()
+        meson.build()
 
     def package(self):
-        self.copy("COPYING", dst="licenses", src=self._source_subfolder)
-        meson = self._configure_meson()
+        copy(self, "COPYING", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
+        meson = Meson(self)
         meson.install()
-        if self.settings.compiler == "Visual Studio":
-            tools.remove_files_by_mask(os.path.join(self.package_folder, "bin"), "*.pdb")
-            if not self.options.shared:
-                rename(self,
-                       os.path.join(self.package_folder, "lib", "libsigc-2.0.a"),
-                       os.path.join(self.package_folder, "lib", "sigc-2.0.lib"))
-
         for header_file in glob.glob(os.path.join(self.package_folder, "lib", "sigc++-2.0", "include", "*.h")):
-            shutil.move(
-                header_file,
-                os.path.join(self.package_folder, "include",
-                             "sigc++-2.0", os.path.basename(header_file))
-            )
-
-        for dir_to_remove in ["pkgconfig", "sigc++-2.0"]:
-            tools.rmdir(os.path.join(
-                self.package_folder, "lib", dir_to_remove))
+            dst = os.path.join(self.package_folder, "include", "sigc++-2.0", os.path.basename(header_file))
+            rename(self, header_file, dst)
+        rm(self, "*.pdb", os.path.join(self.package_folder, "bin"))
+        rmdir(self, os.path.join(self.package_folder, "lib", "pkgconfig"))
+        rmdir(self, os.path.join(self.package_folder, "lib", "sigc++-2.0"))
+        fix_apple_shared_install_name(self)
+        fix_msvc_libname(self)
 
     def package_info(self):
-        self.cpp_info.components["sigc++-2.0"].names["pkg_config"] = "sigc++-2.0"
-        self.cpp_info.components["sigc++-2.0"].includedirs.append(os.path.join("include", "sigc++-2.0"))
-        self.cpp_info.components["sigc++-2.0"].libs = ["sigc-2.0"]
+        self.cpp_info.set_property("pkg_config_name", "sigc++-2.0")
+        self.cpp_info.includedirs.append(os.path.join("include", "sigc++-2.0"))
+        self.cpp_info.libs = ["sigc-2.0"]
+
+def fix_msvc_libname(conanfile, remove_lib_prefix=True):
+    """remove lib prefix & change extension to .lib"""
+    from conan.tools.files import rename
+    from conan.tools.microsoft import is_msvc
+    import glob
+    import os
+    if not is_msvc(conanfile):
+        return
+    libdirs = getattr(conanfile.cpp.package, "libdirs")
+    for libdir in libdirs:
+        for ext in [".dll.a", ".dll.lib", ".a"]:
+            full_folder = os.path.join(conanfile.package_folder, libdir)
+            for filepath in glob.glob(os.path.join(full_folder, f"*{ext}")):
+                libname = os.path.basename(filepath)[0:-len(ext)]
+                if remove_lib_prefix and libname[0:3] == "lib":
+                    libname = libname[3:]
+                rename(conanfile, filepath, os.path.join(os.path.dirname(filepath), f"{libname}.lib"))

recipes/libsigcpp/2.x.x/test_package/CMakeLists.txt

@@ -1,12 +1,9 @@
-cmake_minimum_required(VERSION 3.6)
-project(test_package)
-
-include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
-conan_basic_setup(TARGET)
+cmake_minimum_required(VERSION 3.8)
+project(test_package LANGUAGES CXX)
 
 find_package(PkgConfig REQUIRED)
 pkg_search_module(SIGCPP IMPORTED_TARGET REQUIRED sigc++-2.0)
 
 add_executable(${PROJECT_NAME} test_package.cpp)
-target_link_libraries(${PROJECT_NAME} PkgConfig::SIGCPP)
-set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 11)
+target_link_libraries(${PROJECT_NAME} PRIVATE PkgConfig::SIGCPP)
+target_compile_features(${PROJECT_NAME} PRIVATE cxx_std_11)

recipes/libsigcpp/2.x.x/test_package/conanfile.py

@@ -1,20 +1,37 @@
-from conans import ConanFile, CMake, tools
+from conan import ConanFile
+from conan.tools.build import can_run
+from conan.tools.cmake import CMake, cmake_layout
+from conan.tools.env import Environment
 import os
 
 
 class TestPackageConan(ConanFile):
     settings = "os", "arch", "compiler", "build_type"
-    generators = "cmake", "pkg_config"
+    generators = "CMakeToolchain", "PkgConfigDeps", "VirtualBuildEnv", "VirtualRunEnv"
+    test_type = "explicit"
+
+    def layout(self):
+        cmake_layout(self)
+
+    def requirements(self):
+        self.requires(self.tested_reference_str)
 
     def build_requirements(self):
-        self.build_requires("pkgconf/1.7.4")
+        if not self.conf.get("tools.gnu:pkg_config", check_type=str):
+            self.tool_requires("pkgconf/1.9.3")
+
+    def generate(self):
+        # TODO: to remove once conan 1.55.0 deployed in c3i (see https://github.com/conan-io/conan/pull/12513)
+        env = Environment()
+        env.prepend_path("PKG_CONFIG_PATH", self.generators_folder)
+        env.vars(self).save_script("conanbuild_pkg_config_path")
 
     def build(self):
         cmake = CMake(self)
         cmake.configure()
         cmake.build()
 
     def test(self):
-        if not tools.cross_building(self):
-            bin_path = os.path.join("bin", "test_package")
-            self.run(bin_path, run_environment=True)
+        if can_run(self):
+            bin_path = os.path.join(self.cpp.build.bindirs[0], "test_package")
+            self.run(bin_path, env="conanrun")

recipes/libsigcpp/2.x.x/test_v1_package/CMakeLists.txt

@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.1)
+project(test_package)
+
+include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
+conan_basic_setup(TARGETS)
+
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../test_package
+                 ${CMAKE_CURRENT_BINARY_DIR}/test_package)

recipes/libsigcpp/2.x.x/test_v1_package/conanfile.py

@@ -0,0 +1,20 @@
+from conans import ConanFile, CMake, tools
+import os
+
+
+class TestPackageConan(ConanFile):
+    settings = "os", "arch", "compiler", "build_type"
+    generators = "cmake", "pkg_config"
+
+    def build_requirements(self):
+        self.build_requires("pkgconf/1.9.3")
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+
+    def test(self):
+        if not tools.cross_building(self):
+            bin_path = os.path.join("bin", "test_package")
+            self.run(bin_path, run_environment=True)

recipes/libsigcpp/3.x.x/conandata.yml

@@ -8,7 +8,5 @@ sources:
 patches:
   "3.0.7":
     - patch_file: "patches/3.0.7-0001-libsigcpp.patch"
-      base_path: "source_subfolder"
   "3.0.0":
     - patch_file: "patches/3.0.0-0001-libsigcpp.patch"
-      base_path: "source_subfolder"