Add a strict argument to the JSONPath CLI

Author: jg-rp

jsonpath/cli.py

@@ -19,8 +19,6 @@ def path_sub_command(parser: argparse.ArgumentParser) -> None:  # noqa: D103
     parser.set_defaults(func=handle_path_command)
     group = parser.add_mutually_exclusive_group(required=True)
 
-    # TODO: add "strict" argument
-
     group.add_argument(
         "-q",
         "--query",
@@ -62,6 +60,15 @@ def path_sub_command(parser: argparse.ArgumentParser) -> None:  # noqa: D103
         help="Disables filter expression well-typedness checks.",
     )
 
+    parser.add_argument(
+        "--strict",
+        action="store_true",
+        help=(
+            "Compile and evaluate JSONPath expressions with strict "
+            "compliance with RFC 9535."
+        ),
+    )
+
 
 def pointer_sub_command(parser: argparse.ArgumentParser) -> None:  # noqa: D103
     parser.set_defaults(func=handle_pointer_command)
@@ -251,6 +258,7 @@ def handle_path_command(args: argparse.Namespace) -> None:  # noqa: PLR0912
         path = jsonpath.JSONPathEnvironment(
             unicode_escape=not args.no_unicode_escape,
             well_typed=not args.no_type_checks,
+            strict=args.strict,
         ).compile(query)
     except JSONPathSyntaxError as err:
         if args.debug:

tests/test_cli.py

@@ -1,4 +1,5 @@
 """Test cases for the command line interface."""
+
 import argparse
 import json
 import pathlib
@@ -291,6 +292,50 @@ def test_json_path(
         assert len(json.load(fd)) == 4  # noqa: PLR2004
 
 
+def test_json_path_strict(
+    parser: argparse.ArgumentParser,
+    sample_target: str,
+    outfile: str,
+) -> None:
+    """Test a valid JSONPath."""
+    args = parser.parse_args(
+        [
+            "--debug",
+            "path",
+            "-q",
+            "price_cap",  # No root identifier is an error in strict mode.
+            "-f",
+            sample_target,
+            "-o",
+            outfile,
+            "--strict",
+        ]
+    )
+
+    with pytest.raises(JSONPathSyntaxError):
+        handle_path_command(args)
+
+    args = parser.parse_args(
+        [
+            "path",
+            "-q",
+            "$.price_cap",  # With a root identifier is OK.
+            "-f",
+            sample_target,
+            "-o",
+            outfile,
+            "--strict",
+        ]
+    )
+
+    handle_path_command(args)
+    args.output.flush()
+
+    with open(outfile, "r") as fd:
+        rv = json.load(fd)
+        assert rv == [10]
+
+
 def test_pointer_command_invalid_target(
     parser: argparse.ArgumentParser,
     invalid_target: str,

tests/test_convenience_api.py

@@ -1 +1,104 @@
-# TODO:
+import asyncio
+from typing import List
+
+import pytest
+
+import jsonpath
+
+
+def test_convenience_compile() -> None:
+    # Implicit root identifier works by default, but not when strict=True.
+    path = jsonpath.compile("a.*")
+    assert isinstance(path, jsonpath.JSONPath)
+    assert path.findall({"a": [1, 2, 3]}) == [1, 2, 3]
+
+
+def test_convenience_compile_strict() -> None:
+    with pytest.raises(jsonpath.JSONPathSyntaxError):
+        jsonpath.compile("a.*", strict=True)
+
+    path = jsonpath.compile("$.a.*", strict=True)
+    assert isinstance(path, jsonpath.JSONPath)
+    assert path.findall({"a": [1, 2, 3]}) == [1, 2, 3]
+
+
+def test_convenience_findall() -> None:
+    assert jsonpath.findall("a.*", {"a": [1, 2, 3]}) == [1, 2, 3]
+
+
+def test_convenience_findall_strict() -> None:
+    with pytest.raises(jsonpath.JSONPathSyntaxError):
+        jsonpath.findall("a.*", {"a": [1, 2, 3]}, strict=True)
+
+    assert jsonpath.findall("$.a.*", {"a": [1, 2, 3]}, strict=True) == [1, 2, 3]
+
+
+def test_convenience_findall_async() -> None:
+    async def coro() -> List[object]:
+        return await jsonpath.findall_async("a.*", {"a": [1, 2, 3]})
+
+    assert asyncio.run(coro()) == [1, 2, 3]
+
+
+def test_convenience_findall_async_strict() -> None:
+    async def coro() -> List[object]:
+        with pytest.raises(jsonpath.JSONPathSyntaxError):
+            await jsonpath.findall_async("a.*", {"a": [1, 2, 3]}, strict=True)
+
+        return await jsonpath.findall_async("$.a.*", {"a": [1, 2, 3]}, strict=True)
+
+    assert asyncio.run(coro()) == [1, 2, 3]
+
+
+def test_convenience_finditer() -> None:
+    matches = list(jsonpath.finditer("a.*", {"a": [1, 2, 3]}))
+    assert [m.obj for m in matches] == [1, 2, 3]
+
+
+def test_convenience_finditer_strict() -> None:
+    with pytest.raises(jsonpath.JSONPathSyntaxError):
+        list(jsonpath.finditer("a.*", {"a": [1, 2, 3]}, strict=True))
+
+    matches = list(jsonpath.finditer("$.a.*", {"a": [1, 2, 3]}, strict=True))
+    assert [m.obj for m in matches] == [1, 2, 3]
+
+
+def test_convenience_finditer_async_strict() -> None:
+    async def coro() -> List[object]:
+        with pytest.raises(jsonpath.JSONPathSyntaxError):
+            await jsonpath.finditer_async("a.*", {"a": [1, 2, 3]}, strict=True)
+
+        it = await jsonpath.finditer_async("$.a.*", {"a": [1, 2, 3]}, strict=True)
+        return [m.obj async for m in it]
+
+    assert asyncio.run(coro()) == [1, 2, 3]
+
+
+def test_convenience_match() -> None:
+    match = jsonpath.match("a.*", {"a": [1, 2, 3]})
+    assert isinstance(match, jsonpath.JSONPathMatch)
+    assert match.obj == 1
+
+
+def test_convenience_match_strict() -> None:
+    with pytest.raises(jsonpath.JSONPathSyntaxError):
+        jsonpath.match("a.*", {"a": [1, 2, 3]}, strict=True)
+
+    match = jsonpath.match("$.a.*", {"a": [1, 2, 3]})
+    assert isinstance(match, jsonpath.JSONPathMatch)
+    assert match.obj == 1
+
+
+def test_convenience_query() -> None:
+    query = jsonpath.query("a.*", {"a": [1, 2, 3]})
+    assert isinstance(query, jsonpath.Query)
+    assert list(query.values()) == [1, 2, 3]
+
+
+def test_convenience_query_strict() -> None:
+    with pytest.raises(jsonpath.JSONPathSyntaxError):
+        jsonpath.query("a.*", {"a": [1, 2, 3]}, strict=True)
+
+    query = jsonpath.query("$.a.*", {"a": [1, 2, 3]})
+    assert isinstance(query, jsonpath.Query)
+    assert list(query.values()) == [1, 2, 3]