Add support for local paths to libraries input

The previous behavior of the action is to always install the repository as a library. That works for compilation testing of libraries, but there is no reason to restrict this tool to that application. It can just as well be a general purpose tool for compilation testing of any Arduino project (library, platform, sketch). When seen from that perspective, it is better to give the user control over this behavior.

For backwards compatibility, the previous behavior of always installing the repository as a library is retained when the old space-separated list syntax is used, or if the user doesn't provide a libraries input.

Author: per1234

README.md

@@ -20,6 +20,8 @@ For 3rd party boards, also specify the Boards Manager URL:
 
 YAML-format list of library dependencies to install.
 
+Default `"- source-path: ./"`. This causes the repository to be installed as a library. If there are no library dependencies and you want to override the default, set the `libraries` input to an empty list (`- libraries: '-'`).
+
 Note: the original space-separated list format is also supported. When this syntax is used, the repository under test will always be installed as a library.
 
 #### Sources:
@@ -30,6 +32,12 @@ Keys:
 - `name` - name of the library.
 - `version` - version of the library to install. Default is the latest version.
 
+##### Local path
+
+Keys:
+- `source-path` - path to install as a library. Relative paths are assumed to be relative to the root of the repository.
+- `destination-name` - folder name to install the library to. By default, the folder will be named according to the source repository or subfolder name.
+
 
 ### `sketch-paths`
 

action.yml

@@ -8,8 +8,8 @@ inputs:
     description: 'Full qualified board name, with Boards Manager URL if needed'
     default: 'arduino:avr:uno'
   libraries:
-    default: ''
     description: 'YAML-format list of library dependencies to install'
+    default: '- source-path: ./'
   sketch-paths:
     description: 'List of paths containing sketches to compile.'
     default: 'examples'

compilesketches/compilesketches.py

@@ -88,6 +88,8 @@ class RunCommandOutput(enum.Enum):
 
     dependency_name_key = "name"
     dependency_version_key = "version"
+    dependency_source_path_key = "source-path"
+    dependency_destination_name_key = "destination-name"
 
     latest_release_indicator = "latest"
 
@@ -241,7 +243,12 @@ def sort_dependency_list(self, dependency_list):
         sorted_dependencies = self.Dependencies()
         for dependency in dependency_list:
             if dependency is not None:
-                sorted_dependencies.manager.append(dependency)
+                if self.dependency_source_path_key in dependency:
+                    # Libraries with source-path and no source-url are assumed to be paths
+                    sorted_dependencies.path.append(dependency)
+                else:
+                    # All others are Library/Board Manager names
+                    sorted_dependencies.manager.append(dependency)
 
         return sorted_dependencies
 
@@ -250,6 +257,7 @@ class Dependencies:
 
         def __init__(self):
             self.manager = []
+            self.path = []
 
     def install_platforms_from_board_manager(self, platform_list, additional_url_list):
         """Install platform dependencies from the Arduino Board Manager
@@ -372,13 +380,15 @@ def install_libraries(self):
             library_list.manager = [{self.dependency_name_key: library_name}
                                     for library_name in parse_list_input(self.libraries)]
 
+            # The original behavior of the action was to assume the root of the repo is a library to be installed, so
+            # that behavior is retained when using the old input syntax
+            library_list.path = [{self.dependency_source_path_key: pathlib.Path(os.environ["GITHUB_WORKSPACE"])}]
+
         if len(library_list.manager) > 0:
             self.install_libraries_from_library_manager(library_list=library_list.manager)
 
-        # TODO: this is in anticipation of allowing arbitrary paths to be specified by the user, rather than assuming
-        #       there is a library in the root of the repo (not the case when testing platforms and sketches)
-        # Install the repository as a library by creating a symlink in the sketchbook
-        self.install_libraries_from_path(library_path_list=[pathlib.Path(os.environ["GITHUB_WORKSPACE"])])
+        if len(library_list.path) > 0:
+            self.install_libraries_from_path(library_list=library_list.path)
 
     def install_libraries_from_library_manager(self, library_list):
         """Install libraries using the Arduino Library Manager
@@ -390,18 +400,37 @@ def install_libraries_from_library_manager(self, library_list):
         lib_install_command.extend([self.get_manager_dependency_name(library) for library in library_list])
         self.run_arduino_cli_command(command=lib_install_command, enable_output=self.get_run_command_output_level())
 
