Remove unneeded cmake-build-dir option, we already have output

Author: multiplemonomials

tools/cmake/mbed_generate_configuration.cmake

@@ -89,7 +89,6 @@ if(MBED_NEED_TO_RECONFIGURE)
         --mbed-os-path ${CMAKE_CURRENT_LIST_DIR}/../..
         --output-dir ${CMAKE_CURRENT_BINARY_DIR}
         --program-path ${CMAKE_SOURCE_DIR}
-        --cmake-build-dir ${CMAKE_BINARY_DIR}
         ${APP_CONFIG_ARGUMENT}
         ${CUSTOM_TARGET_ARGUMENT})
 

tools/python/mbed_tools/build/_internal/templates/mbed_config.tmpl

@@ -15,7 +15,7 @@ set(MBED_GREENTEA_TEST_RESET_TIMEOUT "{{forced_reset_timeout}}")
 
 # JSON files used to generate this config.  If any of these change, the Python config generation
 # scripts must be rerun.
-set(CONFIG_JSON_SOURCE_FILES {% for json_source in json_sources %}
+set(CONFIG_JSON_SOURCE_FILES {% for json_source in json_sources | sort %}
     "{{json_source.as_posix()}}"
 {%- endfor %}
 )

tools/python/mbed_tools/cli/configure.py

@@ -25,7 +25,10 @@
     help="The toolchain you are using to build your app.",
 )
 @click.option("-m", "--mbed-target", required=True, help="A build target for an Mbed-enabled device, eg. K64F")
-@click.option("-o", "--output-dir", type=click.Path(), default=None, help="Path to output directory.")
+@click.option("-o", "--output-dir",
+              type=click.Path(path_type=pathlib.Path),
+              required=True,
+              help="Path to output directory (CMake binary dir)")
 @click.option(
     "-p",
     "--program-path",
@@ -39,18 +42,14 @@
 @click.option(
     "--app-config", type=click.Path(), default=None, help="Path to application configuration file.",
 )
-@click.option(
-    "--cmake-build-dir", type=click.Path(path_type=pathlib.Path), help="Path to CMake build dir", required=True
-)
 def configure(
     toolchain: str,
     mbed_target: str,
     program_path: str,
     mbed_os_path: str,
-    output_dir: str,
+    output_dir: pathlib.Path,
     custom_targets_json: str,
-    app_config: str,
-    cmake_build_dir: pathlib.Path
+    app_config: str
 ) -> None:
     """Exports a mbed_config.cmake file to build directory in the program root.
 
@@ -69,16 +68,13 @@ def configure(
         mbed_os_path: the path to the local Mbed OS directory
         output_dir: the path to the output directory
         app_config: the path to the application configuration file
-        cmake_build_dir: Path to CMake build dir
     """
     if mbed_os_path is None:
-        program = MbedProgram.from_existing(pathlib.Path(program_path), cmake_build_dir)
+        program = MbedProgram.from_existing(pathlib.Path(program_path), output_dir)
     else:
-        program = MbedProgram.from_existing(pathlib.Path(program_path), cmake_build_dir, pathlib.Path(mbed_os_path).resolve())
+        program = MbedProgram.from_existing(pathlib.Path(program_path), output_dir, pathlib.Path(mbed_os_path).resolve())
     if custom_targets_json is not None:
         program.files.custom_targets_json = pathlib.Path(custom_targets_json)
-    if output_dir is not None:
-        program.files.cmake_build_dir = pathlib.Path(output_dir)
     if app_config is not None:
         program.files.app_config_file = pathlib.Path(app_config)
 

tools/python/mbed_tools/project/_internal/project_data.py

@@ -99,12 +99,12 @@ def from_new(cls, root_path: Path) -> "MbedProgramFiles":
         )
 
     @classmethod
