Support YAML-format sketch-paths input value

The other two inputs that accept lists: `libraries` and `platforms`, support the value being a string in YAML format, following the precedent established by GitHub for their workflows.

For consistency, it makes sense to also support YAML format for the action's `sketch-paths` input.

Author: per1234

README.md

@@ -102,7 +102,7 @@ Keys:
 
 ### `sketch-paths`
 
-List of paths containing sketches to compile. These paths will be searched recursively. Default `"examples"`.
+YAML-format list of paths containing sketches to compile. These paths will be searched recursively. Default `- examples`.
 
 ### `verbose`
 

action.yml

@@ -15,7 +15,7 @@ inputs:
     default: ''
   sketch-paths:
     description: 'List of paths containing sketches to compile.'
-    default: 'examples'
+    default: '- examples'
   verbose:
     description: 'Set to true to show verbose output in the log'
     default: false

compilesketches/compilesketches.py

@@ -117,8 +117,8 @@ def __init__(self, cli_version, fqbn_arg, platforms, libraries, sketch_paths, ve
         self.libraries = libraries
 
         # Save the space-separated list of paths as a Python list
-        sketch_paths = parse_list_input(sketch_paths)
-        absolute_sketch_paths = [absolute_path(path=sketch_path) for sketch_path in sketch_paths]
+        sketch_paths = get_list_from_multiformat_input(input_value=sketch_paths)
+        absolute_sketch_paths = [absolute_path(path=sketch_path) for sketch_path in sketch_paths.value]
         self.sketch_paths = absolute_sketch_paths
 
         self.verbose = parse_boolean_input(boolean_input=verbose)
@@ -596,21 +596,16 @@ def install_platforms_from_download(self, platform_list):
 
     def install_libraries(self):
         """Install Arduino libraries."""
-        libraries = yaml.load(stream="", Loader=yaml.SafeLoader)
-        try:
-            libraries = yaml.load(stream=self.libraries, Loader=yaml.SafeLoader)
-        except yaml.parser.ParserError:
-            # This exception occurs when the space separated list items are individually quoted (e.g., '"Foo" "Bar"')
-            pass
+        libraries = get_list_from_multiformat_input(input_value=self.libraries)
 
         library_list = self.Dependencies()
-        if type(libraries) is list:
+        if libraries.was_yaml_list:
             # libraries input is YAML
-            library_list = self.sort_dependency_list(libraries)
+            library_list = self.sort_dependency_list(libraries.value)
         else:
             # libraries input uses the old space-separated list syntax
             library_list.manager = [{self.dependency_name_key: library_name}
-                                    for library_name in parse_list_input(self.libraries)]
+                                    for library_name in libraries.value]
 
             # 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
@@ -1261,6 +1256,46 @@ def absolute_path(path):
     return path
 
 
