[question] How to explicitly pass a build directory to `CMake.build()`? about conan HOT 12 CLOSED

# -*- coding: utf-8 -*-
import os
from conan import ConanFile
from conan.tools.cmake import CMake
from conan.tools.files import unzip, patch, chdir, replace_in_file, mkdir, load, save, copy
import shutil


class ZlibConan(ConanFile):
    name = "zlib"
    version = "1.2.11"
    url = "https://github.com/conan-io/conan-center-index"
    homepage = "https://zlib.net"
    license = "Zlib"
    description = ("A Massively Spiffy Yet Delicately Unobtrusive Compression Library "
                   "(Also Free, Not to Mention Unencumbered by Patents)")
    settings = "os", "arch", "compiler", "build_type"
    options = {"shared": [True, False],
               "fPIC": [True, False],
               "minizip": [True, False],
               "os_version": ["linux", "windows", "other"],
               }
    default_options = {"shared": False, "fPIC": True, "minizip": True}
    exports_sources = ["zlib-{}.tar.gz".format(version),
                       "CMakeLists.txt",
                       "CMakeLists_minizip.txt",
                       "patches/**"]
    generators = "CMakeDeps", "CMakeToolchain"
    source_url = "https://zlib.net/zlib-1.2.11.tar.gz"
    _source_subfolder = "source_subfolder"
    topics = ("conan", "zlib", "compression")
    short_paths = True
    build_requires = "cmake_installer/3.29.3"

    #---------------------------------------ZlibConan methods (not Conan API)----------------------------------------

    # Called by build(). Returns the name of the archive containing the zlib source code.
    @property
    def _source_zip_filename(self):
        return "zlib-{}.tar.gz".format(self.version)

    # Called by _build_zlib().
    def _build_zlib_cmake(self):
        cmake = CMake(self)
        #cmake.configure(build_dir=".")
        cmake.configure()
        # we need to build only libraries without test example/example64 and minigzip/minigzip64
        make_target = "zlib" if self.options.shared else "zlibstatic"
        #cmake.build(build_dir=".", target=make_target)
        cmake.build(target=make_target)

    # Called by build().
    def _build_zlib(self):

        # Apply patches.  These are changes to the source code applied in the build diretory 
        # (the original source files remain unchanged in the source repository).
        # See conandata.yml file that comes along this recipe in the source repository for info
        # on the patches to be applied.
        patches = self.conan_data["patches"][self.version]
        for p in patches:
            patch(self, base_path=p["base_path"], patch_file=p["patch_file"])

        with chdir(self, self._source_subfolder):
            # https://github.com/madler/zlib/issues/268
            replace_in_file(self, 'gzguts.h',
                                  '#if defined(_WIN32) || defined(__CYGWIN__)',
                                  '#if defined(_WIN32) || defined(__MINGW32__)')

            is_apple_clang12 = self.settings.compiler == "apple-clang" and tools.Version(self.settings.compiler.version) >= "12.0"
            if not is_apple_clang12:
                for filename in ['zconf.h', 'zconf.h.cmakein', 'zconf.h.in']:
                    replace_in_file(self, filename,
                                          '#ifdef HAVE_UNISTD_H    '
                                          '/* may be set to #if 1 by ./configure */',
                                          '#if defined(HAVE_UNISTD_H) && (1-HAVE_UNISTD_H-1 != 0)')
                    replace_in_file(self, filename,
                                          '#ifdef HAVE_STDARG_H    '
                                          '/* may be set to #if 1 by ./configure */',
                                          '#if defined(HAVE_STDARG_H) && (1-HAVE_STDARG_H-1 != 0)')
            #mkdir(self, "_build")
            #with chdir(self, "_build"): # this _build directory stays empty...
                #self._build_zlib_cmake()
            self._build_zlib_cmake()

    # Called by build().
    def _build_minizip(self):
        minizip_dir = os.path.join(self._source_subfolder, 'contrib', 'minizip')
        os.rename(os.path.join(self.source_folder, "CMakeLists_minizip.txt"), os.path.join(minizip_dir, 'CMakeLists.txt'))
        with chdir(self, minizip_dir):
            cmake = CMake(self)
            # It is necessary to pass minizip's build directory as cmake.configure() tries to build in zlib's own build directory
            # resulting in a CMake error. 
            # https://stackoverflow.com/questions/18826789/cmake-how-to-set-the-build-directory-to-be-different-than-source-directory
            # Is is also necessary to explicitly pass where conan_toochain.cmake used to bild main zlib is.
            # Somehow CMAKE_BUILD_TYPE is also not being set for the minizip library (Conan is supposed to do that but it doesn't).
            # This is somewhat messy in Conan 2.  In Conan 1 it was simpler.
            cmake.configure(build_script_folder=os.path.join(self.build_folder, self._source_subfolder, 'contrib', 'minizip'),
                            cli_args=["-B\""+os.path.join(self.build_folder, self._source_subfolder, 'contrib', 'minizip')+"\"",
                                      "-DCMAKE_TOOLCHAIN_FILE=\""+os.path.join(self.build_folder, 'conan_toolchain.cmake')+"\"",
                                      "-DCMAKE_BUILD_TYPE="+str(self.settings.build_type)])
            with chdir(self, os.path.join(self.build_folder, self._source_subfolder, 'contrib', 'minizip')):
                #cmake.build(cli_args=["--build \""+os.path.join(self.build_folder, self._source_subfolder, 'contrib', 'minizip')+"\""])
                cmake.build()
            cmake.install()

    # Called by package().
    # The different toolsets create different library names, so this method standardizes them.
    def _rename_libraries(self):
        if self.settings.os == "Windows":
            lib_path = os.path.join(self.package_folder, "lib")
            suffix = "d" if self.settings.build_type == "Debug" else ""

            if self.options.shared:
                #if self.settings.compiler == "Visual Studio":
                if self.settings.compiler == "msvc":
                    current_lib = os.path.join(lib_path, "zlib%s.lib" % suffix)
                    os.rename(current_lib, os.path.join(lib_path, "zlib.lib"))
            else:  # static libaries enabled (self.options.shared==False)
                #if self.settings.compiler == "Visual Studio":
                if self.settings.compiler == "msvc":
                    current_lib = os.path.join(lib_path, "zlibstatic%s.lib" % suffix)
                    os.rename(current_lib, os.path.join(lib_path, "zlib.lib"))
                elif self.settings.compiler == "gcc":
                    if self.settings.os != "Windows" or not self.settings.os.subsystem:
                        current_lib = os.path.join(lib_path, "libzlibstatic.a")
                        os.rename(current_lib, os.path.join(lib_path, "libzlib.a"))
                elif self.settings.compiler == "clang":
                    current_lib = os.path.join(lib_path, "zlibstatic.lib")
                    os.rename(current_lib, os.path.join(lib_path, "zlib.lib"))


    #---------------------------------------Methods of ConanFile's interface----------------------------------------
    def config_options(self):
        if self.settings.os == "Windows":
            del self.options.fPIC

    def configure(self):
        del self.settings.compiler.cppstd
        if self.settings.os == "Windows":
            self.options.os_version = "windows"
        elif self.settings.os == "Linux":
            del self.settings.compiler.libcxx
            self.options.os_version = "linux"
        else:
            del self.settings.compiler.libcxx
            self.options.os_version = "other"