-    def from_existing(cls, root_path: Path, build_subdir: Path) -> "MbedProgramFiles":
+    def from_existing(cls, root_path: Path, build_dir: Path) -> "MbedProgramFiles":
         """Create MbedProgramFiles from a directory containing an existing program.
 
         Args:
             root_path: The path containing the MbedProgramFiles.
-            build_subdir: The subdirectory of BUILD_DIR to use for CMake build.
+            build_dir: The directory to use for CMake build.
         """
         app_config: Optional[Path] = None
         if (root_path / APP_CONFIG_FILE_NAME_JSON5).exists():
@@ -126,13 +126,12 @@ def from_existing(cls, root_path: Path, build_subdir: Path) -> "MbedProgramFiles
         cmakelists_file = root_path / CMAKELISTS_FILE_NAME
         if not cmakelists_file.exists():
             logger.warning("No CMakeLists.txt found in the program root.")
-        cmake_build_dir = root_path / BUILD_DIR / build_subdir
 
         return cls(
             app_config_file=app_config,
             mbed_os_ref=mbed_os_file,
             cmakelists_file=cmakelists_file,
-            cmake_build_dir=cmake_build_dir,
+            cmake_build_dir=build_dir,
             custom_targets_json=custom_targets_json,
         )
 

tools/python/mbed_tools/project/mbed_program.py

