Allow installation of platform dependencies from local path

This change allows the action to be used for easy compilation testing of platforms.

The easiest way to install the platform's tools dependencies is via Board Manager. If the platform from the local path was also installed via Board Manager (as identified by them having the same name value, the Board Manager platform will be replaced by the one from the local path.

Author: per1234

README.md

@@ -22,6 +22,17 @@ YAML-format list of platform dependencies to install.
 
 Default `""`. If no `platforms` input is provided, the board's dependency will be automatically determined from the `fqbn` input and the latest version of that platform will be installed via Board Manager.
 
+If a platform dependency from a non-Board Manager source of the same name as another Board Manager source platform dependency is defined, they will both be installed, with the non-Board Manager dependency overwriting the Board Manager platform installation. This permits testing against a non-release version of a platform while using Board Manager to install the platform's tools dependencies. 
+Example:
+```yaml
+platforms: |
+  # Install the latest release of Arduino SAMD Boards and its toolchain via Board Manager
+  - name: "arduino:samd"
+  # Install the platform from the root of the repository, replacing the BM installed platform
+  - source-path: "."
+    name: "arduino:samd"
+```
+
 #### Sources:
 
 ##### Board Manager
@@ -30,6 +41,12 @@ Keys:
 - `name` - platform name in the form of `VENDOR:ARCHITECTURE`.
 - `version` - version of the platform to install. Default is the latest version.
 
+##### Local path
+
+Keys:
+- `source-path` - path to install as a platform. Relative paths are assumed to be relative to the root of the repository.
+- `name` - platform name in the form of `VENDOR:ARCHITECTURE`.
+
 ### `libraries`
 
 YAML-format list of library dependencies to install.

compilesketches/compilesketches.py

@@ -77,7 +77,10 @@ class RunCommandOutput(enum.Enum):
 
     arduino_cli_installation_path = pathlib.Path.home().joinpath("bin")
     arduino_cli_user_directory_path = pathlib.Path.home().joinpath("Arduino")
+    arduino_cli_data_directory_path = pathlib.Path.home().joinpath(".arduino15")
     libraries_path = arduino_cli_user_directory_path.joinpath("libraries")
+    user_platforms_path = arduino_cli_user_directory_path.joinpath("hardware")
+    board_manager_platforms_path = arduino_cli_data_directory_path.joinpath("packages")
 
     report_fqbn_key = "fqbn"
     report_sketch_key = "sketch"
@@ -206,6 +209,8 @@ def install_arduino_cli(self):
 
         # Configure the location of the Arduino CLI user directory
         os.environ["ARDUINO_DIRECTORIES_USER"] = str(self.arduino_cli_user_directory_path)
+        # Configure the location of the Arduino CLI data directory
+        os.environ["ARDUINO_DIRECTORIES_DATA"] = str(self.arduino_cli_data_directory_path)
 
     def verbose_print(self, *print_arguments):
         """Print log output when in verbose mode"""
@@ -226,6 +231,9 @@ def install_platforms(self):
             # override system will work
             self.install_platforms_from_board_manager(platform_list=platform_list.manager)
 
+        if len(platform_list.path) > 0:
+            self.install_platforms_from_path(platform_list=platform_list.path)
+
     def get_fqbn_platform_dependency(self):
         """Return the platform dependency definition automatically generated from the FQBN."""
         # Extract the platform name from the FQBN (e.g., arduino:avr:uno => arduino:avr)