-    def install_libraries_from_path(self, library_path_list):
+    def install_libraries_from_path(self, library_list):
         """Install libraries from local paths
 
         Keyword arguments:
-        library_path_list -- list of paths to install libraries from. Relative paths are assumed to be relative to the
-                             Docker container workspace (root of the repository)
+        library_list -- list of dictionaries defining the dependencies
         """
-        self.verbose_print("Installing libraries from paths:", list_to_string(library_path_list))
-        for library_path in library_path_list:
-            # Install the repository as a library by creating a symlink in the sketchbook
-            library_symlink_path = self.libraries_path.joinpath(library_path.name)
-            library_symlink_path.symlink_to(target=library_path, target_is_directory=True)
+        for library in library_list:
+            source_path = absolute_path(library[self.dependency_source_path_key])
+            self.verbose_print("Installing library from path:", path_relative_to_workspace(source_path))
+
+            if not source_path.exists():
+                print("::error::Library source path:", path_relative_to_workspace(source_path), "doesn't exist")
+                sys.exit(1)
+
+            # Determine library folder name (important because it is a factor in dependency resolution)
+            if self.dependency_destination_name_key in library:
+                # If a name was specified, use it
+                destination_name = library[self.dependency_destination_name_key]
+            elif (
+                source_path == pathlib.Path(os.environ["GITHUB_WORKSPACE"])
+            ):
+                # If source_path is the root of the workspace (i.e., repository root), name the folder according to the
+                # repository name, otherwise it will unexpectedly be "workspace"
+                destination_name = os.environ["GITHUB_REPOSITORY"].split(sep="/")[1]
+            else:
+                # Use the existing folder name
+                destination_name = source_path.name
+
+            # Install the library by creating a symlink in the sketchbook
+            library_symlink_path = self.libraries_path.joinpath(destination_name)
+            library_symlink_path.symlink_to(target=source_path, target_is_directory=True)
 
     def find_sketches(self):
         """Return a list of all sketches under the paths specified in the sketch paths list recursively."""

compilesketches/tests/test_compilesketches.py

@@ -308,6 +308,7 @@ def test_install_platforms(mocker, fqbn_arg, expected_platform, expected_additio
 @pytest.mark.parametrize(
     "dependency_list, expected_dependency_type_list",
     [([None], []),
+     ([{compilesketches.CompileSketches.dependency_source_path_key: "foo/bar"}], ["path"]),
      ([{compilesketches.CompileSketches.dependency_name_key: "FooBar"}], ["manager"])]
 )
 def test_sort_dependency_list(monkeypatch, dependency_list, expected_dependency_type_list):
@@ -455,16 +456,22 @@ def test_get_manager_dependency_name(dependency, expected_name):
     assert compile_sketches.get_manager_dependency_name(dependency=dependency) == expected_name
 
 
-@pytest.mark.parametrize("libraries, expected_manager",
-                         [("", []),
-                          ("foo bar", [{compilesketches.CompileSketches.dependency_name_key: "foo"},
-                                       {compilesketches.CompileSketches.dependency_name_key: "bar"}]),
-                          ("\"foo\" \"bar\"", [{compilesketches.CompileSketches.dependency_name_key: "foo"},
-                                               {compilesketches.CompileSketches.dependency_name_key: "bar"}]),
-                          ("-", []),
-                          ("- " + compilesketches.CompileSketches.dependency_name_key + ": foo",
-                           [{compilesketches.CompileSketches.dependency_name_key: "foo"}])])
-def test_install_libraries(monkeypatch, mocker, libraries, expected_manager):
+@pytest.mark.parametrize(
+    "libraries, expected_manager, expected_path",
+    [("", [], [{compilesketches.CompileSketches.dependency_source_path_key: pathlib.PurePath("/foo/GitHubWorkspace")}]),
+     ("foo bar", [{compilesketches.CompileSketches.dependency_name_key: "foo"},
+                  {compilesketches.CompileSketches.dependency_name_key: "bar"}],
+      [{compilesketches.CompileSketches.dependency_source_path_key: pathlib.PurePath("/foo/GitHubWorkspace")}]),
+     ("\"foo\" \"bar\"", [{compilesketches.CompileSketches.dependency_name_key: "foo"},
+                          {compilesketches.CompileSketches.dependency_name_key: "bar"}],
+      [{compilesketches.CompileSketches.dependency_source_path_key: pathlib.PurePath("/foo/GitHubWorkspace")}]),
+     ("-", [], []),
+     ("- " + compilesketches.CompileSketches.dependency_name_key + ": foo",
+      [{compilesketches.CompileSketches.dependency_name_key: "foo"}], []),
+     ("- " + compilesketches.CompileSketches.dependency_source_path_key + ": /foo/bar", [],
+      [{compilesketches.CompileSketches.dependency_source_path_key: "/foo/bar"}])]
+)
+def test_install_libraries(monkeypatch, mocker, libraries, expected_manager, expected_path):
     libraries_path = pathlib.Path("/foo/LibrariesPath")
 
     monkeypatch.setenv("GITHUB_WORKSPACE", "/foo/GitHubWorkspace")
@@ -488,7 +495,12 @@ def test_install_libraries(monkeypatch, mocker, libraries, expected_manager):
     else:
         compile_sketches.install_libraries_from_library_manager.assert_not_called()
 
-    compile_sketches.install_libraries_from_path.assert_called_once()
+    if len(expected_path) > 0:
+        compile_sketches.install_libraries_from_path.assert_called_once_with(
+            compile_sketches,
+            library_list=expected_path)
+    else:
+        compile_sketches.install_libraries_from_path.assert_not_called()
 
 
 def test_install_libraries_from_library_manager(mocker):
@@ -509,17 +521,56 @@ def test_install_libraries_from_library_manager(mocker):
                                                                      enable_output=run_command_output_level)
 
 
