json-sorted 1.0.0__tar.gz

json_sorted-1.0.0/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Johannes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

json_sorted-1.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include run_tests.py
+recursive-include docs *.rst
+recursive-include src/json_sorted *.toml

json_sorted-1.0.0/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: json_sorted
+Version: 1.0.0
+Summary: This project sorts JSON data.
+Author-email: Johannes <johannes.programming@gmail.com>
+License-Expression: MIT
+Project-URL: Download, https://pypi.org/project/json_sorted/#files
+Project-URL: Index, https://pypi.org/project/json_sorted/
+Project-URL: Source, https://github.com/johannes-programming/json_sorted/
+Project-URL: Website, https://json-sorted.johannes-programming.online/
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.11
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: setdoc<3,>=1.3.14
+Dynamic: license-file
+
+===========
+json_sorted
+===========
+
+Each minor version has its own documentation.
+These docs can be found as rst-files in the ``docs/`` directory of this project.
+They can also be viewed on the website `https://json-sorted.johannes-programming.online/ <https://json-sorted.johannes-programming.online/>`_.

json_sorted-1.0.0/README.rst

@@ -0,0 +1,7 @@
+===========
+json_sorted
+===========
+
+Each minor version has its own documentation.
+These docs can be found as rst-files in the ``docs/`` directory of this project.
+They can also be viewed on the website `https://json-sorted.johannes-programming.online/ <https://json-sorted.johannes-programming.online/>`_.

json_sorted-1.0.0/docs/v1.0.rst

