More layouts: Generators folder, CMake Toolchain, Editable packages and more

conan/tools/cmake/cmake.py

@@ -10,7 +10,6 @@
 from conan.tools.microsoft.msbuild import msbuild_verbosity_cmd_line_arg, \
     msbuild_max_cpu_count_cmd_line_arg
 from conans.client import tools
-
 from conans.client.tools.files import chdir
 from conans.client.tools.oss import cpu_count, args_to_string
 from conans.errors import ConanException
@@ -62,17 +61,16 @@ class CMake(object):
     are passed to the command line, plus the ``--config Release`` for builds in multi-config
     """
 
-    def __init__(self, conanfile, build_folder=None, parallel=True):
+    def __init__(self, conanfile, parallel=True):
         _validate_recipe(conanfile)
 
         # Store a reference to useful data
         self._conanfile = conanfile
         self._parallel = parallel
-
         self._generator = None
         if os.path.exists(CONAN_TOOLCHAIN_ARGS_FILE):
             self._generator = json.loads(load(CONAN_TOOLCHAIN_ARGS_FILE))["cmake_generator"]
-        self._build_folder = build_folder
+
         self._cmake_program = "cmake"  # Path to CMake should be handled by environment
 
     def configure(self, source_folder=None):
@@ -85,12 +83,11 @@ def configure(self, source_folder=None):
             source = os.path.join(self._conanfile.source_folder, source_folder)
 
         build_folder = self._conanfile.build_folder
-        if self._build_folder:
-            build_folder = os.path.join(self._conanfile.build_folder, self._build_folder)
+        generator_folder = self._conanfile.generators_folder
 
         mkdir(build_folder)
         arg_list = '-DCMAKE_TOOLCHAIN_FILE="{}" -DCMAKE_INSTALL_PREFIX="{}" "{}"'.format(
-            CMakeToolchain.filename,
+            os.path.join(generator_folder, CMakeToolchain.filename).replace("\\", "/"),
             self._conanfile.package_folder.replace("\\", "/"),
             source)
 
@@ -107,9 +104,6 @@ def configure(self, source_folder=None):
 
     def _build(self, build_type=None, target=None):
         bf = self._conanfile.build_folder
-        if self._build_folder:
-            bf = os.path.join(self._conanfile.build_folder, self._build_folder)
-
         is_multi = is_multi_configuration(self._generator)
         if build_type and not is_multi:
             self._conanfile.output.error("Don't specify 'build_type' at build time for "

conan/tools/cmake/toolchain.py

@@ -298,10 +298,10 @@ class IOSSystemBlock(Block):
         set(CMAKE_SYSTEM_VERSION {{ CMAKE_SYSTEM_VERSION }})
         set(DEPLOYMENT_TARGET ${CONAN_SETTINGS_HOST_MIN_OS_VERSION})
         # Set the architectures for which to build.
-        set(CMAKE_OSX_ARCHITECTURES {{ CMAKE_OSX_ARCHITECTURES }})
+        set(CMAKE_OSX_ARCHITECTURES {{ CMAKE_OSX_ARCHITECTURES }} CACHE STRING "" FORCE)
         # Setting CMAKE_OSX_SYSROOT SDK, when using Xcode generator the name is enough
         # but full path is necessary for others
-        set(CMAKE_OSX_SYSROOT {{ CMAKE_OSX_SYSROOT }})
+        set(CMAKE_OSX_SYSROOT {{ CMAKE_OSX_SYSROOT }} CACHE STRING "" FORCE)
         """)
 
     def _get_architecture(self):
@@ -342,8 +342,8 @@ def context(self):
         host_sdk_name = self._apple_sdk_name()
 
         # TODO: Discuss how to handle CMAKE_OSX_DEPLOYMENT_TARGET to set min-version