-def test_install_libraries_from_path(mocker):
-    library_path_list = [pathlib.Path("FooLibrary"), pathlib.Path("bar/Barlibrary")]
+@pytest.mark.parametrize("path_exists, library_list, expected_destination_name_list",
+                         [(False, [{compilesketches.CompileSketches.dependency_source_path_key: pathlib.Path(
+                             "/foo/GitHubWorkspace/Nonexistent")}], []),
+                          (True, [{compilesketches.CompileSketches.dependency_destination_name_key: "FooName",
+                                   compilesketches.CompileSketches.dependency_source_path_key: pathlib.Path(
+                                       "/foo/GitHubWorkspace/FooLibrary")}], ["FooName"]),
+                          (True, [{compilesketches.CompileSketches.dependency_source_path_key: pathlib.Path(
+                              "/foo/GitHubWorkspace")}], ["FooRepoName"]),
+                          (True,
+                           [{compilesketches.CompileSketches.dependency_source_path_key: pathlib.Path(
+                               "/foo/GitHubWorkspace/Bar")}], ["Bar"])])
+def test_install_libraries_from_path(capsys, monkeypatch, mocker, path_exists, library_list,
+                                     expected_destination_name_list):
+    libraries_path = pathlib.Path("/foo/LibrariesPath")
+    symlink_source_path = pathlib.Path("/foo/SymlinkSourcePath")
+
+    monkeypatch.setenv("GITHUB_WORKSPACE", "/foo/GitHubWorkspace")
+    monkeypatch.setenv("GITHUB_REPOSITORY", "foo/FooRepoName")
 
     compile_sketches = get_compilesketches_object()
+    compile_sketches.libraries_path = libraries_path
 
+    mocker.patch.object(pathlib.Path, "exists", autospec=True, return_value=path_exists)
+    mocker.patch.object(pathlib.Path, "joinpath", autospec=True, return_value=symlink_source_path)
     mocker.patch.object(pathlib.Path, "symlink_to", autospec=True)
 
-    compile_sketches.install_libraries_from_path(library_path_list=library_path_list)
+    if not path_exists:
+        with pytest.raises(expected_exception=SystemExit, match="1"):
+            compile_sketches.install_libraries_from_path(library_list=library_list)
+        assert capsys.readouterr().out.strip() == (
+            "::error::Library source path: "
+            + str(compilesketches.path_relative_to_workspace(library_list[0]["source-path"]))
+            + " doesn't exist"
+        )
 
-    # noinspection PyUnresolvedReferences
-    pathlib.Path.symlink_to.assert_called()
+    else:
+        compile_sketches.install_libraries_from_path(library_list=library_list)
+
+        joinpath_calls = []
+        symlink_to_calls = []
+        for library, expected_destination_name in zip(library_list, expected_destination_name_list):
+            joinpath_calls.append(unittest.mock.call(libraries_path, expected_destination_name))
+            symlink_to_calls.append(
+                unittest.mock.call(symlink_source_path,
+                                   target=library[compilesketches.CompileSketches.dependency_source_path_key],
+                                   target_is_directory=True))
+
+        # noinspection PyUnresolvedReferences
+        pathlib.Path.joinpath.assert_has_calls(calls=joinpath_calls)
+        pathlib.Path.symlink_to.assert_has_calls(calls=symlink_to_calls)
 
 
 def test_find_sketches(capsys, monkeypatch):