CMake Conan 2.0 compatibility

recipes/cmake/3.x.x/conanfile.py

@@ -1,20 +1,23 @@
-import os
-from conan import ConanFile
+from conan import ConanFile, conan_version
+from conan.tools.files import chdir, copy, rmdir, get, replace_in_file
+from conan.tools.cmake import CMakeToolchain, CMake, cmake_layout
+from conan.tools.gnu import AutotoolsToolchain, Autotools
+from conan.tools.build import build_jobs, cross_building, check_min_cppstd
 from conan.tools.scm import Version
-from conan.tools.files import rmdir, get
-from conans import tools, AutoToolsBuildEnvironment, CMake
-from conan.errors import ConanInvalidConfiguration, ConanException
+from conan.errors import ConanInvalidConfiguration
+from conan.errors import ConanException
+import os
 
-required_conan_version = ">=1.49.0"
+required_conan_version = ">=1.52.0"
 
 class CMakeConan(ConanFile):
     name = "cmake"
+    package_type = "application"
     description = "Conan installer for CMake"
     topics = ("cmake", "build", "installer")
     url = "https://github.com/conan-io/conan-center-index"
     homepage = "https://github.com/Kitware/CMake"
     license = "BSD-3-Clause"
-    generators = "cmake"
     settings = "os", "arch", "compiler", "build_type"
 
     options = {
@@ -26,9 +29,6 @@ class CMakeConan(ConanFile):
         "bootstrap": False,
     }
 
-    _source_subfolder = "source_subfolder"
-    _cmake = None
-
     def config_options(self):
         if self.settings.os == "Windows":
             self.options.with_openssl = False
@@ -38,15 +38,15 @@ def requirements(self):
             self.requires("openssl/1.1.1q")
 
     def validate(self):
-        if self.settings.os == "Macos" and self.settings.arch == "x86":
+        if self.info.settings.os == "Macos" and self.info.settings.arch == "x86":
             raise ConanInvalidConfiguration("CMake does not support x86 for macOS")
 
-        if self.settings.os == "Windows" and self.options.bootstrap:
+        if self.info.settings.os == "Windows" and self.info.options.bootstrap:
             raise ConanInvalidConfiguration("CMake does not support bootstrapping on Windows")
 
         minimal_cpp_standard = "11"
-        if self.settings.compiler.cppstd:
-            tools.check_min_cppstd(self, minimal_cpp_standard)
+        if self.info.settings.get_safe("compiler.cppstd"):
+            check_min_cppstd(self, minimal_cpp_standard)
 
         minimal_version = {
             "gcc": "4.8",
@@ -55,85 +55,89 @@ def validate(self):
             "Visual Studio": "14",
         }
 
-        compiler = str(self.settings.compiler)
+        compiler = str(self.info.settings.compiler)
         if compiler not in minimal_version:
-            self.output.warn(
+            self.output.warning(
                 "{} recipe lacks information about the {} compiler standard version support".format(self.name, compiler))
-            self.output.warn(
+            self.output.warning(
                 "{} requires a compiler that supports at least C++{}".format(self.name, minimal_cpp_standard))
             return
 
-        version = Version(self.settings.compiler.version)
+        version = Version(self.info.settings.compiler.version)
         if version < minimal_version[compiler]:
             raise ConanInvalidConfiguration(
                 "{} requires a compiler that supports at least C++{}".format(self.name, minimal_cpp_standard))
 
+    def layout(self):
+        cmake_layout(self, src_folder="src")
+
     def source(self):
-        get(self, **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 _configure_cmake(self):
-        if not self._cmake:
-            self._cmake = CMake(self)
+    def generate(self):
+        if self.info.options.bootstrap:
+            tc = AutotoolsToolchain(self)
+            tc.generate()
+        else:
+            tc = CMakeToolchain(self)
             if not self.settings.compiler.cppstd:
-                self._cmake.definitions["CMAKE_CXX_STANDARD"] = 11
-            self._cmake.definitions["CMAKE_BOOTSTRAP"] = False
+                tc.variables["CMAKE_CXX_STANDARD"] = 11
+            tc.variables["CMAKE_BOOTSTRAP"] = False
             if self.settings.os == "Linux":
-                self._cmake.definitions["CMAKE_USE_OPENSSL"] = self.options.with_openssl
+                tc.variables["CMAKE_USE_OPENSSL"] = self.options.with_openssl
                 if self.options.with_openssl:
-                    self._cmake.definitions["OPENSSL_USE_STATIC_LIBS"] = not self.options["openssl"].shared
-            if tools.cross_building(self):
-                self._cmake.definitions["HAVE_POLL_FINE_EXITCODE"] = ''
-                self._cmake.definitions["HAVE_POLL_FINE_EXITCODE__TRYRUN_OUTPUT"] = ''
-            self._cmake.configure(source_folder=self._source_subfolder)
-
-        return self._cmake
+                    openssl = self.dependencies["openssl"]
+                    tc.variables["OPENSSL_USE_STATIC_LIBS"] = not openssl.options.shared
+            if cross_building(self):
+                tc.variables["HAVE_POLL_FINE_EXITCODE"] = ''
+                tc.variables["HAVE_POLL_FINE_EXITCODE__TRYRUN_OUTPUT"] = ''
+            tc.generate()
 
     def build(self):
-        if self.options.bootstrap:
-            with tools.chdir(self._source_subfolder):
-                self.run(['./bootstrap', '--prefix={}'.format(self.package_folder), '--parallel={}'.format(tools.cpu_count())])
-                autotools = AutoToolsBuildEnvironment(self)
+        if self.info.options.bootstrap:
+            with chdir(self, self.source_folder):
+                self.run('./bootstrap --prefix="" --parallel={}'.format(build_jobs(self)))
+                autotools = Autotools(self)
                 autotools.make()
         else:
-            tools.replace_in_file(os.path.join(self._source_subfolder, "CMakeLists.txt"),
-                                  "project(CMake)",
-                                  "project(CMake)\ninclude(\"{}/conanbuildinfo.cmake\")\nconan_basic_setup(NO_OUTPUT_DIRS)".format(
-                                      self.install_folder.replace("\\", "/")))
             if self.settings.os == "Linux":
-                tools.replace_in_file(os.path.join(self._source_subfolder, "Utilities", "cmcurl", "CMakeLists.txt"),
+                replace_in_file(self, os.path.join(self.source_folder, "Utilities", "cmcurl", "CMakeLists.txt"),
                                       "list(APPEND CURL_LIBS ${OPENSSL_LIBRARIES})",
                                       "list(APPEND CURL_LIBS ${OPENSSL_LIBRARIES} ${CMAKE_DL_LIBS} pthread)")
-
-            cmake = self._configure_cmake()
+            cmake = CMake(self)
+            cmake.configure()
             cmake.build()
 
     def package(self):
-        self.copy("Copyright.txt", dst="licenses", src=self._source_subfolder)
+        copy(self, "Copyright.txt", self.source_folder, os.path.join(self.package_folder, "licenses"), keep_path=False)
         if self.options.bootstrap:
-            with tools.chdir(self._source_subfolder):
-                autotools = AutoToolsBuildEnvironment(self)
+            with chdir(self, self.source_folder):
+                autotools = Autotools(self)
                 autotools.install()
         else:
-            cmake = self._configure_cmake()
+            cmake = CMake(self)
+            cmake.configure()
             cmake.install()
         rmdir(self, os.path.join(self.package_folder, "doc"))
 
     def package_id(self):
         del self.info.settings.compiler
 
     def package_info(self):
-        module_version = "{}.{}".format(Version(self.version).major, Version(self.version).minor)
-
-        bindir = os.path.join(self.package_folder, "bin")
-        self.output.info("Appending PATH environment variable: {}".format(bindir))
-        self.env_info.PATH.append(bindir)
-
         self.buildenv_info.prepend_path("CMAKE_ROOT", self.package_folder)
-        self.env_info.CMAKE_ROOT = self.package_folder
+        self.runenv_info.define_path("CMAKE_ROOT", self.package_folder)
+        module_version = "{}.{}".format(Version(self.version).major, Version(self.version).minor)
         mod_path = os.path.join(self.package_folder, "share", f"cmake-{module_version}", "Modules")
         self.buildenv_info.prepend_path("CMAKE_MODULE_PATH", mod_path)
-        self.env_info.CMAKE_MODULE_PATH = mod_path
+        self.runenv_info.define_path("CMAKE_MODULE_PATH", mod_path)
         if not os.path.exists(mod_path):
             raise ConanException("Module path not found: %s" % mod_path)
 
         self.cpp_info.includedirs = []
+
+        # TODO remove once conan v2 is the only support and recipes have been migrated
+        if Version(conan_version).major < 2:
+            bindir = os.path.join(self.package_folder, "bin")
+            self.output.info("Appending PATH environment variable: {}".format(bindir))
+            self.runenv_info.append_path("PATH", bindir)

recipes/cmake/3.x.x/test_package/conanfile.py

@@ -1,7 +1,7 @@
-import os
 from six import StringIO
-from conan import ConanFile
+from conan import ConanFile, conan_version
 from conan.tools.build import can_run
+from conan.tools.scm import Version
 
 
 class TestPackageConan(ConanFile):
@@ -14,10 +14,14 @@ def requirements(self):
     def test(self):
         if can_run(self):
             output = StringIO()
-            self.run("cmake --version", env="conanrun", output=output)
+            # Third arg to self.run renamed "stdout" in Conan 2.0 but 1.x linter doesn't like it
+            self.run("cmake --version", output, env="conanrun")
             output_str = str(output.getvalue())
             self.output.info("Installed version: {}".format(output_str))
-            require_version = str(self.deps_cpp_info["cmake"].version)
+            if Version(conan_version).major < 2:
+                require_version = str(self.deps_cpp_info["cmake"].version)
+            else:
+                require_version = str(self.dependencies["cmake"].ref.version)
             self.output.info("Expected version: {}".format(require_version))
             assert_cmake_version = "cmake version %s" % require_version
             assert(assert_cmake_version in output_str)