@@ -384,6 +392,80 @@ def run_command(self, command, enable_output=RunCommandOutput.ON_FAILURE, exit_o
 
         return command_data
 
+    def install_platforms_from_path(self, platform_list):
+        """Install libraries from local paths
+
+        Keyword arguments:
+        platform_list -- Dependencies object containing lists of dictionaries defining platform dependencies of each
+                         source type
+        """
+        for platform in platform_list:
+            source_path = absolute_path(platform[self.dependency_source_path_key])
+            self.verbose_print("Installing platform from path:", platform[self.dependency_source_path_key])
+
+            if not source_path.exists():
+                print("::error::Platform source path:", platform[self.dependency_source_path_key], "doesn't exist")
+                sys.exit(1)
+
+            platform_installation_path = self.get_platform_installation_path(platform=platform)
+
+            # Create the parent path if it doesn't exist already. This must be the immediate parent, whereas
+            # get_platform_installation_path().platform will be multiple nested folders under the base path
+            platform_installation_path_parent = (
+                pathlib.Path(platform_installation_path.base, platform_installation_path.platform).parent
+            )
+            platform_installation_path_parent.mkdir(parents=True, exist_ok=True)
+
+            # Install the platform by creating a symlink
+            destination_path = platform_installation_path.base.joinpath(platform_installation_path.platform)
+            destination_path.symlink_to(target=source_path, target_is_directory=True)
+
+    def get_platform_installation_path(self, platform):
+        """Return the correct installation path for the given platform
+
+        Keyword arguments:
+        platform -- dictionary defining the platform dependency
+        """
+
+        class PlatformInstallationPath:
+            def __init__(self):
+                self.base = pathlib.PurePath()
+                self.platform = pathlib.PurePath()
+
+        platform_installation_path = PlatformInstallationPath()
+
+        platform_vendor = platform[self.dependency_name_key].split(sep=":")[0]
+        platform_architecture = platform[self.dependency_name_key].rsplit(sep=":", maxsplit=1)[1]
+
+        # Default to installing to the sketchbook
+        platform_installation_path.base = self.user_platforms_path
+        platform_installation_path.platform = pathlib.PurePath(platform_vendor, platform_architecture)
+
+        # I have no clue why this is needed, but arduino-cli core list fails if this isn't done first. The 3rd party
+        # platforms are still shown in the list even if their index URLs are not specified to the command via the
+        # --additional-urls option
+        self.run_arduino_cli_command(command=["core", "update-index"])
+        # Use Arduino CLI to get the list of installed platforms
+        command_data = self.run_arduino_cli_command(command=["core", "list", "--format", "json"])
+        installed_platform_list = json.loads(command_data.stdout)
+        for installed_platform in installed_platform_list:
+            if installed_platform["ID"] == platform[self.dependency_name_key]:
+                # The platform has been installed via Board Manager, so do an overwrite
+                platform_installation_path.base = self.board_manager_platforms_path
+                platform_installation_path.platform = (
+                    pathlib.PurePath(platform_vendor,
+                                     "hardware",
+                                     platform_architecture,
+                                     installed_platform["Installed"])
+                )
+
+                # Remove the existing installation so it can be replaced by the installation function
+                shutil.rmtree(path=platform_installation_path.base.joinpath(platform_installation_path.platform))
+
+                break
+
+        return platform_installation_path
+
     def get_repository_dependency_ref(self, dependency):
         """Return the appropriate git ref value for a repository dependency
 

compilesketches/tests/test_compilesketches.py

@@ -295,11 +295,13 @@ def test_compile_sketches(mocker, compilation_success_list, expected_success, do
 def test_install_arduino_cli(mocker):
     cli_version = "1.2.3"
     arduino_cli_installation_path = unittest.mock.sentinel.arduino_cli_installation_path
+    arduino_cli_data_directory_path = pathlib.PurePath("/foo/arduino_cli_data_directory_path")
     arduino_cli_user_directory_path = pathlib.PurePath("/foo/arduino_cli_user_directory_path")
 
     compile_sketches = get_compilesketches_object(cli_version=cli_version)
     compile_sketches.arduino_cli_installation_path = arduino_cli_installation_path
     compile_sketches.arduino_cli_user_directory_path = arduino_cli_user_directory_path
+    compile_sketches.arduino_cli_data_directory_path = arduino_cli_data_directory_path
 
     mocker.patch("compilesketches.install_from_download", autospec=True)
 
@@ -311,6 +313,11 @@ def test_install_arduino_cli(mocker):
         destination_parent_path=arduino_cli_installation_path)
 
     assert os.environ["ARDUINO_DIRECTORIES_USER"] == str(arduino_cli_user_directory_path)
+    assert os.environ["ARDUINO_DIRECTORIES_DATA"] == str(arduino_cli_data_directory_path)
+    del os.environ["ARDUINO_DIRECTORIES_USER"]
+    del os.environ["ARDUINO_DIRECTORIES_DATA"]
+
+
 @pytest.mark.parametrize("platforms", ["", "foo"])
 def test_install_platforms(mocker, platforms):
     fqbn_platform_dependency = unittest.mock.sentinel.fqbn_platform_dependency
@@ -573,6 +580,130 @@ def test_get_manager_dependency_name(dependency, expected_name):
     assert compile_sketches.get_manager_dependency_name(dependency=dependency) == expected_name
 
 
+@pytest.mark.parametrize(
+    "path_exists, platform_list",
+    [(False, [{compilesketches.CompileSketches.dependency_source_path_key: pathlib.Path("Foo")}]),
+     (True, [{compilesketches.CompileSketches.dependency_source_path_key: pathlib.Path("Foo")}])]
+)
+def test_install_platforms_from_path(capsys, monkeypatch, mocker, path_exists, platform_list):
+    class PlatformInstallationPath:
+        def __init__(self):
+            self.parent = pathlib.PurePath()
+            self.name = pathlib.PurePath()
+
+    platform_installation_path = PlatformInstallationPath()
+    platform_installation_path.base = pathlib.Path("/foo/PlatformInstallationPathParent")
+    platform_installation_path.platform = pathlib.Path("PlatformInstallationPathName")
+    symlink_source_path = pathlib.Path("/foo/SymlinkSourcePath")
+
+    monkeypatch.setenv("GITHUB_WORKSPACE", "/foo/GitHubWorkspace")
+
+    compile_sketches = get_compilesketches_object()
+
+    mocker.patch.object(pathlib.Path, "exists", autospec=True, return_value=path_exists)
+    mocker.patch("compilesketches.CompileSketches.get_platform_installation_path",
+                 autospec=True,
+                 return_value=platform_installation_path)
+    mocker.patch.object(pathlib.Path, "mkdir", autospec=True)
+    mocker.patch.object(pathlib.Path, "joinpath", autospec=True, return_value=symlink_source_path)
+    mocker.patch.object(pathlib.Path, "symlink_to", autospec=True)
+
+    if not path_exists:
+        with pytest.raises(expected_exception=SystemExit, match="1"):
+            compile_sketches.install_platforms_from_path(platform_list=platform_list)
+
+        assert capsys.readouterr().out.strip() == (
+            "::error::Platform source path: "
+            + str(platform_list[0][compilesketches.CompileSketches.dependency_source_path_key])
+            + " doesn't exist"
+        )
+
+    else:
+        compile_sketches.install_platforms_from_path(platform_list=platform_list)
+
+        get_platform_installation_path_calls = []
+        joinpath_calls = []
+        mkdir_calls = []
+        symlink_to_calls = []
+        for platform in platform_list:
+            get_platform_installation_path_calls.append(unittest.mock.call(compile_sketches, platform=platform))
+            mkdir_calls.append(unittest.mock.call(platform_installation_path.base, parents=True, exist_ok=True))
+            joinpath_calls.append(unittest.mock.call(platform_installation_path.base,
+                                                     platform_installation_path.platform))
+            symlink_to_calls.append(
+                unittest.mock.call(
+                    symlink_source_path,
+                    target=compilesketches.absolute_path(
+                        platform[compilesketches.CompileSketches.dependency_source_path_key]
+                    ),
+                    target_is_directory=True
+                )
+            )
+
+        # noinspection PyUnresolvedReferences
+        pathlib.Path.mkdir.assert_has_calls(calls=mkdir_calls)
+        # noinspection PyUnresolvedReferences
+        pathlib.Path.joinpath.assert_has_calls(calls=joinpath_calls)
+        pathlib.Path.symlink_to.assert_has_calls(calls=symlink_to_calls)
+
+
+@pytest.mark.parametrize(
+    "platform,"
+    "command_data_stdout,"
+    "expected_installation_path_base,"
+    "expected_installation_path_platform,"
+    "expected_rmtree",
+    # No match to previously installed platforms
+    [({compilesketches.CompileSketches.dependency_name_key: "foo:bar"},
+      "[{\"ID\": \"asdf:zxcv\"}]",
+      pathlib.PurePath("/foo/UserPlatformsPath"),
+      pathlib.PurePath("foo/bar"),
+      False),
+     # Match with previously installed platform
+     ({compilesketches.CompileSketches.dependency_name_key: "foo:bar"},
+      "[{\"ID\": \"foo:bar\", \"Installed\": \"1.2.3\"}]",
+      pathlib.PurePath("/foo/BoardManagerPlatformsPath"),
+      pathlib.PurePath("foo/hardware/bar/1.2.3"),
+      True)]
+)
+def test_get_platform_installation_path(mocker,
+                                        platform,
+                                        command_data_stdout,
+                                        expected_installation_path_base,
+                                        expected_installation_path_platform,
+                                        expected_rmtree):
+    class CommandData:
+        def __init__(self, stdout):
+            self.stdout = stdout
+
+    command_data = CommandData(stdout=command_data_stdout)
+
+    mocker.patch("compilesketches.CompileSketches.run_arduino_cli_command", autospec=True, return_value=command_data)
+    mocker.patch("shutil.rmtree", autospec=True)
+
+    compile_sketches = get_compilesketches_object()
+    compile_sketches.user_platforms_path = pathlib.PurePath("/foo/UserPlatformsPath")
+    compile_sketches.board_manager_platforms_path = pathlib.PurePath("/foo/BoardManagerPlatformsPath")
+
+    platform_installation_path = compile_sketches.get_platform_installation_path(platform=platform)
+    assert platform_installation_path.base == expected_installation_path_base
+    assert platform_installation_path.platform == expected_installation_path_platform
+
+    run_arduino_cli_command_calls = [unittest.mock.call(compile_sketches, command=["core", "update-index"]),
+                                     unittest.mock.call(compile_sketches, command=["core", "list", "--format", "json"])]
+    compilesketches.CompileSketches.run_arduino_cli_command.assert_has_calls(calls=run_arduino_cli_command_calls)
+
+    # noinspection PyUnresolvedReferences
+    if expected_rmtree is True:
+        # noinspection PyUnresolvedReferences
+        shutil.rmtree.assert_called_once_with(
+            path=platform_installation_path.base.joinpath(platform_installation_path.platform)
+        )
+    else:
+        # noinspection PyUnresolvedReferences
+        shutil.rmtree.assert_not_called()
+
+
 @pytest.mark.parametrize(
     "dependency, expected_ref",
     [({compilesketches.CompileSketches.dependency_version_key: "1.2.3"}, "1.2.3"),