@@ -0,0 +1,145 @@
+Overview
+--------
+
+This project sorts JSON data.
+
+Installation
+------------
+
+To install ``json_sorted``, you can use ``pip``.
+Open your terminal and run:
+
+.. code-block:: shell
+
+    pip install json_sorted
+
+Typing
+------
+
+This project is strictly typed with ``mypy``.
+
+Features
+--------
+
+``json_sorted.core``
+''''''''''''''''''''
+
+``json_sorted.core.main.main(args: Optional[Iterable[str]] = None, /) -> None``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+This function is the CLI implementation of ``run``.
+
+It accepts these instruction flags, applied in the order given:
+
+.. code-block:: shell
+
+    python -m json_sorted example.json --sort --key=foo --all-keys --index=0
+
+turns
+
+.. code-block:: json
+
+{
+    "foo": {
+        "bar": [
+            [
+                4,
+                2
+            ],
+            {}
+        ],
+            "baz": [
+            {
+                "a": 9,
+                "c": 8,
+                "b": 7
+            }
+        ]
+    }
+}
+
+into
+
+.. code-block:: json
+
+    # example.json
+    {
+        "foo": {
+            "bar": [
+            [
+                2,
+                4
+            ],
+            {}
+            ],
+            "baz": [
+            {
+                "a": 9,
+                "b": 7,
+                "c": 8
+            }
+        ]
+    }
+
+``json_sorted.core.run.run(*filepatterns: str, instructions: Iterable[Instruction | Selector | int | str] = ()) -> None``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+``json_sorted.enum``
+''''''''''''''''''''
+
+``class json_sorted.enum.Instruction.Instruction``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+``SORT``
+^^^^^^^^
+
+``SORT_REVERSE``
+^^^^^^^^^^^^^^^^
+
+``class json_sorted.enum.Selector.Selector``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+``ALL_KEYS``
+^^^^^^^^^^^^
+
+A path token that, instead of descending into a single key,
+expands the current table and applies the remaining path and
+the sort to every value.
+It is produced by the ``--all-keys`` flag.
+
+``ALL_INDICES``
+^^^^^^^^^^^^^^^
+
+A path token that, instead of descending into a single index,
+expands the current array and applies the remaining path and
+the sort to every value.
+It is produced by the ``--all-indices`` flag.
+
+Testing
+-------
+
+This project can be tested through its ``run_tests.py`` script
+which runs the tests in its ``tests/`` dir.
+
+License
+-------
+
+This project is licensed under the MIT License.
+
+Links
+-----
+
+- Download: https://pypi.org/project/json_sorted/#files
+- Index: https://pypi.org/project/json_sorted/
+- Source: https://github.com/johannes-programming/json_sorted/
+- Website: https://json-sorted.johannes-programming.online/
+
+Impressum
+---------
+
+**Johannes Programming**
+
+- Name: Johannes
+- Email: johannes.programming@gmail.com
+- Homepage: https://www.johannes-programming.online/
+- Gravatar: https://www.johannes-programming.fyi/

json_sorted-1.0.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = [
+    "setuptools>=77.0",
+]
+
+[project]
+authors = [
+    { email = "johannes.programming@gmail.com", name = "Johannes" },
+]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Natural Language :: English",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+]
+dependencies = [
+    "setdoc>=1.3.14,<3",
+]
+description = "This project sorts JSON data."
+keywords = []
+license = "MIT"
+license-files = [
+    "LICENSE.txt",
+]
+name = "json_sorted"
+readme = "README.rst"
+requires-python = ">=3.11"
+version = "1.0.0"
+
+[project.urls]
+Download = "https://pypi.org/project/json_sorted/#files"
+Index = "https://pypi.org/project/json_sorted/"
+Source = "https://github.com/johannes-programming/json_sorted/"
+Website = "https://json-sorted.johannes-programming.online/"
+
+[tool.mypy]
+files = [
+    ".",
+]
+python_version = "3.11"
+strict = true

json_sorted-1.0.0/run_tests.py

@@ -0,0 +1,17 @@
+import unittest
+
+__all__ = ["main"]
+
+
+def main() -> unittest.TextTestResult:
+    loader: unittest.TestLoader
+    suite: unittest.TestSuite
+    runner: unittest.TextTestRunner
+    loader = unittest.TestLoader()
+    suite = loader.discover("tests")
+    runner = unittest.TextTestRunner(verbosity=2)
+    return runner.run(suite)
+
+
+if __name__ == "__main__":
+    main()

json_sorted-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

json_sorted-1.0.0/src/json_sorted/__init__.py

@@ -0,0 +1,9 @@
+from json_sorted.core.main import main
+from json_sorted.core.run import run
+from json_sorted.enum.Instruction import Instruction
+from json_sorted.enum.Selector import Selector
+
+__all__ = ["Instruction", "Selector", "main", "run"]
+
+if __name__ == "__main__":
+    main()

json_sorted-1.0.0/src/json_sorted/__main__.py

@@ -0,0 +1,4 @@
+from json_sorted import main
+
+if __name__ == "__main__":
+    main()

json_sorted-1.0.0/src/json_sorted/core/main.py

@@ -0,0 +1,67 @@
+import argparse
+import logging
+import sys
+from collections.abc import Iterable
+from typing import Any, Optional
+
+import setdoc
+
+from ..enum.Instruction import Instruction
+from ..enum.Selector import Selector
+from .run import run
+
+__all__ = ["main"]
+
+
+@setdoc.basic
+def main(args: Optional[Iterable[str]] = None, /) -> None:
+    kwargs: dict[str, Any]
+    parser: argparse.ArgumentParser
+    parser = argparse.ArgumentParser(fromfile_prefix_chars="@")
+    parser.add_argument(
+        "filepatterns",
+        nargs="*",
+        default=[],
+    )
+    parser.add_argument(
+        "--all-indices",
+        action="append_const",
+        const=Selector.ALL_INDICES,
+        dest="instructions",
+    )
+    parser.add_argument(
+        "--all-keys",
+        action="append_const",
+        const=Selector.ALL_KEYS,
+        dest="instructions",
+    )
+    parser.add_argument(
+        "--key",
+        action="append",
+        dest="instructions",
+    )
+    parser.add_argument(
+        "--index",
+        action="append",
+        dest="instructions",
+        type=int,
+    )
+    parser.add_argument(
+        "--sort",
+        action="append_const",
+        const=Instruction.SORT,
+        dest="instructions",
+    )
+    parser.add_argument(
+        "--sort-reverse",
+        action="append_const",
+        const=Instruction.SORT_REVERSE,
+        dest="instructions",
+    )
+    parser.set_defaults(instructions=[])
+    kwargs = vars(parser.parse_args(args))
+    try:
+        run(*kwargs.pop("filepatterns"), **kwargs)
+    except Exception:
+        logging.exception("json_sort failed!")
+        sys.exit(1)

json_sorted-1.0.0/src/json_sorted/core/run.py

@@ -0,0 +1,173 @@
+import glob
+import json
+import os
+from collections.abc import Iterable
+from typing import Any, cast
+
+import setdoc
+
+from json_sorted.enum.Instruction import Instruction
+from json_sorted.enum.Selector import Selector
+
+__all__ = ["run"]
+
+
+def get_absfiles(filepatterns: Iterable[str]) -> list[str]:
+    absfile: str
+    absfiles: list[str]
+    file: str
+    pattern: str
+    absfiles = list()
+    for pattern in filepatterns:
+        for file in glob.iglob(pattern, recursive=True):
+            absfile = os.path.abspath(file)
+            if absfile in absfiles:
+                continue
+            if os.path.isfile(absfile):
+                absfiles.append(absfile)
+    return absfiles
+
+
+def parse_instructions(
+    instructions: Iterable[Instruction | Selector | int | str] = (),
+) -> list[tuple[Instruction, list[Selector | int | str]]]:
+    ans: list[tuple[Instruction, list[Selector | int | str]]]
+    x: Instruction | Selector | int | str
+    ans = list()
+    for x in instructions:
+        if isinstance(x, Instruction):
+            ans.append((x, list()))
+        elif len(ans):
+            ans[-1][1].append(x)
+    return ans
+
+
+@setdoc.basic
+def run(
+    *filepatterns: str,
+    instructions: Iterable[Instruction | Selector | int | str] = (),
+) -> None:
+    absfiles: list[str]
+    parsed: list[tuple[Instruction, list[Selector | int | str]]]
+    parsed = parse_instructions(instructions)
+    absfiles = get_absfiles(filepatterns)
+    run_instructions_on_files(absfiles=absfiles, parsed=parsed)
+
+
+def run_instruction_on_data(
+    *,
+    instruction: Instruction,
+    keys: list[Selector | int | str],
+    data: dict[str, Any],
+) -> dict[str, Any]:
+    return cast(
+        dict[str, Any],
+        run_instruction_along_keys(
+            data,
+            instruction=instruction,
+            keys=list(keys),
+        ),
+    )
+
+
+def run_instruction_along_keys(
+    data: Any,
+    *,
+    instruction: Instruction,
+    keys: list[Selector | int | str],
+) -> Any:
+    head: Selector | int | str
+    rest: list[Selector | int | str]
+    if not len(keys):
+        return run_instruction_on_value(data, reverse=instruction.value)
+    head = keys[0]
+    rest = keys[1:]
+    if head is Selector.ALL_KEYS:
+        return run_instruction_on_all_keys(
+            data,
+            instruction=instruction,
+            keys=rest,
+        )
+    if head is Selector.ALL_INDICES:
+        return run_instruction_on_all_indices(
+            data,
+            instruction=instruction,
+            keys=rest,
+        )
+    data[head] = run_instruction_along_keys(
+        data[head],
+        instruction=instruction,
+        keys=rest,
+    )
+    return data
+
+
+def run_instruction_on_all_keys(
+    data: Any,
+    *,
+    instruction: Instruction,
+    keys: list[Selector | int | str],
+) -> Any:
+    key: Any
+    if isinstance(data, dict):
+        for key in list(data.keys()):
+            data[key] = run_instruction_along_keys(
+                data[key],
+                instruction=instruction,
+                keys=keys,
+            )
+        return data
+    raise TypeError(
+        f"Value {data!r} of type {type(data).__name__} has no keys to expand!"
+    )
+
+
+def run_instruction_on_all_indices(
+    data: Any,
+    *,
+    instruction: Instruction,
+    keys: list[Selector | int | str],
+) -> Any:
+    index: int
+    if isinstance(data, list):
+        for index in range(len(data)):
+            data[index] = run_instruction_along_keys(
+                data[index],
+                instruction=instruction,
+                keys=keys,
+            )
+        return data
+    raise TypeError(
+        f"Value {data!r} of type {type(data).__name__} has no indices to expand!"
+    )
+
+
+def run_instruction_on_value(data: Any, *, reverse: bool) -> Any:
+    if isinstance(data, dict):
+        return dict(sorted(data.items(), reverse=reverse))
+    if isinstance(data, list):
+        return list(sorted(data, reverse=reverse))
+    raise TypeError(
+        f"Value {data!r} of type {type(data).__name__} cannot be sorted!"
+    )
+
+
+def run_instructions_on_files(
+    *,
+    absfiles: list[str],
+    parsed: list[tuple[Instruction, list[Selector | int | str]]],
+) -> None:
+    absfile: str
+    data: Any
+    for absfile in absfiles:
+        with open(absfile, "r", encoding="utf-8") as stream:
+            data = json.load(stream)
+        for instruction, keys in parsed:
+            data = run_instruction_on_data(
+                data=data,
+                instruction=instruction,
+                keys=keys,
+            )
+        with open(absfile, "w", encoding="utf-8") as stream:
+            json.dump(data, stream, indent=4)
+            stream.write("\n")

json_sorted-1.0.0/src/json_sorted/enum/Instruction.py

@@ -0,0 +1,8 @@
+import enum
+
+__all__ = ["Instruction"]
+
+
+class Instruction(enum.Enum):
+    SORT = False
+    SORT_REVERSE = True

json_sorted-1.0.0/src/json_sorted/enum/Selector.py

@@ -0,0 +1,8 @@
+import enum
+
+__all__ = ["Selector"]
+
+
+class Selector(enum.Enum):
+    ALL_KEYS = enum.auto()
+    ALL_INDICES = enum.auto()

json_sorted-1.0.0/src/json_sorted.egg-info/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: json_sorted
+Version: 1.0.0
+Summary: This project sorts JSON data.
+Author-email: Johannes <johannes.programming@gmail.com>
+License-Expression: MIT
+Project-URL: Download, https://pypi.org/project/json_sorted/#files
+Project-URL: Index, https://pypi.org/project/json_sorted/
+Project-URL: Source, https://github.com/johannes-programming/json_sorted/
+Project-URL: Website, https://json-sorted.johannes-programming.online/
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.11
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: setdoc<3,>=1.3.14
+Dynamic: license-file
+
+===========
+json_sorted
+===========
+
+Each minor version has its own documentation.
+These docs can be found as rst-files in the ``docs/`` directory of this project.
+They can also be viewed on the website `https://json-sorted.johannes-programming.online/ <https://json-sorted.johannes-programming.online/>`_.

json_sorted-1.0.0/src/json_sorted.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+LICENSE.txt
+MANIFEST.in
+README.rst
+pyproject.toml
+run_tests.py
+setup.cfg
+docs/v1.0.rst
+src/json_sorted/__init__.py
+src/json_sorted/__main__.py
+src/json_sorted/py.typed
+src/json_sorted.egg-info/PKG-INFO
+src/json_sorted.egg-info/SOURCES.txt
+src/json_sorted.egg-info/dependency_links.txt
+src/json_sorted.egg-info/requires.txt
+src/json_sorted.egg-info/top_level.txt
+src/json_sorted/core/__init__.py
+src/json_sorted/core/main.py
+src/json_sorted/core/run.py
+src/json_sorted/enum/Instruction.py
+src/json_sorted/enum/Selector.py
+tests/test_0.py
+tests/test_1.py
+tests/test_2.py
+tests/test_3.py

json_sorted-1.0.0/src/json_sorted.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

json_sorted-1.0.0/src/json_sorted.egg-info/requires.txt

@@ -0,0 +1 @@
+setdoc<3,>=1.3.14

json_sorted-1.0.0/src/json_sorted.egg-info/top_level.txt

@@ -0,0 +1 @@
+json_sorted

json_sorted-1.0.0/tests/test_0.py

@@ -0,0 +1,58 @@
+import json
+import tempfile
+import unittest
+from pathlib import Path
+from typing import Any, Self
+
+from json_sorted.core.run import run
+from json_sorted.enum.Instruction import Instruction
+
+__all__ = ["TestJsonSort"]
+
+
+class TestJsonSort(unittest.TestCase):
+
+    def test_run_sorts_matching_json_file(self: Self) -> None:
+        path: Path
+        tmpdir: str
+        stream: Any
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = Path(tmpdir) / "example.json"
+
+            with path.open("w") as stream:
+                json.dump({"b": 2, "a": 1}, stream)
+
+            run(
+                str(path),
+                instructions=[Instruction.SORT],
+            )
+
+            with path.open("r") as stream:
+                result = json.load(stream)
+
+        self.assertEqual(result, {"a": 1, "b": 2})
+
+    def test_run_ignores_duplicate_glob_matches(self: Self) -> None:
+        path: Path
+        stream: Any
+        tmpdir: str
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = Path(tmpdir) / "example.json"
+
+            with path.open("w") as stream:
+                json.dump({"b": 2, "a": 1}, stream)
+
+            run(
+                str(path),
+                str(path),
+                instructions=[Instruction.SORT],
+            )
+
+            with path.open("r") as stream:
+                result = json.load(stream)
+
+        self.assertEqual(result, {"a": 1, "b": 2})
+
+
+if __name__ == "__main__":
+    unittest.main()

json_sorted-1.0.0/tests/test_1.py

@@ -0,0 +1,152 @@
+import json
+import tempfile
+import unittest
+from io import BufferedReader, BufferedWriter
+from pathlib import Path
+from typing import Any, Self
+
+from json_sorted.core.run import run
+from json_sorted.enum.Instruction import Instruction
+
+__all__ = ["TestRun"]
+
+
+def get_instruction(reverse: bool) -> Instruction:
+    instruction: Instruction
+    for instruction in Instruction:
+        if instruction.value == reverse:
+            return instruction
+    raise AssertionError(f"No Instruction found with value={reverse!r}")
+
+
+def write_json(path: Path, data: dict[str, Any]) -> None:
+    stream: Any
+    with path.open("w") as stream:
+        json.dump(data, stream)
+
+
+def read_json(path: Path) -> Any:
+    stream: Any
+    with path.open("r") as stream:
+        return json.load(stream)
+
+
+class TestRun(unittest.TestCase):
+    def test_run_sorts_root_table_ascending(self: Self) -> None:
+        asc: Instruction
+        data: dict[str, Any]
+        path: Path
+        tmpdir: str
+        asc = get_instruction(False)
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = Path(tmpdir) / "example.json"
+            write_json(path, {"z": 1, "a": 2, "m": 3})
+            run(str(path), instructions=[asc])
+            data = read_json(path)
+            self.assertEqual(list(data.keys()), ["a", "m", "z"])
+
+    def test_run_sorts_root_table_descending(self: Self) -> None:
+        data: dict[str, Any]
+        desc: Instruction
+        path: Path
+        tmpdir: str
+        desc = get_instruction(True)
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = Path(tmpdir) / "example.json"
+            write_json(path, {"a": 1, "z": 2, "m": 3})
+            run(str(path), instructions=[desc])
+            data = read_json(path)
+            self.assertEqual(list(data.keys()), ["z", "m", "a"])
+
+    def test_run_sorts_nested_table_by_key_path(self: Self) -> None:
+        asc: Instruction
+        data: dict[str, Any]
+        nested: Any
+        path: Path
+        tmpdir: str
+        asc = get_instruction(False)
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = Path(tmpdir) / "example.json"
+            write_json(
+                path,
+                {
+                    "tool": {
+                        "json_sorted": {
+                            "z": 1,
+                            "a": 2,
+                            "m": 3,
+                        }
+                    }
+                },
+            )
+            run(
+                str(path),
+                instructions=[asc, "tool", "json_sorted"],
+            )
+            data = read_json(path)
+            nested = data["tool"]["json_sorted"]
+            self.assertEqual(list(nested.keys()), ["a", "m", "z"])
+
+    def test_run_sorts_nested_list_by_key_path(self: Self) -> None:
+        asc: Any
+        data: dict[str, Any]
+        path: Path
+        tmpdir: str
+        asc = get_instruction(False)
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = Path(tmpdir) / "example.json"
+            write_json(path, {"project": {"numbers": [3, 1, 2]}})
+            run(
+                str(path),
+                instructions=[asc, "project", "numbers"],
+            )
+            data = read_json(path)
+            self.assertEqual(data["project"]["numbers"], [1, 2, 3])
+
+    def test_run_accepts_glob_patterns(self: Self) -> None:
+        asc: Instruction
+        first: Path
+        root: Path
+        second: Path
+        tmpdir: str
+        asc = get_instruction(False)
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            first = root / "first.json"
+            second = root / "second.json"
+            write_json(first, {"b": 1, "a": 2})
+            write_json(second, {"d": 1, "c": 2})
+            run(str(root / "*.json"), instructions=[asc])
+            self.assertEqual(list(read_json(first).keys()), ["a", "b"])
+            self.assertEqual(list(read_json(second).keys()), ["c", "d"])
+
+    def test_run_ignores_duplicate_file_matches(self: Self) -> None:
+        asc: Instruction
+        data: dict[str, Any]
+        path: Path
+        tmpdir: str
+        asc = get_instruction(False)
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = Path(tmpdir) / "example.json"
+            write_json(path, {"b": 1, "a": 2})
+            run(str(path), str(path), instructions=[asc])
+            data = read_json(path)
+            self.assertEqual(list(data.keys()), ["a", "b"])
+
+    def test_run_raises_type_error_for_unsortable_value(self: Self) -> None:
+        asc: Instruction
+        path: Path
+        tmpdir: str
+        asc = get_instruction(False)
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = Path(tmpdir) / "example.json"
+            write_json(path, {"project": {"name": "demo"}})
+            with self.assertRaises(TypeError):
+                run(
+                    str(path),
+                    instructions=[asc, "project", "name"],
+                )
+
+
+if __name__ == "__main__":
+    unittest.main()

json_sorted-1.0.0/tests/test_2.py

@@ -0,0 +1,127 @@
+import json
+import tempfile
+import unittest
+from io import BufferedReader, BufferedWriter
+from pathlib import Path
+from typing import Any, Self
+
+from json_sorted.core.run import run, run_instruction_on_data
+from json_sorted.enum.Instruction import Instruction
+from json_sorted.enum.Selector import Selector
+
+__all__ = ["TestAllKeys"]
+
+
+def write_json(path: Path, data: dict[str, Any]) -> None:
+    stream: Any
+    with path.open("w") as stream:
+        json.dump(data, stream)
+
+
+def read_json(path: Path) -> Any:
+    stream: Any
+    with path.open("r") as stream:
+        return json.load(stream)
+
+
+class TestAllKeys(unittest.TestCase):
+    def test_all_keys_documented_example(self: Self) -> None:
+        # --sort --key=foo --all-keys --index=0
+        data: dict[str, Any]
+        result: dict[str, Any]
+        data = {
+            "foo": {
+                "bar": [[4, 2], {}],
+                "baz": [{"a": 9, "c": 8, "b": 7}],
+            }
+        }
+        result = run_instruction_on_data(
+            instruction=Instruction.SORT,
+            keys=["foo", Selector.ALL_KEYS, 0],
+            data=data,
+        )
+        self.assertEqual(
+            result,
+            {
+                "foo": {
+                    "bar": [[2, 4], {}],
+                    "baz": [{"a": 9, "b": 7, "c": 8}],
+                }
+            },
+        )
+
+    def test_all_keys_expands_every_child_table(self: Self) -> None:
+        data: dict[str, Any]
+        path: Path
+        tmpdir: str
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = Path(tmpdir) / "example.json"
+            write_json(
+                path,
+                {
+                    "tool": {
+                        "x": {"c": 1, "a": 2, "b": 3},
+                        "y": {"z": 1, "m": 2},
+                    }
+                },
+            )
+            # --sort --key=tool --all-keys
+            run(
+                str(path),
+                instructions=[Instruction.SORT, "tool", Selector.ALL_KEYS],
+            )
+            data = read_json(path)
+            self.assertEqual(list(data["tool"]["x"].keys()), ["a", "b", "c"])
+            self.assertEqual(list(data["tool"]["y"].keys()), ["m", "z"])
+
+    def test_all_keys_expands_list_elements(self: Self) -> None:
+        data: dict[str, Any]
+        path: Path
+        tmpdir: str
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = Path(tmpdir) / "example.json"
+            write_json(path, {"rows": [[3, 1, 2], [9, 8, 7]]})
+            # --sort --key=rows --all-keys
+            with self.assertRaises(Exception):
+                run(
+                    str(path),
+                    instructions=[Instruction.SORT, "rows", Selector.ALL_KEYS],
+                )
+
+    def test_all_indices_expands_list_elements(self: Self) -> None:
+        data: dict[str, Any]
+        path: Path
+        tmpdir: str
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = Path(tmpdir) / "example.json"
+            write_json(path, {"rows": [[3, 1, 2], [9, 8, 7]]})
+            # --sort --key=rows --all-indices
+            run(
+                str(path),
+                instructions=[Instruction.SORT, "rows", Selector.ALL_INDICES],
+            )
+            data = read_json(path)
+            self.assertEqual(data["rows"], [[1, 2, 3], [7, 8, 9]])
+
+    def test_all_keys_respects_sort_reverse(self: Self) -> None:
+        data: dict[str, Any]
+        result: dict[str, Any]
+        data = {"foo": {"a": [3, 1, 2], "b": [6, 5, 4]}}
+        result = run_instruction_on_data(
+            instruction=Instruction.SORT_REVERSE,
+            keys=["foo", Selector.ALL_KEYS],
+            data=data,
+        )
+        self.assertEqual(result, {"foo": {"a": [3, 2, 1], "b": [6, 5, 4]}})
+
+    def test_all_keys_on_scalar_raises_type_error(self: Self) -> None:
+        with self.assertRaises(TypeError):
+            run_instruction_on_data(
+                instruction=Instruction.SORT,
+                keys=[Selector.ALL_KEYS],
+                data={"name": "demo"}["name"],  # type: ignore[arg-type]
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()

json_sorted-1.0.0/tests/test_3.py

@@ -0,0 +1,44 @@
+import json
+import tempfile
+import unittest
+from pathlib import Path
+from typing import Any, Self
+
+from json_sorted.core.main import main
+
+__all__ = ["TestCliAllIndices"]
+
+
+class TestCliAllIndices(unittest.TestCase):
+    def test_cli_accepts_all_indices_selector(self: Self) -> None:
+        data: dict[str, Any]
+        dataA: dict[str, Any]
+        listA: list[str]
+        path: Path
+        stream: Any
+        tmpdir: str
+        dataA = {
+            "items": [
+                {"b": 2, "a": 1},
+                {"d": 4, "c": 3},
+            ]
+        }
+        listA = [
+            "--sort",
+            "--key",
+            "items",
+            "--all-indices",
+        ]
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = Path(tmpdir) / "example.json"
+            with path.open("w") as stream:
+                json.dump(dataA, stream)
+            main(listA + [str(path)])
+            with path.open("r") as stream:
+                data = json.load(stream)
+        self.assertEqual(list(data["items"][0].keys()), ["a", "b"])
+        self.assertEqual(list(data["items"][1].keys()), ["c", "d"])
+
+
+if __name__ == "__main__":
+    unittest.main()