+def get_list_from_multiformat_input(input_value):
+    """For backwards compatibility with the legacy API, some inputs support a space-separated list format in addition to
+    the modern YAML format. This function converts either input format into a list and returns an object with the
+    attributes:
+    value -- the list that was parsed from the input
+    was_yaml_list -- whether the input was in YAML format (True, False)
+
+    Keyword arguments:
+    input_value -- the raw input
+    """
+
+    class InputList:
+        def __init__(self):
+            self.value = []
+            self.was_yaml_list = False
+
+    input_list = InputList()
+
+    try:
+        processed_input_value = yaml.load(stream=input_value, Loader=yaml.SafeLoader)
+    except yaml.parser.ParserError:
+        # The input value was not valid YAML
+        # This exception occurs when the space separated list items are individually quoted (e.g., '"Foo" "Bar"')
+        # Note: some old format list values are also valid YAML by chance (e.g., a normal string), so old format input
+        # won't always cause this exception
+        processed_input_value = input_value
+        pass
+
+    if type(processed_input_value) is list:
+        # The input value was valid YAML and in list format
+        input_list.value = processed_input_value
+        input_list.was_yaml_list = True
+    else:
+        # The input value was either valid YAML, but not a list, or invalid YAML
+        input_list.value = parse_list_input(list_input=input_value)
+        input_list.was_yaml_list = False
+
+    return input_list
+
+
 def path_is_sketch(path):
     """Return whether the specified path is an Arduino sketch.
 

compilesketches/tests/test_compilesketches.py

@@ -1101,30 +1101,30 @@ def test_find_sketches(capsys):
 
     # Test sketch path is a sketch file
     compile_sketches = get_compilesketches_object(
-        sketch_paths="\"" + str(test_data_path.joinpath("HasSketches", "Sketch1", "Sketch1.ino")) + "\""
+        sketch_paths="\'" + str(test_data_path.joinpath("HasSketches", "Sketch1", "Sketch1.ino")) + "\'"
     )
     assert compile_sketches.find_sketches() == [
         test_data_path.joinpath("HasSketches", "Sketch1")
     ]
 
     # Test sketch path is a non-sketch file
     non_sketch_path = str(test_data_path.joinpath("NoSketches", "NotSketch", "NotSketch.foo"))
-    compile_sketches = get_compilesketches_object(sketch_paths="\"" + non_sketch_path + "\"")
+    compile_sketches = get_compilesketches_object(sketch_paths="\'" + non_sketch_path + "\'")
     with pytest.raises(expected_exception=SystemExit, match="1"):
         compile_sketches.find_sketches()
     assert capsys.readouterr().out.strip() == ("::error::Sketch path: " + non_sketch_path + " is not a sketch")
 
     # Test sketch path is a sketch folder
     compile_sketches = get_compilesketches_object(
-        sketch_paths="\"" + str(test_data_path.joinpath("HasSketches", "Sketch1")) + "\""
+        sketch_paths="\'" + str(test_data_path.joinpath("HasSketches", "Sketch1")) + "\'"
     )
     assert compile_sketches.find_sketches() == [
         test_data_path.joinpath("HasSketches", "Sketch1")
     ]
 
     # Test sketch path does contain sketches
     compile_sketches = get_compilesketches_object(
-        sketch_paths="\"" + str(test_data_path.joinpath("HasSketches")) + "\"")
+        sketch_paths="\'" + str(test_data_path.joinpath("HasSketches")) + "\'")
     assert compile_sketches.find_sketches() == [
         test_data_path.joinpath("HasSketches", "Sketch1"),
         test_data_path.joinpath("HasSketches", "Sketch2")
@@ -1133,13 +1133,27 @@ def test_find_sketches(capsys):
     # Test sketch path doesn't contain any sketches
     no_sketches_path = str(test_data_path.joinpath("NoSketches"))
     compile_sketches = get_compilesketches_object(
-        sketch_paths="\"" + no_sketches_path + "\"")
+        sketch_paths="\'" + no_sketches_path + "\'")
     with pytest.raises(expected_exception=SystemExit, match="1"):
         compile_sketches.find_sketches()
     assert capsys.readouterr().out.strip() == ("::error::No sketches were found in "
                                                + no_sketches_path)
 
 
+@pytest.mark.parametrize(
+    "input_value, expected_list, expected_was_yaml_list",
+    [("", [], False),
+     ("foo", ["foo"], False),
+     ("\'\"foo bar\" baz\'", ["foo bar", "baz"], False),
+     ("foo: bar", ["foo:", "bar"], False),
+     ("-", [None], True),
+     ("- foo: asdf\n  bar: qwer\n- baz: zxcv", [{"foo": "asdf", "bar": "qwer"}, {"baz": "zxcv"}], True)])
+def test_get_list_from_multiformat_input(input_value, expected_list, expected_was_yaml_list):
+    input_list = compilesketches.get_list_from_multiformat_input(input_value=input_value)
+    assert input_list.value == expected_list
+    assert input_list.was_yaml_list == expected_was_yaml_list
+
+
 def test_path_is_sketch():
     # Sketch file
     assert compilesketches.path_is_sketch(path=test_data_path.joinpath("HasSketches", "Sketch1", "Sketch1.ino")) is True