config: Support custom_targets.json

Author: rwalton-arm

.travis.yml

@@ -162,6 +162,17 @@ matrix:
         - mbedtools compile -t GCC_ARM -m K64F
         - ccache -s
 
+    - <<: *mbed-tools-test
+      name: "Test custom target"
+      env: NAME=test-import-cmd CACHE_NAME=test-import-cmd
+      script:
+        - mbedtools new custom-target-test
+        - cd custom-target-test
+        - cp $TRAVIS_BUILD_DIR/travis-ci/test-data/custom_targets.json .
+        - mkdir TARGET_IMAGINARYBOARD && cp $TRAVIS_BUILD_DIR/travis-ci/test-data/TARGET_IMAGINARYBOARD/* TARGET_IMAGINARYBOARD
+        - mbedtools compile -t GCC_ARM -m IMAGINARYBOARD
+        - ccache -s
+
     - <<: *mbed-tools-test
       name: "Test deploy command checks out tip of default branch"
       env: NAME=test-deploy-cmd CACHE_NAME=test-deploy-cmd

news/20201222090211.feature

@@ -0,0 +1 @@
+Support custom_targets.json.

src/mbed_tools/build/config.py

@@ -5,12 +5,15 @@
 """Parses the Mbed configuration system and generates a CMake config script."""
 import pathlib
 
+from typing import Any
+
 from mbed_tools.lib.json_helpers import decode_json_file
 from mbed_tools.project import MbedProgram
 from mbed_tools.targets import get_target_by_name
 from mbed_tools.build._internal.cmake_file import render_mbed_config_cmake_template
 from mbed_tools.build._internal.config.assemble_build_config import assemble_config
 from mbed_tools.build._internal.write_files import write_file
+from mbed_tools.build.exceptions import MbedBuildError
 
 
 def generate_config(target_name: str, toolchain: str, program: MbedProgram) -> pathlib.Path:
@@ -24,11 +27,29 @@ def generate_config(target_name: str, toolchain: str, program: MbedProgram) -> p
     Returns:
         Path to the generated config file.
     """
-    target_build_attributes = get_target_by_name(target_name, decode_json_file(program.mbed_os.targets_json_file))
+    targets_data = _load_raw_targets_data(program)
+    target_build_attributes = get_target_by_name(target_name, targets_data)
     config = assemble_config(target_build_attributes, program.root, program.files.app_config_file)
     cmake_file_contents = render_mbed_config_cmake_template(
         target_name=target_name, config=config, toolchain_name=toolchain,
     )
     cmake_config_file_path = program.files.cmake_config_file
     write_file(cmake_config_file_path, cmake_file_contents)
     return cmake_config_file_path
+
+
+def _load_raw_targets_data(program: MbedProgram) -> Any:
+    targets_data = decode_json_file(program.mbed_os.targets_json_file)
+    if program.files.custom_targets_json.exists():
+        custom_targets_data = decode_json_file(program.files.custom_targets_json)
+        for custom_target in custom_targets_data:
+            if custom_target in targets_data:
+                raise MbedBuildError(
+                    f"Error found in {program.files.custom_targets_json}.\n"
+                    f"A target with the name '{custom_target}' already exists in targets.json. "
+                    "Please give your custom target a unique name so it can be identified."
+                )
+
+        targets_data.update(custom_targets_data)
+
+    return targets_data

src/mbed_tools/cli/build.py

@@ -34,6 +34,9 @@
 @click.option(
     "--mbed-os-path", type=click.Path(), default=None, help="Path to local Mbed OS directory.",
 )
+@click.option(
+    "--custom-targets-json", type=click.Path(), default=None, help="Path to custom_targets.json.",
+)
 @click.option(
     "-f", "--flash", is_flag=True, default=False, help="Flash the binary onto a device",
 )
@@ -60,6 +63,7 @@ def build(
     sterm: bool = False,
     baudrate: int = 9600,
     mbed_os_path: str = None,
+    custom_targets_json: str = None,
 ) -> None:
     """Configure and build an Mbed project using CMake and Ninja.
 
@@ -73,6 +77,7 @@ def build(
        program_path: Path to the Mbed project.
        mbed_os_path: the path to the local Mbed OS directory
        profile: The Mbed build profile (debug, develop or release).
+       custom_targets_json: Path to custom_targets.json.
        toolchain: The toolchain to use for the build.
        mbed_target: The name of the Mbed target to build for.
        clean: Perform a clean build.
@@ -93,6 +98,9 @@ def build(
     if any([not mbed_config_file.exists(), not build_tree.exists(), mbed_target, toolchain]):
         click.echo("Configuring project and generating build system...")
         _validate_target_and_toolchain_args(mbed_target, toolchain)
+        if custom_targets_json is not None:
+            program.files.custom_targets_json = pathlib.Path(custom_targets_json)
+
         generate_config(mbed_target.upper(), toolchain, program)
         generate_build_system(program.root, build_tree, profile)
 

src/mbed_tools/project/_internal/project_data.py

@@ -27,6 +27,7 @@
 MBED_OS_REFERENCE_FILE_NAME = "mbed-os.lib"
 MBED_OS_DIR_NAME = "mbed-os"
 TARGETS_JSON_FILE_PATH = Path("targets", "targets.json")
+CUSTOM_TARGETS_JSON_FILE_NAME = "custom_targets.json"
 
 # Information written to mbed-os.lib
 MBED_OS_REFERENCE_URL = "https://github.com/ARMmbed/mbed-os"
@@ -59,6 +60,7 @@ class MbedProgramFiles:
     cmakelists_file: Path
     cmake_config_file: Path
     cmake_build_dir: Path
+    custom_targets_json: Path
 
     @classmethod
     def from_new(cls, root_path: Path) -> "MbedProgramFiles":
@@ -79,6 +81,7 @@ def from_new(cls, root_path: Path) -> "MbedProgramFiles":
         gitignore = root_path / ".gitignore"
         cmake_config = root_path / CMAKE_CONFIG_FILE_PATH
         cmake_build_dir = root_path / CMAKE_BUILD_DIR
+        custom_targets_json = root_path / CUSTOM_TARGETS_JSON_FILE_NAME
 
         if mbed_os_ref.exists():
             raise ValueError(f"Program already exists at path {root_path}.")
@@ -94,6 +97,7 @@ def from_new(cls, root_path: Path) -> "MbedProgramFiles":
             cmakelists_file=cmakelists_file,
             cmake_config_file=cmake_config,
             cmake_build_dir=cmake_build_dir,
+            custom_targets_json=custom_targets_json,
         )
 
     @classmethod
@@ -109,6 +113,7 @@ def from_existing(cls, root_path: Path) -> "MbedProgramFiles":
             logger.info("This program does not contain an mbed_app.json config file.")
             app_config = None
 
+        custom_targets_json = root_path / CUSTOM_TARGETS_JSON_FILE_NAME
         mbed_os_file = root_path / MBED_OS_REFERENCE_FILE_NAME
 
         cmakelists_file = root_path / CMAKELISTS_FILE_NAME
@@ -121,6 +126,7 @@ def from_existing(cls, root_path: Path) -> "MbedProgramFiles":
             cmakelists_file=cmakelists_file,
             cmake_config_file=root_path / CMAKE_CONFIG_FILE_PATH,
             cmake_build_dir=root_path / CMAKE_BUILD_DIR,
+            custom_targets_json=custom_targets_json,
         )
 
 

tests/build/test_generate_config.py

@@ -90,6 +90,27 @@ def test_target_and_toolchain_collected(program):
     assert toolchain in config_text
 
 
+def test_custom_targets_data_found(program):
+    program.files.custom_targets_json.write_text(json.dumps({"IMAGINARYBOARD": TARGET_DATA}))
+    target = "IMAGINARYBOARD"
+    toolchain = "GCC_ARM"
+
+    generate_config(target, toolchain, program)
+
+    config_text = program.files.cmake_config_file.read_text()
+
+    assert target in config_text
+
+
+def test_raises_error_when_attempting_to_customize_existing_target(program):
+    program.files.custom_targets_json.write_text(json.dumps({TARGETS[0]: TARGET_DATA}))
+    target = TARGETS[0]
+    toolchain = "GCC_ARM"
+
+    with pytest.raises(ToolsError):
+        generate_config(target, toolchain, program)
+
+
 def test_config_param_from_lib_processed_with_default_name_mangling(program):
     create_mbed_lib_json(
         program.mbed_os.root / "platform" / "mbed_lib.json",

tests/cli/test_build.py

@@ -144,6 +144,21 @@ def test_build_system_regenerated_when_mbed_os_path_passed(
             generate_config.assert_called_once_with(target.upper(), toolchain.upper(), program)
             generate_build_system.assert_called_once_with(program.root, program.files.cmake_build_dir, "develop")
 
+    def test_custom_targets_location_used_when_passed(
+        self, generate_config, mbed_program, build_project, generate_build_system
+    ):
+        program = mbed_program.from_existing()
+        with mock_project_directory(program, mbed_config_exists=True, build_tree_exists=True):
+            toolchain = "gcc_arm"
+            target = "k64f"
+            custom_targets_json_path = pathlib.Path("custom", "custom_targets.json")
+
+            runner = CliRunner()
+            runner.invoke(build, ["-t", toolchain, "-m", target, "--custom-targets-json", custom_targets_json_path])
+
+            generate_config.assert_called_once_with(target.upper(), toolchain.upper(), program)
+            self.assertEqual(program.files.custom_targets_json, custom_targets_json_path)
+
     def test_build_folder_removed_when_clean_flag_passed(
         self, generate_config, mbed_program, build_project, generate_build_system
     ):

travis-ci/test-data/TARGET_IMAGINARYBOARD/CMakeLists.txt

@@ -0,0 +1,16 @@
+# Copyright (c) 2020 ARM Limited. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+add_library(IMAGINARYBOARD INTERFACE)
+
+target_sources(IMAGINARYBOARD
+    INTERFACE
+        PeripheralPins.c
+)
+
+target_include_directories(IMAGINARYBOARD
+    INTERFACE
+        .
+)
+
+target_link_libraries(IMAGINARYBOARD INTERFACE STM32L475xG)