Support stdin for instancefiles using '-'

- instancefiles are read using `click.File("rb")`
- the resulting IO objects are passed around, rather than the
  filenames or path objects
- tests need to account for this change in the InstanceLoader

Author: sirosen

src/check_jsonschema/checker.py

@@ -47,7 +47,7 @@ def _fail(self, msg: str, err: Exception | None = None) -> t.NoReturn:
         raise _Exit(1)
 
     def get_validator(
-        self, path: pathlib.Path, doc: dict[str, t.Any]
+        self, path: pathlib.Path | str, doc: dict[str, t.Any]
     ) -> jsonschema.protocols.Validator:
         try:
             return self._schema_loader.get_validator(

src/check_jsonschema/cli/main_command.py

@@ -2,6 +2,7 @@
 
 import os
 import textwrap
+import typing as t
 
 import click
 import jsonschema
@@ -217,7 +218,7 @@ def pretty_helptext_list(values: list[str] | tuple[str, ...]) -> str:
     help="Reduce output verbosity",
     count=True,
 )
-@click.argument("instancefiles", required=True, nargs=-1)
+@click.argument("instancefiles", required=True, nargs=-1, type=click.File("rb"))
 def main(
     *,
     schemafile: str | None,
@@ -236,7 +237,7 @@ def main(
     output_format: str,
     verbose: int,
     quiet: int,
-    instancefiles: tuple[str, ...],
+    instancefiles: tuple[t.BinaryIO, ...],
 ) -> None:
     args = ParseResult()
 

src/check_jsonschema/cli/parse_result.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import enum
+import typing as t
 
 import click
 import jsonschema
@@ -21,7 +22,7 @@ def __init__(self) -> None:
         self.schema_mode: SchemaLoadingMode = SchemaLoadingMode.filepath
         self.schema_path: str | None = None
         self.base_uri: str | None = None
-        self.instancefiles: tuple[str, ...] = ()
+        self.instancefiles: tuple[t.BinaryIO, ...] = ()
         # cache controls
         self.disable_cache: bool = False
         self.cache_filename: str | None = None

src/check_jsonschema/instance_loader.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import pathlib
 import typing as t
 
 from .parsers import ParseError, ParserSet
@@ -10,11 +9,11 @@
 class InstanceLoader:
     def __init__(
         self,
-        filenames: t.Sequence[str],
+        files: t.Sequence[t.BinaryIO],
         default_filetype: str = "json",
         data_transform: Transform | None = None,
     ) -> None:
-        self._filenames = filenames
+        self._files = files
         self._default_filetype = default_filetype
         self._data_transform = (
             data_transform if data_transform is not None else Transform()
@@ -24,13 +23,16 @@ def __init__(
             modify_yaml_implementation=self._data_transform.modify_yaml_implementation
         )
 
-    def iter_files(self) -> t.Iterator[tuple[pathlib.Path, ParseError | t.Any]]:
-        for fn in self._filenames:
-            path = pathlib.Path(fn)
+    def iter_files(self) -> t.Iterator[tuple[str, ParseError | t.Any]]:
+        for file in self._files:
+            if not hasattr(file, "name"):
+                raise ValueError(f"File {file} has no name attribute")
             try:
-                data: t.Any = self._parsers.parse_file(path, self._default_filetype)
+                data: t.Any = self._parsers.parse_data_with_path(
+                    file, file.name, self._default_filetype
+                )
             except ParseError as err:
                 data = err
             else:
                 data = self._data_transform(data)
-            yield (path, data)
+            yield (file.name, data)

src/check_jsonschema/result.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import pathlib
 
 import jsonschema
@@ -15,18 +17,18 @@ def __init__(self) -> None:
     def success(self) -> bool:
         return not (bool(self.parse_errors) or bool(self.validation_errors))
 
-    def record_validation_success(self, path: pathlib.Path) -> None:
+    def record_validation_success(self, path: pathlib.Path | str) -> None:
         self.successes.append(str(path))
 
     def record_validation_error(
-        self, path: pathlib.Path, err: jsonschema.ValidationError
+        self, path: pathlib.Path | str, err: jsonschema.ValidationError
     ) -> None:
         filename = str(path)
         if filename not in self.validation_errors:
             self.validation_errors[filename] = []
         self.validation_errors[filename].append(err)
 
-    def record_parse_error(self, path: pathlib.Path, err: ParseError) -> None:
+    def record_parse_error(self, path: pathlib.Path | str, err: ParseError) -> None:
         filename = str(path)
         if filename not in self.parse_errors:
             self.parse_errors[filename] = []

src/check_jsonschema/schema_loader/main.py

@@ -47,7 +47,7 @@ def set_defaults_then_validate(
 class SchemaLoaderBase:
     def get_validator(
         self,
-        path: pathlib.Path,
+        path: pathlib.Path | str,
         instance_doc: dict[str, t.Any],
         format_opts: FormatOptions,
         fill_defaults: bool,
@@ -117,7 +117,7 @@ def get_schema(self) -> dict[str, t.Any]:
 
     def get_validator(
         self,
-        path: pathlib.Path,
+        path: pathlib.Path | str,
         instance_doc: dict[str, t.Any],
         format_opts: FormatOptions,
         fill_defaults: bool,
@@ -189,7 +189,7 @@ def __init__(self, base_uri: str | None = None) -> None:
 
     def get_validator(
         self,
-        path: pathlib.Path,
+        path: pathlib.Path | str,
         instance_doc: dict[str, t.Any],
         format_opts: FormatOptions,
         fill_defaults: bool,

tests/conftest.py

@@ -1,3 +1,4 @@
+import os
 import pathlib
 import sys
 
@@ -38,3 +39,10 @@ def func(path, text):
     for name in all_names_to_clear:
         if name in sys.modules:
             del sys.modules[name]
+
+
+@pytest.fixture
+def in_tmp_dir(request, tmp_path):
+    os.chdir(str(tmp_path))
+    yield
+    os.chdir(request.config.invocation_dir)

tests/unit/test_cli_parse.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import io
 from unittest import mock
 
 import click
@@ -14,6 +15,11 @@ class BoxedContext:
     ref = None
 
 
+def touch_files(dirpath, *filenames):
+    for fname in filenames:
+        (dirpath / fname).touch()
+
+
 @pytest.fixture
 def boxed_context():
     return BoxedContext()
@@ -73,19 +79,24 @@ def test_requires_some_args(runner):
     assert result.exit_code == 2
 
 
-def test_schemafile_and_instancefile(runner, mock_parse_result):
+def test_schemafile_and_instancefile(runner, mock_parse_result, in_tmp_dir, tmp_path):
+    touch_files(tmp_path, "foo.json")
     runner.invoke(cli_main, ["--schemafile", "schema.json", "foo.json"])
     assert mock_parse_result.schema_mode == SchemaLoadingMode.filepath
     assert mock_parse_result.schema_path == "schema.json"
-    assert mock_parse_result.instancefiles == ("foo.json",)
+    assert isinstance(mock_parse_result.instancefiles, tuple)
+    for f in mock_parse_result.instancefiles:
+        assert isinstance(f, (io.BytesIO, io.BufferedReader))
+    assert tuple(f.name for f in mock_parse_result.instancefiles) == ("foo.json",)
 
 
 def test_requires_at_least_one_instancefile(runner):
     result = runner.invoke(cli_main, ["--schemafile", "schema.json"])
     assert result.exit_code == 2
 
 
-def test_requires_schemafile(runner):
+def test_requires_schemafile(runner, in_tmp_dir, tmp_path):
+    touch_files(tmp_path, "foo.json")
     result = runner.invoke(cli_main, ["foo.json"])
     assert result.exit_code == 2
 
@@ -95,7 +106,8 @@ def test_no_cache_defaults_false(runner, mock_parse_result):
     assert mock_parse_result.disable_cache is False
 
 
-def test_no_cache_flag_is_true(runner, mock_parse_result):
+def test_no_cache_flag_is_true(runner, mock_parse_result, in_tmp_dir, tmp_path):
+    touch_files(tmp_path, "foo.json")
     runner.invoke(cli_main, ["--schemafile", "schema.json", "foo.json", "--no-cache"])
     assert mock_parse_result.disable_cache is True
 
@@ -108,32 +120,29 @@ def test_no_cache_flag_is_true(runner, mock_parse_result):
             "x.json",
             "--builtin-schema",
             "vendor.travis",
-            "foo.json",
         ],
         [
             "--schemafile",
             "x.json",
             "--builtin-schema",
             "vendor.travis",
             "--check-metaschema",
-            "foo.json",
         ],
         [
             "--schemafile",
             "x.json",
             "--check-metaschema",
-            "foo.json",
         ],
         [
             "--builtin-schema",
             "vendor.travis",
             "--check-metaschema",
-            "foo.json",
         ],
     ],
 )
-def test_mutex_schema_opts(runner, cmd_args):
-    result = runner.invoke(cli_main, cmd_args)
+def test_mutex_schema_opts(runner, cmd_args, in_tmp_dir, tmp_path):
+    touch_files(tmp_path, "foo.json")
+    result = runner.invoke(cli_main, cmd_args + ["foo.json"])
     assert result.exit_code == 2
     assert "are mutually exclusive" in result.stderr
 
@@ -154,12 +163,15 @@ def test_supports_common_option(runner, cmd_args):
 @pytest.mark.parametrize(
     "setting,expect_value", [(None, None), ("1", False), ("0", False)]
 )
-def test_no_color_env_var(runner, monkeypatch, setting, expect_value, boxed_context):
+def test_no_color_env_var(
+    runner, monkeypatch, setting, expect_value, boxed_context, in_tmp_dir, tmp_path
+):
     if setting is None:
         monkeypatch.delenv("NO_COLOR", raising=False)
     else:
         monkeypatch.setenv("NO_COLOR", setting)
 
+    touch_files(tmp_path, "foo.json")
     runner.invoke(cli_main, ["--schemafile", "schema.json", "foo.json"])
     assert boxed_context.ref.color == expect_value
 
@@ -168,18 +180,22 @@ def test_no_color_env_var(runner, monkeypatch, setting, expect_value, boxed_cont
     "setting,expected_value",
     [(None, None), ("auto", None), ("always", True), ("never", False)],
 )
-def test_color_cli_option(runner, setting, expected_value, boxed_context):
+def test_color_cli_option(
+    runner, setting, expected_value, boxed_context, in_tmp_dir, tmp_path
+):
     args = ["--schemafile", "schema.json", "foo.json"]
     if setting:
         args.extend(("--color", setting))
+    touch_files(tmp_path, "foo.json")
     runner.invoke(cli_main, args)
     assert boxed_context.ref.color == expected_value
 
 
 def test_no_color_env_var_overrides_cli_option(
-    runner, monkeypatch, mock_cli_exec, boxed_context
+    runner, monkeypatch, mock_cli_exec, boxed_context, in_tmp_dir, tmp_path
 ):
     monkeypatch.setenv("NO_COLOR", "1")
+    touch_files(tmp_path, "foo.json")
     runner.invoke(
         cli_main, ["--color=always", "--schemafile", "schema.json", "foo.json"]
     )
@@ -190,16 +206,21 @@ def test_no_color_env_var_overrides_cli_option(
     "setting,expected_value",
     [("auto", 0), ("always", 0), ("never", 0), ("anything_else", 2)],
 )
-def test_color_cli_option_is_choice(runner, setting, expected_value):
+def test_color_cli_option_is_choice(
+    runner, setting, expected_value, in_tmp_dir, tmp_path
+):
+    touch_files(tmp_path, "foo.json")
     assert (
         runner.invoke(
-            cli_main, ["--color", setting, "--schemafile", "schema.json", "foo.json"]
+            cli_main,
+            ["--color", setting, "--schemafile", "schema.json", "foo.json"],
         ).exit_code
         == expected_value
     )
 
 
-def test_formats_default_to_enabled(runner, mock_parse_result):
+def test_formats_default_to_enabled(runner, mock_parse_result, in_tmp_dir, tmp_path):
+    touch_files(tmp_path, "foo.json")
     runner.invoke(cli_main, ["--schemafile", "schema.json", "foo.json"])
     assert mock_parse_result.disable_all_formats is False
     assert mock_parse_result.disable_formats == ()
@@ -217,7 +238,10 @@ def test_formats_default_to_enabled(runner, mock_parse_result):
         ["--disable-formats", "uri-reference,date-time"],
     ),
 )
-def test_disable_selected_formats(runner, mock_parse_result, addargs):
+def test_disable_selected_formats(
+    runner, mock_parse_result, addargs, in_tmp_dir, tmp_path
+):
+    touch_files(tmp_path, "foo.json")
     runner.invoke(
         cli_main,
         [
@@ -246,7 +270,8 @@ def test_disable_selected_formats(runner, mock_parse_result, addargs):
         ["--disable-formats", "*,email"],
     ),
 )
-def test_disable_all_formats(runner, mock_parse_result, addargs):
+def test_disable_all_formats(runner, mock_parse_result, addargs, in_tmp_dir, tmp_path):
+    touch_files(tmp_path, "foo.json")
     # this should be an override, with or without other args
     runner.invoke(
         cli_main,
@@ -260,10 +285,13 @@ def test_disable_all_formats(runner, mock_parse_result, addargs):
     assert mock_parse_result.disable_all_formats is True
 
 
-def test_can_specify_custom_validator_class(runner, mock_parse_result, mock_module):
+def test_can_specify_custom_validator_class(
+    runner, mock_parse_result, mock_module, in_tmp_dir, tmp_path
+):
     mock_module("foo.py", "class MyValidator: pass")
     import foo
 
+    touch_files(tmp_path, "foo.json")
     result = runner.invoke(
         cli_main,
         [
@@ -281,7 +309,9 @@ def test_can_specify_custom_validator_class(runner, mock_parse_result, mock_modu
 @pytest.mark.parametrize(
     "failmode", ("syntax", "import", "attr", "function", "non_callable")
 )
-def test_custom_validator_class_fails(runner, mock_parse_result, mock_module, failmode):
+def test_custom_validator_class_fails(
+    runner, mock_parse_result, mock_module, failmode, in_tmp_dir, tmp_path
+):
     mock_module(
         "foo.py",
         """\
@@ -307,6 +337,7 @@ def validator_func(*args, **kwargs):
     else:
         raise NotImplementedError
 
+    touch_files(tmp_path, "foo.json")
     result = runner.invoke(
         cli_main,
         ["--schemafile", "schema.json", "foo.json", "--validator-class", arg],