jsonschema-diff 0.1.0__py3-none-any.whl

jsonschema_diff/__init__.py

@@ -0,0 +1,17 @@
+from importlib import import_module
+from types import ModuleType
+
+from .config_maker import ConfigMaker
+from .pypi_interface import JsonSchemaDiff
+
+
+# Lazy-import подмодуля sphinx (тянет Rich → Sphinx только по требованию)
+def __getattr__(name: str) -> ModuleType:  # pragma: no cover
+    if name == "sphinx":
+        return import_module("jsonschema_diff.sphinx")
+    raise AttributeError(name)
+
+
+__all__ = ["JsonSchemaDiff", "ConfigMaker"]
+
+__version__ = "0.1.0"

jsonschema_diff/cli.py

@@ -0,0 +1,190 @@
+"""
+jsonschema_diff CLI
+===================
+
+A tiny command-line front-end around :py:mod:`jsonschema_diff`
+that highlights semantic differences between two JSON-Schema
+documents directly in your terminal.
+
+Typical usage
+-------------
+>>> jsonschema-diff old.schema.json new.schema.json
+>>> jsonschema-diff --no-color --legend old.json new.json
+>>> jsonschema-diff --exit-code old.json new.json  # useful in CI
+
+Exit status
+-----------
+* **0** – the two schemas are semantically identical
+* **1** – at least one difference was detected (only when
+  ``--exit-code`` is given)
+
+The CLI is intentionally minimal: *all* comparison options are taken
+from :pyclass:`jsonschema_diff.ConfigMaker`, so the behaviour stays
+in sync with the library defaults.
+
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from jsonschema_diff import ConfigMaker, JsonSchemaDiff
+from jsonschema_diff.color import HighlighterPipeline
+from jsonschema_diff.color.stages import (
+    MonoLinesHighlighter,
+    PathHighlighter,
+    ReplaceGenericHighlighter,
+)
+from jsonschema_diff.core.parameter_base import Compare
+
+
+def _make_highlighter(disable_color: bool) -> HighlighterPipeline:
+    """
+    Create the high-lighting pipeline used to colorise diff output.
+
+    Parameters
+    ----------
+    disable_color :
+        When *True* ANSI escape sequences are suppressed even if the
+        invoking TTY advertises color support (e.g. when piping the
+        output into a file).
+
+    Returns
+    -------
+    HighlighterPipeline
+        Either an **empty** pipeline (no colour) or the standard
+        three-stage pipeline consisting of
+        :class:`~jsonschema_diff.color.stages.MonoLinesHighlighter`,
+        :class:`~jsonschema_diff.color.stages.ReplaceGenericHighlighter`
+        and :class:`~jsonschema_diff.color.stages.PathHighlighter`.
+
+    Note
+    -----
+    The composition of the *default* pipeline mirrors what the core
+    library exposes; duplicating the stages here keeps the CLI fully
+    self-contained while allowing future customisation.
+
+    Examples
+    --------
+    >>> _make_highlighter(True)
+    HighlighterPipeline(stages=[])
+    >>> _make_highlighter(False).stages   # doctest: +ELLIPSIS
+    [<jsonschema_diff.color.stages.MonoLinesHighlighter ...>, ...]
+    """
+    if disable_color:
+        return HighlighterPipeline([])
+    return HighlighterPipeline(
+        [
+            MonoLinesHighlighter(),
+            ReplaceGenericHighlighter(),
+            PathHighlighter(),
+        ]
+    )
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    """
+    Construct the :pyclass:`argparse.ArgumentParser` for the CLI.
+
+    Returns
+    -------
+    argparse.ArgumentParser
+        The fully configured parser containing positional arguments
+        for the *old* and *new* schema paths, together with three
+        optional feature flags.
+
+    See Also
+    --------
+    * :pyfunc:`main` – where the parser is consumed.
+    * The *argparse* documentation for available formatting options.
+    """
+    p = argparse.ArgumentParser(
+        prog="jsonschema-diff",
+        description="Show the difference between two JSON-Schema files",
+    )
+
+    # Positional arguments
+    p.add_argument("old_schema", help="Path to the *old* schema")
+    p.add_argument("new_schema", help="Path to the *new* schema")
+
+    # Output options
+    p.add_argument(
+        "--no-color",
+        action="store_true",
+        help="Disable ANSI colors even if the terminal supports them",
+    )
+    p.add_argument(
+        "--legend",
+        action="store_true",
+        help="Print a legend explaining diff symbols at the end",
+    )
+
+    # Exit-code control
+    p.add_argument(
+        "--exit-code",
+        action="store_true",
+        help="Return **1** if differences are detected, otherwise **0**",
+    )
+
+    return p
+
+
+def main(argv: list[str] | None = None) -> None:  # pragma: no cover
+    """
+    CLI entry-point (invoked by ``python -m jsonschema_diff`` or by the
+    ``jsonschema-diff`` console script).
+
+    Parameters
+    ----------
+    argv :
+        Command-line argument vector **excluding** the executable name.
+        When *None* (default) ``sys.argv[1:]`` is used – this is the
+        behaviour required by *setuptools* console-scripts.
+
+
+    Note
+    ----
+        The function performs four sequential steps:
+
+        1. Build a :class:`JsonSchemaDiff` instance.
+        2. Compare the two user-supplied schema files.
+        3. Print a colourised diff (optionally with a legend).
+        4. Optionally exit with code 1 if differences are present.
+
+    """
+    args = _build_parser().parse_args(argv)
+
+    # 1. Build the wrapper object
+    diff = JsonSchemaDiff(
+        config=ConfigMaker.make(),
+        colorize_pipeline=_make_highlighter(args.no_color),
+        legend_ignore=[Compare],  # as in the library example
+    )
+
+    def try_load(data: str) -> dict | str:
+        try:
+            return dict(json.loads(data))
+        except json.JSONDecodeError:
+            return str(data)
+
+    # 2. Compare the files
+    diff.compare(
+        old_schema=try_load(args.old_schema),
+        new_schema=try_load(args.new_schema),
+    )
+
+    # 3. Print the result
+    diff.print(
+        with_legend=args.legend,
+    )
+
+    # 4. Optional special exit code
+    if args.exit_code:
+        # ``last_compare_list`` is filled during render/print.
+        sys.exit(1 if diff.last_compare_list else 0)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

jsonschema_diff/color/__init__.py

@@ -0,0 +1,12 @@
+"""
+Convenience re-exports for the colour sub-package.
+
+End-users can simply write::
+
+    from jsonschema_diff.color import HighlighterPipeline, LineHighlighter
+"""
+
+from .abstraction import LineHighlighter
+from .base import HighlighterPipeline
+
+__all__ = ["HighlighterPipeline", "LineHighlighter"]

jsonschema_diff/color/abstraction.py

@@ -0,0 +1,62 @@
+from typing import List, Protocol, Sequence
+
+from rich.text import Text
+
+"""
+Abstraction for line-based high-lighters
+=======================================
+
+This module defines :class:`LineHighlighter`, a thin
+:class:`typing.Protocol` that specifies the minimal contract required by the
+colour pipeline implemented in :pyfile:`base.py`.
+
+Implementors are expected to decorate :class:`rich.text.Text` objects **in
+place**; therefore methods must not alter the underlying string content –
+only styling metadata.
+"""
+
+
+class LineHighlighter(Protocol):
+    """Protocol for single-line high-lighters.
+
+    Concrete implementations *may* also override
+    :meth:`colorize_lines` for bulk operations, but
+    :meth:`colorize_line` is the only mandatory method.
+    """
+
+    def colorize_line(self, line: Text) -> Text:
+        """Stylise one line **in-place** and return it.
+
+        Parameters
+        ----------
+        line :
+            A single :class:`rich.text.Text` instance to be colour-styled.
+
+        Returns
+        -------
+        rich.text.Text
+            The **same** `Text` object, now containing style spans.
+
+        Raises
+        ------
+        NotImplementedError
+            Always here; concrete subclasses must override this method.
+        """
+        raise NotImplementedError("LineHighlighter.colorize_line должен быть переопределен")
+
+    def colorize_lines(self, lines: Sequence[Text]) -> List[Text]:
+        """Vectorised helper that stylises a *sequence* of lines.
+
+        The naïve fallback simply delegates to :meth:`colorize_line`.
+
+        Parameters
+        ----------
+        lines :
+            Ordered collection of :class:`rich.text.Text` objects.
+
+        Returns
+        -------
+        list[rich.text.Text]
+            The original objects, now styled in place.
+        """
+        return [self.colorize_line(t) for t in lines]

jsonschema_diff/color/base.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+"""
+Composable *Rich*-native colouring pipeline
+==========================================
+
+Provides :class:`HighlighterPipeline`, an orchestrator that feeds raw
+multi-line strings through a chain of :class:`LineHighlighter` stages.
+Each stage operates on :class:`rich.text.Text` so it can add style spans
+without mutating the text itself.
+
+Typical usage
+-------------
+
+>>> pipeline = HighlighterPipeline([MySyntaxHL(), MyDiffHL()])
+>>> ansi_output = pipeline.colorize_and_render(src_string)
+print(ansi_output)
+"""
+
+from typing import TYPE_CHECKING, Iterable
+
+from rich.console import Console
+from rich.text import Text
+
+if TYPE_CHECKING:  # pragma: no cover
+    from .abstraction import LineHighlighter  # noqa: F401 (imported for typing only)
+
+
+class HighlighterPipeline:  # noqa: D101
+    """Chain of :pyclass:`LineHighlighter` stages.
+
+    Parameters
+    ----------
+    stages :
+        Iterable of :class:`LineHighlighter` instances.  The iterable is
+        immediately materialised into a list so the pipeline can be reused.
+
+    Note
+    ----
+    * Each input line is passed through **every** stage in order.
+    * If a stage exposes a bulk :pyfunc:`colorize_lines` method it is
+      preferred over per-line iteration for performance.
+    """
+
+    def __init__(self, stages: Iterable["LineHighlighter"]):
+        self.stages: list["LineHighlighter"] = list(stages)
+
+    # ------------------------------------------------------------------
+    # Public helpers
+    # ------------------------------------------------------------------
+    def colorize(self, text: str) -> Text:  # noqa: D401
+        """Return a rich ``Text`` object with all styles applied.
+
+        Parameters
+        ----------
+        text :
+            Multi-line string to be colourised.
+
+        Returns
+        -------
+            One composite `Text` built by joining all styled lines with
+            ``\\n`` separators.
+        """
+        lines = text.splitlines()
+        rich_lines = [Text(line) for line in lines]
+
+        for stage in self.stages:
+            colorize_lines = getattr(stage, "colorize_lines", None)
+            if callable(colorize_lines):
+                colorize_lines(rich_lines)
+            else:
+                for rl in rich_lines:
+                    stage.colorize_line(rl)
+        return Text("\n").join(rich_lines)
+
+    def colorize_and_render(self, text: str) -> str:
+        """Colourise and immediately render to ANSI.
+
+        Parameters
+        ----------
+        text :
+            Multi-line input string.
+
+        Returns
+        -------
+            ANSI-encoded string ready for terminal output.
+        """
+        rich_lines = self.colorize(text)
+
+        console = Console(
+            force_terminal=True,
+            color_system="truecolor",
+            width=self._detect_width(),
+            legacy_windows=False,
+        )
+        with console.capture() as cap:
+            console.print(rich_lines, end="")
+        return cap.get()
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+    @staticmethod
+    def _detect_width(default: int = 512) -> int:  # noqa: D401
+        """Best-effort terminal width detection.
+
+        Falls back to *default* when a real TTY is not present
+        (e.g. in CI).
+
+        Parameters
+        ----------
+        default :
+            Width to use when detection fails.  Defaults to ``512``.
+
+        Returns
+        -------
+            Column count deemed safe for rendering.
+        """
+        try:
+            from shutil import get_terminal_size
+
+            return max(get_terminal_size().columns, 20)
+        except Exception:  # pragma: no cover
+            return default

jsonschema_diff/color/stages/__init__.py

@@ -0,0 +1,31 @@
+"""
+Built-in high-lighter stages
+============================
+
+This *sub-package* bundles three ready-to-use implementations of
+:class:`jsonschema_diff.color.abstraction.LineHighlighter` that cover the most
+common needs when rendering a JSON-Schema diff to the terminal:
+
+* :class:`MonoLinesHighlighter` – apply a foreground colour chosen from a
+  *prefix → colour* mapping
+* :class:`ReplaceGenericHighlighter` – highlight token-level changes within
+  ``OLD -> NEW`` tails
+* :class:`PathHighlighter` – pretty-print JSON-Pointer-like paths
+
+Importing the package directly re-exports these classes so you can write
+succinct code such as ::
+
+    from jsonschema_diff.color.stages import MonoLinesHighlighter
+
+Only the three public classes below are exported via :py:data:`__all__`.
+"""
+
+from .mono_lines import MonoLinesHighlighter
+from .path import PathHighlighter
+from .replace import ReplaceGenericHighlighter
+
+__all__: list[str] = [
+    "MonoLinesHighlighter",
+    "ReplaceGenericHighlighter",
+    "PathHighlighter",
+]

jsonschema_diff/color/stages/mono_lines.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+"""
+Monochrome prefix-based high-lighter
+====================================
+
+A :class:`~jsonschema_diff.color.abstraction.LineHighlighter` that decorates a
+single :class:`rich.text.Text` *in-place* by looking at its **first matching
+prefix**—typically the leading character produced by *unified diff* output
+(``-``, ``+``, *etc.*).
+
+Why a “Rich-native” rewrite?
+----------------------------
+The original *jsonschema-diff* implementation rendered to a string containing
+ANSI escape codes.  In interactive TUI applications you often want to keep the
+object as a real ``Text`` so you can:
+
+* put it into a :class:`rich.table.Table`,
+* display it inside a :class:`rich.panel.Panel`,
+* or update it live without re-parsing ANSI.
+
+This drop-in replacement keeps behaviour identical while removing the ANSI
+round-trip.
+"""
+from typing import Mapping, Optional
+
+from rich.style import Style
+from rich.text import Text
+
+from ..abstraction import LineHighlighter
+
+
+class MonoLinesHighlighter(LineHighlighter):
+    """Colourise one line based on a prefix lookup.
+
+    Parameters
+    ----------
+    bold :
+        Apply the *bold* attribute together with the foreground colour.
+        Enabled by default to keep parity with the original.
+    default_color :
+        Fallback colour when no rule matches.  If *None* the line is left
+        unchanged (except for *bold* when that option is *True*).
+    case_sensitive :
+        Whether prefix matching should be case-sensitive.  Defaults to *False*.
+    rules :
+        Mapping ``prefix → colour``.  The first match wins; order is therefore
+        significant.  If *None*, the following defaults are used::
+
+            {
+                "-": "red",
+                "+": "green",
+                "r": "cyan",
+                "m": "cyan",
+            }
+    """
+
+    def __init__(
+        self,
+        bold: bool = True,
+        default_color: Optional[str] = None,
+        case_sensitive: bool = False,
+        rules: Mapping[str, str] | None = None,
+    ) -> None:
+        if rules is None:
+            rules = {
+                "-": "red",
+                "+": "green",
+                "r": "cyan",
+                "m": "cyan",
+            }
+        self.bold = bold
+        self.default_color = default_color
+        self.case_sensitive = case_sensitive
+        self.rules: Mapping[str, str] = dict(rules)  # preserve order
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+    def colorize_line(self, line: Text) -> Text:
+        """Apply a single style pass **in place**.
+
+        Parameters
+        ----------
+        line :
+            The :class:`rich.text.Text` instance to be modified.
+
+        Returns
+        -------
+        rich.text.Text
+            **The very same instance** that was passed in—allowing fluent,
+            chainable APIs.
+
+        Note
+        ----
+        Only the *first* matching prefix is honoured; subsequent rules are
+        ignored, mirroring classic *grep* / *sed* behaviour.
+        """
+        probe = line.plain if self.case_sensitive else line.plain.lower()
+
+        for prefix, color in self.rules.items():
+            pref = prefix if self.case_sensitive else prefix.lower()
+            if probe.startswith(pref):
+                line.stylize(Style(color=color, bold=self.bold), 0, len(line))
+                return line  # first match wins
+
+        # --- fall-back -------------------------------------------------
+        if self.default_color is not None:
+            line.stylize(Style(color=self.default_color, bold=self.bold), 0, len(line))
+        elif self.bold:
+            line.stylize(Style(bold=True), 0, len(line))
+        return line