fix generators_folder relative path to conanfile

conan/tools/cmake/cmake.py

@@ -141,7 +141,20 @@ def install(self, build_type=None):
         if not self._conanfile.should_install:
             return
         mkdir(self._conanfile, self._conanfile.package_folder)
-        self._build(build_type=build_type, target="install")
+
+        bt = build_type or self._conanfile.settings.get_safe("build_type")
+        if not bt:
+            raise ConanException("build_type setting should be defined.")
+        is_multi = is_multi_configuration(self._generator)
+        build_config = "--config {}".format(bt) if bt and is_multi else ""
+
+        pkg_folder = args_to_string([self._conanfile.package_folder.replace("\\", "/")])
+        build_folder = args_to_string([self._conanfile.build_folder])
+        arg_list = ["--install", build_folder, build_config, "--prefix", pkg_folder]
+        arg_list = " ".join(filter(None, arg_list))
+        command = "%s %s" % (self._cmake_program, arg_list)
+        self._conanfile.output.info("CMake command: %s" % command)
+        self._conanfile.run(command)
 
     def test(self, build_type=None, target=None, output_on_failure=False):
         if not self._conanfile.should_test:

conans/client/cmd/build.py

@@ -41,12 +41,19 @@ def cmd_build(app, conanfile_path, base_path, source_folder, build_folder, packa
     try:
         # FIXME: Conan 2.0 all these build_folder, source_folder will disappear
         #  Only base_path and conanfile_path will remain
-        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)
+        if hasattr(conan_file, "layout") and not test:
+            conanfile_folder = os.path.dirname(conanfile_path)
+            conan_file.folders.set_base_build(conanfile_folder)
+            conan_file.folders.set_base_source(conanfile_folder)
+            conan_file.folders.set_base_package(conanfile_folder)
+            conan_file.folders.set_base_generators(conanfile_folder)
+            conan_file.folders.set_base_install(conanfile_folder)
+        else:
+            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

@@ -52,7 +52,8 @@ def create(app, ref, graph_info, remotes, update, build_modes,
                          build_modes=build_modes,
                          update=update,
                          keep_build=keep_build,
-                         recorder=recorder)
+                         recorder=recorder,
+                         conanfile_path=os.path.dirname(test_conanfile_path))
             out.info("Executing test_package %s" % repr(ref))
             try:
                 graph_info.graph_lock.relax()

conans/client/cmd/export_pkg.py

@@ -10,7 +10,7 @@
 
 
 def export_pkg(app, recorder, full_ref, source_folder, build_folder, package_folder, install_folder,
-               graph_info, force, remotes):
+               graph_info, force, remotes, source_conanfile_path):
     ref = full_ref.copy_clear_rev()
     cache, output, hook_manager = app.cache, app.out, app.hook_manager
     graph_manager = app.graph_manager
@@ -54,13 +54,22 @@ def _init_conanfile_infos():
     recipe_hash = layout.recipe_manifest().summary_hash
     conanfile.info.recipe_hash = recipe_hash
     conanfile.develop = True
-    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)
+    if hasattr(conanfile, "layout"):
+        conanfile_folder = os.path.dirname(source_conanfile_path)
+        conanfile.folders.set_base_build(conanfile_folder)
+        conanfile.folders.set_base_source(conanfile_folder)
+        conanfile.folders.set_base_package(dest_package_folder)
+        conanfile.folders.set_base_install(conanfile_folder)
+        conanfile.folders.set_base_generators(conanfile_folder)
+    else:
+        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:
+            # FIXME: To be removed in 2.0
             prev = packager.export_pkg(conanfile, package_id, package_folder, hook_manager,
                                        conan_file_path, ref)
         else:

conans/client/cmd/test.py