#    def source(self):
#        self.output.info("Source code was exported (copied) with the recipe.")
#        self.output.info("From here: {}".format(self.source_url))

    def build(self):
        unzip(self, filename=os.path.join(self.source_folder, self._source_zip_filename), destination=self.build_folder, keep_permissions=True)
        shutil.move("zlib-{}".format(self.version), self._source_subfolder)
        self._build_zlib()
        if self.options.minizip:
            self._build_minizip()

    def package(self):
        # Extract the License/s from the header to a file
        with chdir(self, os.path.join(self.source_folder, self._source_subfolder)):
            tmp = load(self, "zlib.h")
            license_contents = tmp[2:tmp.find("*/", 1)]
            save(self, "LICENSE", license_contents)

        # Copy the license files
        copy(self, pattern="LICENSE", src=self._source_subfolder, dst="licenses")

        # Copy headers
        for header in ["*zlib.h", "*zconf.h"]:
            copy(self, pattern=header, dst="include", src=self._source_subfolder, keep_path=False)
            copy(self, pattern=header, dst="include", src="_build", keep_path=False)

        # Copying static and dynamic libs
        build_dir = os.path.join(self._source_subfolder, "_build")
        if self.options.shared:
            copy(self, pattern="*.dylib*", dst="lib", src=build_dir, keep_path=False, symlinks=True)
            copy(self, pattern="*.so*", dst="lib", src=build_dir, keep_path=False, symlinks=True)
            copy(self, pattern="*.dll", dst="bin", src=build_dir, keep_path=False)
            copy(self, pattern="*.dll.a", dst="lib", src=build_dir, keep_path=False)
        else:
            copy(self, pattern="*.a", dst="lib", src=build_dir, keep_path=False)
        copy(self, pattern="*.lib", dst="lib", src=build_dir, keep_path=False)

        self._rename_libraries()

    def package_info(self):
        self.cpp_info.libs.append("zlib" if self.settings.os == "Windows" and not self.settings.os.subsystem else "z")
        if self.options.minizip:
            self.cpp_info.libs.append('minizip')
            if self.options.shared:
                self.cpp_info.defines.append('MINIZIP_DLL')
        self.cpp_info.name = "zlib"