-        # add a setting? check an option and if not present set a default?
-        # default to os.version?
+        #       add a setting? check an option and if not present set a default?
+        #       default to os.version?
         ctxt_toolchain = {
             "CMAKE_OSX_ARCHITECTURES": host_architecture,
             "CMAKE_SYSTEM_NAME": host_os,
@@ -358,12 +358,12 @@ class FindConfigFiles(Block):
         {% if find_package_prefer_config %}
         set(CMAKE_FIND_PACKAGE_PREFER_CONFIG {{ find_package_prefer_config }})
         {% endif %}
-        # To support the cmake_find_package generators
+        # To support the generators based on find_package()
         {% if cmake_module_path %}
-        set(CMAKE_MODULE_PATH {{ cmake_module_path }} ${CMAKE_MODULE_PATH})
+        set(CMAKE_MODULE_PATH "{{ cmake_module_path }}" ${CMAKE_MODULE_PATH})
         {% endif %}
         {% if cmake_prefix_path %}
-        set(CMAKE_PREFIX_PATH {{ cmake_prefix_path }} ${CMAKE_PREFIX_PATH})
+        set(CMAKE_PREFIX_PATH "{{ cmake_prefix_path }}" ${CMAKE_PREFIX_PATH})
         {% endif %}
         {% if android_prefix_path %}
         set(CMAKE_FIND_ROOT_PATH {{ android_prefix_path }} ${CMAKE_FIND_ROOT_PATH})
@@ -373,8 +373,6 @@ class FindConfigFiles(Block):
     def context(self):
         # To find the generated cmake_find_package finders
         # TODO: Change this for parameterized output location of CMakeDeps
-        cmake_prefix_path = "${CMAKE_CURRENT_LIST_DIR}"
-        cmake_module_path = "${CMAKE_CURRENT_LIST_DIR}"
         find_package_prefer_config = "ON"  # assume ON by default if not specified in conf
         prefer_config = self._conanfile.conf["tools.cmake.cmaketoolchain:find_package_prefer_config"]
         if prefer_config is not None and prefer_config.lower() in ("false", "0", "off"):
@@ -383,8 +381,8 @@ def context(self):
         os_ = self._conanfile.settings.get_safe("os")
         android_prefix = "${CMAKE_CURRENT_LIST_DIR}" if os_ == "Android" else None
         return {"find_package_prefer_config": find_package_prefer_config,
-                "cmake_prefix_path": cmake_prefix_path,
-                "cmake_module_path": cmake_module_path,
+                "cmake_prefix_path": "${CMAKE_CURRENT_LIST_DIR}",
+                "cmake_module_path": "${CMAKE_CURRENT_LIST_DIR}",
                 "android_prefix_path": android_prefix}
 
 

conan/tools/files/files.py

@@ -1,10 +1,10 @@
 import errno
 import os
 
+from conans.client.downloaders.download import run_downloader
+from conans.client.tools.files import unzip
 from conans.errors import ConanException
 from conans.util.files import decode_text, to_file_bytes
-from conans.client.tools.files import unzip
-from conans.client.downloaders.download import run_downloader
 
 
 def load(conanfile, path, binary=False, encoding="auto"):

conan/tools/layout/__init__.py

@@ -0,0 +1,98 @@
+import os
+
+from conan.tools.microsoft.msbuild import msbuild_arch
+from conans.client.file_copier import FileCopier
+from conans.errors import ConanException
+
+
+def clion_layout(conanfile):
+    if not conanfile.settings.get_safe("build_type"):
+        raise ConanException("The 'clion_layout' requires the 'build_type' setting")
+    base = "cmake-build-{}".format(str(conanfile.settings.build_type).lower())
+    conanfile.folders.build = base
+    conanfile.cpp.build.libdirs = ["."]
+    conanfile.folders.generators = os.path.join(base, "generators")
+    conanfile.folders.source = "."
+    conanfile.cpp.source.includedirs = ["."]
+
+
+def vs_layout(conanfile):
+    if not conanfile.settings.get_safe("build_type"):
+        raise ConanException("The 'vs_layout' requires the 'build_type' setting")
+    if not conanfile.settings.get_safe("arch"):
+        raise ConanException("The 'vs_layout' requires the 'arch' setting")
+
+    if conanfile.settings.arch != "x86":
+        arch = msbuild_arch(conanfile.settings.arch)
+        if not arch:
+            raise ConanException("The 'vs_layout' doesn't "
+                                 "work with the arch '{}'".format(conanfile.settings.arch))
+        base = "{}/{}".format(arch, str(conanfile.settings.build_type))
+    else:
+        base = str(conanfile.settings.build_type)
+
+    conanfile.folders.build = base
+    conanfile.cpp.build.libdirs = ["."]
+    conanfile.folders.generators = os.path.join(base, "generators")
+    conanfile.folders.source = "."
+    conanfile.cpp.source.includedirs = ["."]
+
+
+class LayoutPackager(object):
+
+    def __init__(self, conanfile):
+        self._conanfile = conanfile
+
+    def package(self):
+        cf = self._conanfile
+
+        # Check that the components declared in source/build are in package
+        cnames = set(cf.cpp.source.component_names)
+        cnames = cnames.union(set(cf.cpp.build.component_names))
+        if cnames.difference(set(cf.cpp.package.component_names)):
+            # TODO: Raise? Warning? Ignore?
+            raise ConanException("There are components declared in source_cpp_info.components"
+                                 " or in build_cpp_info.components that are not declared in"
+                                 " package_cpp_info.components")
+
+
+        if cnames:
+            for cname in cnames:
+                if cname in cf.cpp.source.components:
+                    self._package_cppinfo("source", cf.cpp.source.components[cname],
+                                                    cf.cpp.package.components[cname])
+                if cname in cf.cpp.build.components:
+                    self._package_cppinfo("build",  cf.cpp.build.components[cname],
+                                                    cf.cpp.package.components[cname])
+        else:  # No components declared
+            self._package_cppinfo("source", cf.cpp.source, cf.cpp.package)
+            self._package_cppinfo("build", cf.cpp.build, cf.cpp.package)
+
+    def _package_cppinfo(self, origin_name, origin_cppinfo, dest_cppinfo):
+        """
+        @param origin_name: one from ["source", "build"]
+        @param origin_cppinfo: cpp_info object of an origin (can be a component cppinfo too)
+        @param dest_cppinfo: cpp_info object of the package or a component from package
+        """
+        patterns_var = getattr(self._conanfile.patterns, origin_name)
+        base_folder = getattr(self._conanfile, "{}_folder".format(origin_name))
+        for var in ["include", "lib", "bin", "framework", "src", "build", "res"]:
+            dirs_var_name = "{}dirs".format(var)
+            origin_paths = getattr(origin_cppinfo, dirs_var_name)
+            if not origin_paths:
+                continue
+            patterns = getattr(patterns_var, var)
+            destinations = getattr(dest_cppinfo, dirs_var_name)
+            if not destinations:  # For example: Not declared "includedirs" in package.cpp_info
+                continue
+            if len(destinations) > 1:
+                # Check if there is only one possible destination at package, otherwise the
+                # copy would need to be done manually
+                err_msg = "The package has more than 1 cpp_info.{}, cannot package automatically"
+                raise ConanException(err_msg.format(dirs_var_name))
+
+            for d in origin_paths:
+                copier = FileCopier([os.path.join(base_folder, d)],
+                                    self._conanfile.folders.base_package)
+                for pattern in patterns:
+                    copier(pattern, dst=destinations[0])

conan/tools/microsoft/msbuild.py

@@ -18,18 +18,21 @@ def msbuild_max_cpu_count_cmd_line_arg(conanfile):
         return "/m:{}".format(max_cpu_count)
 
 
+def msbuild_arch(arch):
+    return {'x86': 'x86',
+            'x86_64': 'x64',
+            'armv7': 'ARM',
+            'armv8': 'ARM64'}.get(str(arch))
+
+
 class MSBuild(object):
     def __init__(self, conanfile):
         self._conanfile = conanfile
         self.build_type = conanfile.settings.get_safe("build_type")
-        msvc_arch = {'x86': 'x86',
-                     'x86_64': 'x64',
-                     'armv7': 'ARM',
-                     'armv8': 'ARM64'}
         # if platforms:
         #    msvc_arch.update(platforms)
         arch = conanfile.settings.get_safe("arch")
-        msvc_arch = msvc_arch.get(str(arch))
+        msvc_arch = msbuild_arch(arch)
         if conanfile.settings.get_safe("os") == "WindowsCE":
             msvc_arch = conanfile.settings.get_safe("os.platform")
         self.platform = msvc_arch
@@ -50,7 +53,7 @@ def command(self, sln):
 
     def build(self, sln):
         cmd = self.command(sln)
-        vcvars = os.path.join(self._conanfile.install_folder, "conanvcvars")
+        vcvars = os.path.join(self._conanfile.generators_folder, "conanvcvars")
         self._conanfile.run(cmd, env=["conanbuildenv", vcvars])
 
     @staticmethod

conan/tools/microsoft/msbuilddeps.py

@@ -99,8 +99,6 @@ def __init__(self, conanfile):
         self.configuration = conanfile.settings.build_type
         self.platform = {'x86': 'Win32',
                          'x86_64': 'x64'}.get(str(conanfile.settings.arch))
-        # TODO: this is ugly, improve this
-        self.output_path = os.getcwd()
         # ca_exclude section
         self.exclude_code_analysis = None
         ca_exclude = self._conanfile.conf["tools.microsoft.msbuilddeps:exclude_code_analysis"]
@@ -126,8 +124,7 @@ def generate(self):
             raise ConanException("MSBuildDeps.platform is None, it should have a value")
         generator_files = self._content()
         for generator_file, content in generator_files.items():
-            generator_file_path = os.path.join(self.output_path, generator_file)
-            save(generator_file_path, content)
+            save(generator_file, content)
 
     def _config_filename(self):
         # Default name
@@ -190,7 +187,8 @@ def _conf_props_file(self, dep_name, vars_props_name, deps):
         return content_multi
 
     def _dep_props_file(self, name, name_general, dep_props_filename, condition):
-        multi_path = os.path.join(self.output_path, name_general)
+        # Current directory is the generators_folder
+        multi_path = name_general
         if os.path.isfile(multi_path):
             content_multi = load(multi_path)
         else:
@@ -220,7 +218,8 @@ def _dep_props_file(self, name, name_general, dep_props_filename, condition):
     def _all_props_file(self, name_general, deps):
         """ this is a .props file including all declared dependencies
         """
-        multi_path = os.path.join(self.output_path, name_general)
+        # Current directory is the generators_folder
+        multi_path = name_general
         if os.path.isfile(multi_path):
             content_multi = load(multi_path)
         else:

conan/tools/microsoft/toolchain.py

@@ -33,7 +33,7 @@ def write_conanvcvars(conanfile):
             @echo off
             {}
             """.format(cvars))
-        save(CONAN_VCVARS_FILE, content)
+        save(os.path.join(conanfile.generators_folder, CONAN_VCVARS_FILE), content)
 
 
 def vs_ide_version(conanfile):
@@ -168,12 +168,12 @@ def format_macro(key, value):
                                   for k, v in self.compile_options.items())
         config_props = toolchain_file.format(preprocessor_definitions, runtime_library, cppstd,
                                              compile_options, toolset)
-        config_filepath = os.path.abspath(config_filename)
+        config_filepath = os.path.join(self._conanfile.generators_folder, config_filename)
         self._conanfile.output.info("MSBuildToolchain created %s" % config_filename)
         save(config_filepath, config_props)
 
     def _write_main_toolchain(self, config_filename, condition):
-        main_toolchain_path = os.path.abspath(self.filename)
+        main_toolchain_path = os.path.join(self._conanfile.generators_folder, self.filename)
         if os.path.isfile(main_toolchain_path):
             content = load(main_toolchain_path)
         else:

conans/client/cmd/build.py

@@ -8,9 +8,9 @@
 from conans.util.log import logger
 
 
-def cmd_build(app, conanfile_path, source_folder, build_folder, package_folder, install_folder,
-              test=False, should_configure=True, should_build=True, should_install=True,
-              should_test=True):
+def cmd_build(app, conanfile_path, base_path, source_folder, build_folder, package_folder,
+              install_folder, test=False, should_configure=True, should_build=True,
+              should_install=True, should_test=True):
     """ Call to build() method saved on the conanfile.py
     param conanfile_path: path to a conanfile.py
     """
@@ -41,10 +41,12 @@ def cmd_build(app, conanfile_path, source_folder, build_folder, package_folder,
     try:
         # FIXME: Conan 2.0 all these build_folder, source_folder will disappear
         #  Only base_path and conanfile_path will remain
-        conan_file.layout.set_base_build_folder(build_folder)
-        conan_file.layout.set_base_source_folder(source_folder)
-        conan_file.layout.set_base_package_folder(package_folder)
-        conan_file.layout.set_base_install_folder(install_folder)
+        conan_file.folders.set_base_build(build_folder)
+        conan_file.folders.set_base_source(source_folder)
+        conan_file.folders.set_base_package(package_folder)
+        conan_file.folders.set_base_generators(base_path)
+
+        conan_file.folders.set_base_install(install_folder)
 
         mkdir(conan_file.build_folder)
         os.chdir(conan_file.build_folder)

conans/client/cmd/create.py

@@ -42,7 +42,8 @@ def create(app, ref, graph_info, remotes, update, build_modes,
             deps_install(app=app,
                          ref_or_path=ref,
                          create_reference=ref,
-                         install_folder=None,  # Not output anything
+                         install_folder=None,  # Not output conaninfo etc
+                         base_folder=None,  # Not output generators
                          manifest_folder=manifest_folder,
                          manifest_verify=manifest_verify,
                          manifest_interactive=manifest_interactive,
@@ -67,7 +68,8 @@ def create(app, ref, graph_info, remotes, update, build_modes,
                                      % (str(ref), str(e)))
 
         else:
-            install_build_and_test(app, test_conanfile_path, ref, graph_info, remotes, update,
+            install_build_and_test(app, test_conanfile_path,
+                                   ref, graph_info, remotes, update,
                                    build_modes=build_modes,
                                    manifest_folder=manifest_folder,
                                    manifest_verify=manifest_verify,
@@ -79,7 +81,8 @@ def create(app, ref, graph_info, remotes, update, build_modes,
         deps_install(app=app,
                      ref_or_path=ref,
                      create_reference=ref,
-                     install_folder=None,  # Not output anything
+                     install_folder=None,  # Not output infos etc
+                     base_folder=None,  # Not output generators
                      manifest_folder=manifest_folder,
                      manifest_verify=manifest_verify,
                      manifest_interactive=manifest_interactive,

conans/client/cmd/export_pkg.py

@@ -54,10 +54,10 @@ def _init_conanfile_infos():
     recipe_hash = layout.recipe_manifest().summary_hash
     conanfile.info.recipe_hash = recipe_hash
     conanfile.develop = True
-    conanfile.layout.set_base_build_folder(build_folder)
-    conanfile.layout.set_base_source_folder(source_folder)
-    conanfile.layout.set_base_package_folder(dest_package_folder)
-    conanfile.layout.set_base_install_folder(install_folder)
+    conanfile.folders.set_base_build(build_folder)
+    conanfile.folders.set_base_source(source_folder)
+    conanfile.folders.set_base_package(dest_package_folder)
+    conanfile.folders.set_base_install(install_folder)
 
     with layout.set_dirty_context_manager(pref):
         if package_folder: