Use consistent approach to processing user-provided paths

Paths from user input are converted to absolute paths as early as possible, then those absolute paths are used from there on. If possible, the path is converted to a user-friendly path relative to the root of the repository (GITHUB_WORKSPACE) before output to the log or sketches report.

This is now more important due to the addition of support for ~, which requires processing through the absolute_path() function to work.

Author: per1234

compilesketches/compilesketches.py

@@ -111,8 +111,8 @@ def __init__(self, cli_version, fqbn_arg, platforms, libraries, sketch_paths, ve
 
         # Save the space-separated list of paths as a Python list
         sketch_paths = parse_list_input(sketch_paths)
-        sketch_paths = [pathlib.Path(sketch_path) for sketch_path in sketch_paths]
-        self.sketch_paths = sketch_paths
+        absolute_sketch_paths = [absolute_path(path=sketch_path) for sketch_path in sketch_paths]
+        self.sketch_paths = absolute_sketch_paths
 
         self.verbose = parse_boolean_input(boolean_input=verbose)
 
@@ -383,10 +383,10 @@ def install_platforms_from_path(self, platform_list):
         """
         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])
+            self.verbose_print("Installing platform from path:", path_relative_to_workspace(path=source_path))
 
             if not source_path.exists():
-                print("::error::Platform source path:", platform[self.dependency_source_path_key], "doesn't exist")
+                print("::error::Platform source path:", path_relative_to_workspace(path=source_path), "doesn't exist")
                 sys.exit(1)
 
             platform_installation_path = self.get_platform_installation_path(platform=platform)
@@ -583,7 +583,7 @@ def install_libraries(self):
 
             # 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"])}]
+            library_list.path = [{self.dependency_source_path_key: os.environ["GITHUB_WORKSPACE"]}]
 
         if len(library_list.manager) > 0:
             self.install_libraries_from_library_manager(library_list=library_list.manager)
@@ -700,36 +700,34 @@ def find_sketches(self):
         sketch_list = []
         self.verbose_print("Finding sketches under paths:", list_to_string(self.sketch_paths))
         for sketch_path in self.sketch_paths:
-            # The absolute path is used in the code, the sketch path provided by the user is used in the log output
-            absolute_sketch_path = absolute_path(sketch_path)
             sketch_path_sketch_list = []
-            if not absolute_sketch_path.exists():
-                print("::error::Sketch path:", sketch_path, "doesn't exist")
+            if not sketch_path.exists():
+                print("::error::Sketch path:", path_relative_to_workspace(path=sketch_path), "doesn't exist")
                 sys.exit(1)
 
             # Check if the specified path is a sketch (as opposed to containing sketches in subfolders)
-            if absolute_sketch_path.is_file():
-                if path_is_sketch(path=absolute_sketch_path):
+            if sketch_path.is_file():
+                if path_is_sketch(path=sketch_path):
                     # The path directly to a sketch file was provided, so don't search recursively
-                    sketch_list.append(absolute_sketch_path.parent)
+                    sketch_list.append(sketch_path.parent)
                     continue
                 else:
-                    print("::error::Sketch path:", sketch_path, "is not a sketch")
+                    print("::error::Sketch path:", path_relative_to_workspace(path=sketch_path), "is not a sketch")
                     sys.exit(1)
             else:
                 # Path is a directory
-                if path_is_sketch(path=absolute_sketch_path):
+                if path_is_sketch(path=sketch_path):
                     # Add sketch to list, but also search the path recursively for more sketches
-                    sketch_path_sketch_list.append(absolute_sketch_path)
+                    sketch_path_sketch_list.append(sketch_path)
 
             # Search the sketch path recursively for sketches
-            for sketch in sorted(absolute_sketch_path.rglob("*")):
+            for sketch in sorted(sketch_path.rglob("*")):
                 if sketch.is_dir() and path_is_sketch(path=sketch):
                     sketch_path_sketch_list.append(sketch)
 
             if len(sketch_path_sketch_list) == 0:
                 # If a path provided via the sketch-paths input doesn't contain sketches, that indicates user error
-                print("::error::No sketches were found in", sketch_path)
+                print("::error::No sketches were found in", path_relative_to_workspace(path=sketch_path))
                 sys.exit(1)
 
             sketch_list.extend(sketch_path_sketch_list)
@@ -751,12 +749,12 @@ def compile_sketch(self, sketch_path):
             command=compilation_command, enable_output=self.RunCommandOutput.NONE, exit_on_failure=False)
         # Group compilation output to make the log easy to read
         # https://github.com/actions/toolkit/blob/master/docs/commands.md#group-and-ungroup-log-lines
-        print("::group::Compiling sketch:", path_relative_to_workspace(sketch_path))
+        print("::group::Compiling sketch:", path_relative_to_workspace(path=sketch_path))
         print(compilation_data.stdout)
         print("::endgroup::")
 
         class CompilationResult:
-            sketch = path_relative_to_workspace(sketch_path)
+            sketch = sketch_path
             success = compilation_data.returncode == 0
             output = compilation_data.stdout
 
@@ -795,7 +793,7 @@ def get_sketch_report(self, compilation_result):
 
             # Compile the sketch again
             print("Compiling previous version of sketch to determine memory usage change")
-            previous_compilation_result = self.compile_sketch(sketch_path=absolute_path(path=compilation_result.sketch))
+            previous_compilation_result = self.compile_sketch(sketch_path=compilation_result.sketch)
 
             # git checkout the PR's head ref to return the repository to its previous state
             repository.git.checkout(original_git_ref)
@@ -824,7 +822,7 @@ def get_sketch_report_from_output(self, compilation_result):
         ram_regex = r"Global variables use [0-9]+ bytes .*of dynamic memory"
 
         # Set default report values
-        sketch_report = {self.report_sketch_key: str(compilation_result.sketch),
+        sketch_report = {self.report_sketch_key: str(path_relative_to_workspace(path=compilation_result.sketch)),
                          self.report_compilation_success_key: compilation_result.success,
                          self.report_flash_key: self.not_applicable_indicator,
                          self.report_ram_key: self.not_applicable_indicator}

compilesketches/tests/test_compilesketches.py

@@ -153,8 +153,8 @@ def test_compilesketches():
     platforms = unittest.mock.sentinel.platforms
     libraries = unittest.mock.sentinel.libraries
     sketch_paths = "examples/FooSketchPath examples/BarSketchPath"
-    expected_sketch_paths_list = [pathlib.PurePath("examples/FooSketchPath"),
-                                  pathlib.PurePath("examples/BarSketchPath")]
+    expected_sketch_paths_list = [compilesketches.absolute_path(path="examples/FooSketchPath"),
+                                  compilesketches.absolute_path(path="examples/BarSketchPath")]
     verbose = "false"
     github_token = "fooGitHubToken"
     report_sketch = unittest.mock.sentinel.report_sketch
@@ -771,19 +771,19 @@ def __init__(self):
     "libraries, expected_manager, expected_path, expected_repository, expected_download",
     [("",
       [],
-      [{compilesketches.CompileSketches.dependency_source_path_key: pathlib.PurePath(os.environ["GITHUB_WORKSPACE"])}],
+      [{compilesketches.CompileSketches.dependency_source_path_key: os.environ["GITHUB_WORKSPACE"]}],
       [],
       []),
      ("foo bar",
       [{compilesketches.CompileSketches.dependency_name_key: "foo"},
        {compilesketches.CompileSketches.dependency_name_key: "bar"}],
-      [{compilesketches.CompileSketches.dependency_source_path_key: pathlib.PurePath(os.environ["GITHUB_WORKSPACE"])}],
+      [{compilesketches.CompileSketches.dependency_source_path_key: os.environ["GITHUB_WORKSPACE"]}],
       [],
       []),
      ("\"foo\" \"bar\"",
       [{compilesketches.CompileSketches.dependency_name_key: "foo"},
        {compilesketches.CompileSketches.dependency_name_key: "bar"}],
-      [{compilesketches.CompileSketches.dependency_source_path_key: pathlib.PurePath(os.environ["GITHUB_WORKSPACE"])}],
+      [{compilesketches.CompileSketches.dependency_source_path_key: os.environ["GITHUB_WORKSPACE"]}],
       [],
       []),
      ("-",
@@ -925,8 +925,7 @@ def test_install_libraries_from_path(capsys, monkeypatch, mocker, path_exists, l
             symlink_to_calls.append(
                 unittest.mock.call(symlink_source_path,
                                    target=compilesketches.absolute_path(
-                                       library[compilesketches.CompileSketches.dependency_source_path_key]
-                                   ),
+                                       library[compilesketches.CompileSketches.dependency_source_path_key]),
                                    target_is_directory=True))
 
         # noinspection PyUnresolvedReferences
@@ -1011,8 +1010,11 @@ def test_find_sketches(capsys):
     )
     with pytest.raises(expected_exception=SystemExit, match="1"):
         compile_sketches.find_sketches()
-    assert capsys.readouterr().out.strip() == ("::error::Sketch path: " + str(pathlib.PurePath(nonexistent_sketch_path))
-                                               + " doesn't exist")
+    assert capsys.readouterr().out.strip() == (
+        "::error::Sketch path: "
+        + str(compilesketches.path_relative_to_workspace(path=nonexistent_sketch_path))
+        + " doesn't exist"
+    )
 
     # Test sketch path is a sketch file
     compile_sketches = get_compilesketches_object(
@@ -1080,7 +1082,7 @@ def test_path_is_sketch():
                                                           (0, True)])
 def test_compile_sketch(capsys, mocker, returncode, expected_success):
     stdout = unittest.mock.sentinel.stdout
-    relative_sketch_path = pathlib.PurePath("FooSketch", "FooSketch.ino")
+    sketch_path = pathlib.Path("FooSketch", "FooSketch.ino").resolve()
 
     # Stub
     class CompilationData:
@@ -1095,19 +1097,19 @@ class CompilationData:
                  return_value=CompilationData())
 
     compilation_result = compile_sketches.compile_sketch(
-        sketch_path=pathlib.PurePath(os.environ["GITHUB_WORKSPACE"]).joinpath(relative_sketch_path)
+        sketch_path=sketch_path
     )
 
     expected_stdout = (
-        "::group::Compiling sketch: " + str(relative_sketch_path) + "\n"
+        "::group::Compiling sketch: " + str(compilesketches.path_relative_to_workspace(path=sketch_path)) + "\n"
         + str(stdout) + "\n"
         + "::endgroup::"
     )
     if not expected_success:
         expected_stdout += "\n::error::Compilation failed"
     assert capsys.readouterr().out.strip() == expected_stdout
 
-    assert compilation_result.sketch == relative_sketch_path
+    assert compilation_result.sketch == sketch_path
     assert compilation_result.success == expected_success
     assert compilation_result.output == stdout
 
@@ -1124,7 +1126,6 @@ def __init__(self, sketch_input):
 
     compilation_result = CompilationResult(sketch_input=sketch)
 
-    sketch_absolute_path = unittest.mock.sentinel.sketch_absolute_path
     previous_compilation_result = unittest.mock.sentinel.previous_compilation_result
     sketch_size = unittest.mock.sentinel.sketch_size
 
@@ -1148,7 +1149,6 @@ def checkout(self):
                  return_value=do_size_deltas_report)
     mocker.patch("git.Repo", autospec=True, return_value=Repo())
     mocker.patch("compilesketches.CompileSketches.checkout_pull_request_base_ref", autospec=True)
-    mocker.patch("compilesketches.absolute_path", autospec=True, return_value=sketch_absolute_path)
     mocker.patch("compilesketches.CompileSketches.compile_sketch", autospec=True,
                  return_value=previous_compilation_result)
     mocker.patch.object(Repo, "checkout")
@@ -1162,8 +1162,7 @@ def checkout(self):
     if do_size_deltas_report:
         git.Repo.assert_called_once_with(path=os.environ["GITHUB_WORKSPACE"])
         compile_sketches.checkout_pull_request_base_ref.assert_called_once()
-        compilesketches.absolute_path.assert_called_once_with(path=compilation_result.sketch)
-        compile_sketches.compile_sketch.assert_called_once_with(compile_sketches, sketch_path=sketch_absolute_path)
+        compile_sketches.compile_sketch.assert_called_once_with(compile_sketches, sketch_path=compilation_result.sketch)
         Repo.checkout.assert_called_once_with(original_git_ref)
         get_sketch_size_from_output_calls.append(
             unittest.mock.call(compile_sketches, compilation_result=previous_compilation_result))
@@ -1269,11 +1268,11 @@ def checkout(self):
       get_compilesketches_object().not_applicable_indicator)]
 )
 def test_get_sketch_report_from_output(compilation_success, compilation_output, flash, ram):
-    sketch_path = unittest.mock.sentinel.sketch
+    sketch_path = pathlib.PurePath("foo/bar")
     compilation_output = compilation_output.format(flash=str(flash), ram=str(ram))
     compile_sketches = get_compilesketches_object()
     compilation_result = type("CompilationResult", (),
-                              {compile_sketches.report_sketch_key: sketch_path,
+                              {"sketch": sketch_path,
                                "success": compilation_success,
                                "output": compilation_output})