@@ -68,13 +68,13 @@ def from_new(cls, dir_path: Path) -> "MbedProgram":
 
     @classmethod
     def from_existing(
-        cls, dir_path: Path, build_subdir: Path, mbed_os_path: Path = None, check_mbed_os: bool = True,
+        cls, dir_path: Path, build_dir: Path, mbed_os_path: Path = None, check_mbed_os: bool = True,
     ) -> "MbedProgram":
         """Create an MbedProgram from an existing program directory.
 
         Args:
             dir_path: Directory containing an Mbed program.
-            build_subdir: The subdirectory for the CMake build tree.
+            build_dir: The directory for the CMake build tree.
             mbed_os_path: Directory containing Mbed OS.
             check_mbed_os: If True causes an exception to be raised if the Mbed OS source directory does not
                            exist.
@@ -89,7 +89,7 @@ def from_existing(
             program_root = dir_path
 
         logger.info(f"Found existing Mbed program at path '{program_root}'")
-        program = MbedProgramFiles.from_existing(program_root, build_subdir)
+        program = MbedProgramFiles.from_existing(program_root, build_dir)
 
         try:
             mbed_os = MbedOS.from_existing(mbed_os_path, check_mbed_os)

tools/python/python_tests/mbed_tools/cli/test_configure.py

@@ -15,14 +15,14 @@ class TestConfigureCommand(TestCase):
     @mock.patch("mbed_tools.cli.configure.generate_config")
     @mock.patch("mbed_tools.cli.configure.MbedProgram")
     def test_generate_config_called_with_correct_arguments(self, program, generate_config):
-        CliRunner().invoke(configure, ["-m", "k64f", "-t", "gcc_arm", "--cmake-build-dir", "build"])
+        CliRunner().invoke(configure, ["-m", "k64f", "-t", "gcc_arm", "-o", "some_output_dir"])
 
         generate_config.assert_called_once_with("K64F", "GCC_ARM", program.from_existing())
 
     @mock.patch("mbed_tools.cli.configure.generate_config")
     @mock.patch("mbed_tools.cli.configure.MbedProgram")
     def test_generate_config_called_with_mbed_os_path(self, program, generate_config):
-        CliRunner().invoke(configure, ["-m", "k64f", "-t", "gcc_arm", "--mbed-os-path", "./extern/mbed-os", "--cmake-build-dir", "build"])
+        CliRunner().invoke(configure, ["-m", "k64f", "-t", "gcc_arm", "--mbed-os-path", "./extern/mbed-os", "-o", "some_output_dir"])
 
         generate_config.assert_called_once_with("K64F", "GCC_ARM", program.from_existing())
 
@@ -32,49 +32,39 @@ def test_custom_targets_location_used_when_passed(self, program, generate_config
         program = program.from_existing()
         custom_targets_json_path = pathlib.Path("custom", "custom_targets.json")
         CliRunner().invoke(
-            configure, ["-t", "gcc_arm", "-m", "k64f", "--custom-targets-json", custom_targets_json_path, "--cmake-build-dir", "build"]
+            configure, ["-t", "gcc_arm", "-m", "k64f", "--custom-targets-json", custom_targets_json_path, "-o", "some_output_dir"]
         )
 
         generate_config.assert_called_once_with("K64F", "GCC_ARM", program)
         self.assertEqual(program.files.custom_targets_json, custom_targets_json_path)
 
-    @mock.patch("mbed_tools.cli.configure.generate_config")
-    @mock.patch("mbed_tools.cli.configure.MbedProgram")
-    def test_custom_output_directory_used_when_passed(self, program, generate_config):
-        program = program.from_existing()
-        output_dir = pathlib.Path("build")
-        CliRunner().invoke(configure, ["-t", "gcc_arm", "-m", "k64f", "-o", output_dir, "--cmake-build-dir", "build"])
-
-        generate_config.assert_called_once_with("K64F", "GCC_ARM", program)
-        self.assertEqual(program.files.cmake_build_dir, output_dir)
-
     @mock.patch("mbed_tools.cli.configure.generate_config")
     @mock.patch("mbed_tools.cli.configure.MbedProgram")
     def test_app_config_used_when_passed(self, program, generate_config):
         program = program.from_existing()
         app_config_path = pathlib.Path("alternative_config.json")
         CliRunner().invoke(
-            configure, ["-t", "gcc_arm", "-m", "k64f", "--app-config", app_config_path, "--cmake-build-dir", "build"]
+            configure, ["-t", "gcc_arm", "-m", "k64f", "--app-config", app_config_path, "-o", "some_output_dir"]
         )
 
         generate_config.assert_called_once_with("K64F", "GCC_ARM", program)
         self.assertEqual(program.files.app_config_file, app_config_path)
 
     @mock.patch("mbed_tools.cli.configure.generate_config")
     @mock.patch("mbed_tools.cli.configure.MbedProgram")
-    def test_cmake_build_dir_passed(self, program, generate_config):
+    def test_output_dir_passed(self, program, generate_config):
         test_program = program.from_existing()
         program.reset_mock()  # clear call count from previous line
 
         toolchain = "gcc_arm"
         target = "k64f"
 
         CliRunner().invoke(
-            configure, ["-t", toolchain, "-m", target, "--cmake-build-dir", "some-build-dir"]
+            configure, ["-t", toolchain, "-m", target, "-o", "some_output_dir"]
         )
 
         program.from_existing.assert_called_once_with(
             pathlib.Path("."),
-            pathlib.Path("some-build-dir")
+            pathlib.Path("some_output_dir")
         )
         generate_config.assert_called_once_with("K64F", "GCC_ARM", test_program)

tools/python/python_tests/mbed_tools/project/test_mbed_program.py

@@ -10,7 +10,7 @@
 from mbed_tools.project import MbedProgram
 from mbed_tools.project.exceptions import ExistingProgram, ProgramNotFound, MbedOSNotFound
 from mbed_tools.project.mbed_program import _find_program_root, parse_url
-from mbed_tools.project._internal.project_data import MbedProgramFiles
+from mbed_tools.project._internal.project_data import MbedProgramFiles, BUILD_DIR
 from python_tests.mbed_tools.project.factories import make_mbed_program_files, make_mbed_os_files
 
 
@@ -40,7 +40,7 @@ def test_from_new_local_dir_generates_valid_program_creating_directory(self, tmp
 
         program = from_new_set_target_toolchain(program_root)
 
-        assert program.files == MbedProgramFiles.from_existing(program_root, DEFAULT_BUILD_SUBDIR)
+        assert program.files == MbedProgramFiles.from_existing(program_root, program_root / BUILD_DIR / DEFAULT_BUILD_SUBDIR)
 
     def test_from_new_local_dir_generates_valid_program_creating_directory_in_cwd(self, tmp_path):
         old_cwd = os.getcwd()
@@ -52,7 +52,7 @@ def test_from_new_local_dir_generates_valid_program_creating_directory_in_cwd(se
 
             program = from_new_set_target_toolchain(program_root)
 
-            assert program.files == MbedProgramFiles.from_existing(program_root, DEFAULT_BUILD_SUBDIR)
+            assert program.files == MbedProgramFiles.from_existing(program_root, program_root / BUILD_DIR / DEFAULT_BUILD_SUBDIR)
         finally:
             os.chdir(old_cwd)
 
@@ -64,29 +64,29 @@ def test_from_new_local_dir_generates_valid_program_existing_directory(self, tmp
 
         program = from_new_set_target_toolchain(program_root)
 
-        assert program.files == MbedProgramFiles.from_existing(program_root, DEFAULT_BUILD_SUBDIR)
+        assert program.files == MbedProgramFiles.from_existing(program_root, program_root / BUILD_DIR / DEFAULT_BUILD_SUBDIR)
 
     def test_from_existing_raises_if_path_is_not_a_program(self, tmp_path):
         fs_root = pathlib.Path(tmp_path, "foo")
         fs_root.mkdir()
         program_root = fs_root / "programfoo"
 
         with pytest.raises(ProgramNotFound):
-            MbedProgram.from_existing(program_root, DEFAULT_BUILD_SUBDIR)
+            MbedProgram.from_existing(program_root, program_root / BUILD_DIR / DEFAULT_BUILD_SUBDIR)
 
     def test_from_existing_raises_if_no_mbed_os_dir_found_and_check_mbed_os_is_true(self, tmp_path):
         fs_root = pathlib.Path(tmp_path, "foo")
         make_mbed_program_files(fs_root)
 
         with pytest.raises(MbedOSNotFound):
-            MbedProgram.from_existing(fs_root, DEFAULT_BUILD_SUBDIR, check_mbed_os=True)
+            MbedProgram.from_existing(fs_root, fs_root / BUILD_DIR / DEFAULT_BUILD_SUBDIR, check_mbed_os=True)
 
     def test_from_existing_returns_valid_program(self, tmp_path):
         fs_root = pathlib.Path(tmp_path, "foo")
         make_mbed_program_files(fs_root)
         make_mbed_os_files(fs_root / "mbed-os")
 
-        program = MbedProgram.from_existing(fs_root, DEFAULT_BUILD_SUBDIR)
+        program = MbedProgram.from_existing(fs_root, fs_root / BUILD_DIR / DEFAULT_BUILD_SUBDIR)
 
         assert program.files.app_config_file.exists()
         assert program.mbed_os.root.exists()
@@ -98,7 +98,7 @@ def test_from_existing_with_mbed_os_path_returns_valid_program(self, tmp_path):
         make_mbed_program_files(fs_root)
         make_mbed_os_files(mbed_os_path)
 
-        program = MbedProgram.from_existing(fs_root, DEFAULT_BUILD_SUBDIR, mbed_os_path)
+        program = MbedProgram.from_existing(fs_root, fs_root / BUILD_DIR / DEFAULT_BUILD_SUBDIR, mbed_os_path)
 
         assert program.files.app_config_file.exists()
         assert program.mbed_os.root.exists()

tools/python/python_tests/mbed_tools/regression/test_configure.py

@@ -56,6 +56,6 @@ def test_generate_config_called_with_correct_arguments(self):
             pathlib.Path(tmpDirPath / "cmake-build-debug").mkdir()
 
             result = CliRunner().invoke(
-                configure, ["-m", "Target", "-t", "gcc_arm", "-p", tmpDir, "--cmake-build-dir", str(tmpDirPath / "cmake-build-debug")], catch_exceptions=False
+                configure, ["-m", "Target", "-t", "gcc_arm", "-p", tmpDir, "-o", str(tmpDirPath / "cmake-build-debug")], catch_exceptions=False
             )
             self.assertIn("mbed_config.cmake has been generated and written to", result.output)