@@ -37,7 +37,10 @@ def install_build_and_test(app, conanfile_abs_path, reference, graph_info,
                      manifest_interactive=manifest_interactive,
                      keep_build=keep_build,
                      recorder=recorder,
-                     require_overrides=require_overrides)
+                     require_overrides=require_overrides,
+                     conanfile_path=os.path.dirname(conanfile_abs_path),
+                     test=True  # To keep legacy test_package_layout
+                     )
         cmd_build(app, conanfile_abs_path, test_build_folder,
                   source_folder=base_folder, build_folder=test_build_folder,
                   package_folder=os.path.join(test_build_folder, "package"),

conans/client/conan_api.py

@@ -453,7 +453,7 @@ def export_pkg(self, conanfile_path, name, channel, source_folder=None, build_fo
             export_pkg(self.app, recorder, new_ref, source_folder=source_folder,
                        build_folder=build_folder, package_folder=package_folder,
                        install_folder=install_folder, graph_info=graph_info, force=force,
-                       remotes=remotes)
+                       remotes=remotes, source_conanfile_path=conanfile_path)
             if lockfile_out:
                 lockfile_out = _make_abs_path(lockfile_out, cwd)
                 graph_lock_file = GraphLockFile(graph_info.profile_host, graph_info.profile_build,
@@ -617,7 +617,8 @@ def install(self, path="", name=None, version=None, user=None, channel=None,
                          generators=generators,
                          no_imports=no_imports,
                          recorder=recorder,
-                         require_overrides=require_overrides)
+                         require_overrides=require_overrides,
+                         conanfile_path=os.path.dirname(conanfile_path))
 
             if lockfile_out:
                 lockfile_out = _make_abs_path(lockfile_out, cwd)
@@ -796,10 +797,19 @@ def package(self, path, build_folder, package_folder, source_folder=None, instal
         else:
             package_folder = _make_abs_path(package_folder, cwd, default=build_folder)
 
-        conanfile.folders.set_base_build(build_folder)
-        conanfile.folders.set_base_source(source_folder)
-        conanfile.folders.set_base_package(package_folder)
-        conanfile.folders.set_base_install(install_folder)
+        if hasattr(conanfile, "layout"):
+            dir_path = os.path.dirname(conanfile_path)
+            conanfile.folders.set_base_generators(dir_path)
+            conanfile.folders.set_base_build(dir_path)
+            conanfile.folders.set_base_source(dir_path)
+            # FIXME: this is bad, but conanfile.folders.package=xxx is broken atm, cant be used
+            conanfile.folders.set_base_package(os.path.join(dir_path, "package"))
+            conanfile.folders.set_base_install(install_folder)
+        else:
+            conanfile.folders.set_base_build(build_folder)
+            conanfile.folders.set_base_source(source_folder)
+            conanfile.folders.set_base_package(package_folder)
+            conanfile.folders.set_base_install(install_folder)
 
         # Use the complete package layout for the local method
         if conanfile.folders.package:

conans/client/manager.py

@@ -22,7 +22,8 @@ def deps_install(app, ref_or_path, install_folder, base_folder, graph_info, remo
                  build_modes=None, update=False, manifest_folder=None, manifest_verify=False,
                  manifest_interactive=False, generators=None, no_imports=False,
                  create_reference=None, keep_build=False, recorder=None, lockfile_node_id=None,
-                 is_build_require=False, add_txt_generator=True, require_overrides=None):
+                 is_build_require=False, add_txt_generator=True, require_overrides=None,
+                 conanfile_path=None, test=None):
 
     """ Fetch and build all dependencies for the given reference
     @param app: The ConanApp instance with all collaborators
@@ -94,9 +95,14 @@ def deps_install(app, ref_or_path, install_folder, base_folder, graph_info, remo
                                      interactive=manifest_interactive)
         manifest_manager.print_log()
 
-    conanfile.folders.set_base_install(install_folder)
-    conanfile.folders.set_base_imports(install_folder)
-    conanfile.folders.set_base_generators(base_folder)
+    if hasattr(conanfile, "layout") and not test:
+        conanfile.folders.set_base_install(conanfile_path)
+        conanfile.folders.set_base_imports(conanfile_path)
+        conanfile.folders.set_base_generators(conanfile_path)
+    else:
+        conanfile.folders.set_base_install(install_folder)
+        conanfile.folders.set_base_imports(install_folder)
+        conanfile.folders.set_base_generators(base_folder)
 
     output = conanfile.output if root_node.recipe != RECIPE_VIRTUAL else out
 

conans/test/functional/layout/test_editable_cmake.py

@@ -22,10 +22,10 @@ def editable_cmake(generator):
            path=os.path.join(c.current_folder, "pkg"))
 
     def build_dep():
-        c.run("install .")
-        c.run("build .")
-        c.run("install . -s build_type=Debug")
-        c.run("build .")
+        c.run("install . -if=install_release")
+        c.run("build . -if=install_release")
+        c.run("install . -s build_type=Debug -if=install_debug")
+        c.run("build . -if=install_debug")
 
     with c.chdir("dep"):
         c.run("editable add . dep/0.1@")
@@ -94,10 +94,10 @@ def editable_cmake_exe(generator):
     c.save(pkg_cmake("dep", "0.1", exe=True), path=os.path.join(c.current_folder, "dep"))
 
     def build_dep():
-        c.run("install . -o dep:shared=True")
-        c.run("build .")
-        c.run("install . -s build_type=Debug -o dep:shared=True")
-        c.run("build .")
+        c.run("install . -o dep:shared=True -if=install_release")
+        c.run("build . -if=install_release")
+        c.run("install . -s build_type=Debug -o dep:shared=True -if=install_debug")
+        c.run("build . -if=install_debug")
 
     with c.chdir("dep"):
         c.run("editable add . dep/0.1@")

conans/test/functional/layout/test_local_commands.py

@@ -1,8 +1,11 @@
 import os
+import platform
 import re
+import textwrap
 
 from conans.model.ref import ConanFileReference, PackageReference
 from conans.test.assets.genconanfile import GenConanfile
+from conans.test.assets.pkg_cmake import pkg_cmake
 from conans.test.utils.tools import TestClient
 
 
@@ -156,7 +159,8 @@ def build(self):
     client.save({"conanfile.py": conan_file})
     client.run("install . -if=common")
     client.run("build . -if=common -bf=common")
-    dll = os.path.join(client.current_folder, "common", "my_build", "build_file.dll")
+    # -bf is ignored here, the layout defines it
+    dll = os.path.join(client.current_folder, "my_build", "build_file.dll")
     assert os.path.exists(dll)
 
 
@@ -359,3 +363,59 @@ def imports(self):
     bfolder = client.cache.package_layout(ref).build(pref)
     imports_folder = os.path.join(bfolder, "my_imports")
     assert "WARN: Imports folder: {}".format(imports_folder) in client.out
+
+
+def test_start_dir_failure():
+    c = TestClient()
+    c.save(pkg_cmake("dep", "0.1"))
+    c.run("install .")
+    build = "build" if platform.system() == "Windows" else "cmake-build-release"
+    expected_path = os.path.join(c.current_folder, build, "conan", "conan_toolchain.cmake")
+    assert os.path.exists(expected_path)
+    os.unlink(expected_path)
+    with c.chdir("build"):
+        c.run("install ..")
+    assert os.path.exists(expected_path)
+
+
+def test_importdir_failure():
+    c = TestClient()
+    conanfile = textwrap.dedent("""
+        from conans import ConanFile
+        from conan.tools.files import save
+        class Cosumer(ConanFile):
+            requires = "dep/0.1"
+            settings = "build_type"
+            def layout(self):
+                self.folders.imports = "Import" + str(self.settings.build_type)
+                self.folders.build = "build"
+            def build(self):
+                self.output.info("saving file")
+                save(self, "mybuild.txt", "mybuild")
+            def imports(self):
+                self.copy("myfile.txt")
+        """)
+    c.save({"dep/conanfile.py": GenConanfile().with_package_file("myfile.txt", "mycontent"),
+            "consumer/conanfile.py": conanfile})
+    c.run("create dep dep/0.1@")
+    with c.chdir("consumer"):
+        c.run("install . -s build_type=Release")
+        expected_path_release = os.path.join(c.current_folder, "ImportRelease", "myfile.txt")
+        assert os.path.exists(expected_path_release)
+        c.run("build .")
+        expected_build_file = os.path.join(c.current_folder, "build", "mybuild.txt")
+        assert os.path.exists(expected_build_file)
+        c.run("install . -s build_type=Debug")
+        expected_path_debug = os.path.join(c.current_folder, "ImportDebug", "myfile.txt")
+        assert os.path.exists(expected_path_debug)
+
+        os.unlink(expected_path_release)
+        os.unlink(expected_path_debug)
+        os.unlink(expected_build_file)
+        with c.chdir("build"):
+            c.run("install .. -s build_type=Release")
+            assert os.path.exists(expected_path_release)
+            c.run("build ..")
+            assert os.path.exists(expected_build_file)
+            c.run("install .. -s build_type=Debug")
+            assert os.path.exists(expected_path_debug)

conans/test/functional/toolchains/cmake/test_v2_cmake_template.py

@@ -1,3 +1,7 @@
+import os
+import re
+
+from conans.model.ref import ConanFileReference, PackageReference
 from conans.test.utils.tools import TestClient
 
 
@@ -7,6 +11,15 @@ def test_cmake_lib_template():
     # Local flow works
     client.run("install . -if=install")
     client.run("build . -if=install")
+    client.run("package . -if=install")
+    print(os.path.join(client.current_folder))
+    assert os.path.exists(os.path.join(client.current_folder, "package", "include", "hello.h"))
+
+    client.run("export-pkg . hello/0.1@ -if=install")
+    package_id = re.search(r"Packaging to (\S+)", str(client.out)).group(1)
+    pref = PackageReference(ConanFileReference.loads("hello/0.1"), package_id)
+    package_folder = client.cache.package_layout(pref.ref).package(pref)
+    assert os.path.exists(os.path.join(package_folder, "include", "hello.h"))
 
     # Create works
     client.run("create .")

conans/test/functional/toolchains/ios/test_using_cmake.py

@@ -55,6 +55,7 @@ def package(self):
             """)
         })
 
+    @pytest.mark.tool_cmake(version="3.19")
     def test_xcode_generator(self):
         """ Simplest approach:
             https://cmake.org/cmake/help/latest/manual/cmake-toolchains.7.html#cross-compiling-for-ios-tvos-or-watchos