Remove circular dependency to jsonschema :(

Author: hynek

CHANGELOG.md

@@ -13,6 +13,11 @@ The **third number** is for emergencies when we need to start branches for older
 
 ## [Unreleased](https://github.com/hynek/hatch-fancy-pypi-readme/compare/22.6.0...HEAD)
 
+### Changed
+
+- Removed another circular dependency: this time the wonderful [*jsonschema*](https://python-jsonschema.readthedocs.io/).
+  The price of building packaging tools is to not use packages.
+
 
 ## [22.6.0](https://github.com/hynek/hatch-fancy-pypi-readme/compare/22.5.0...22.6.0) - 2022-09-11
 

pyproject.toml

@@ -29,7 +29,6 @@ classifiers = [
 ]
 dependencies = [
   "hatchling",
-  "jsonschema",
   "tomli; python_version<'3.11'",
   "typing-extensions; python_version<'3.8'",
 ]

src/hatch_fancy_pypi_readme/_config.py

@@ -5,14 +5,10 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any
-
-import jsonschema
+from typing import Any, cast
 
 from ._fragments import VALID_FRAGMENTS, Fragment
-from ._humanize_validation_errors import errors_to_human_strings
 from ._substitutions import Substituter
-from ._validators import CustomValidator
 from .exceptions import ConfigurationError
 
 
@@ -23,91 +19,72 @@ class Config:
     substitutions: list[Substituter]
 
 
-SCHEMA = {
-    "$schema": CustomValidator.META_SCHEMA["$id"],
-    "type": "object",
-    "properties": {
-        "content-type": {
-            "type": "string",
-            "enum": ["text/markdown", "text/x-rst"],
-        },
-        "fragments": {
-            "type": "array",
-            "minItems": 1,
-            # Items are validated separately for better error messages.
-            "items": {"type": "object"},
-        },
-        "substitutions": {
-            "type": "array",
-            "items": {
-                "type": "object",
-                "properties": {
-                    "pattern": {"type": "string", "regex": True},
-                    "replacement": {"type": "string"},
-                    "ignore-case": {"type": "boolean"},
-                },
-                "required": ["pattern", "replacement"],
-                "additionalProperties": False,
-            },
-        },
-    },
-    "required": ["content-type", "fragments"],
-    "additionalProperties": False,
-}
+_BASE = "tool.hatch.metadata.hooks.fancy-pypi-readme."
 
 
 def load_and_validate_config(config: dict[str, Any]) -> Config:
-    errs = sorted(
-        CustomValidator(SCHEMA).iter_errors(config),
-        key=jsonschema.exceptions.relevance,
-    )
+    errs = []
+
+    ct = config.get("content-type")
+    if ct is None:
+        errs.append(f"{_BASE}content-type is missing.")
+    elif ct not in ("text/markdown", "text/x-rst"):
+        errs.append(
+            f"{_BASE}content-type: '{ct}' is not one of "
+            "['text/markdown', 'text/x-rst']"
+        )
+
+    try:
+        fragments = _load_fragments(config.get("fragments"))
+    except ConfigurationError as e:
+        errs.extend(e.errors)
+
+    try:
+        subs_cfg = config.get("substitutions", [])
+        if not isinstance(subs_cfg, list):
+            raise ConfigurationError(
+                [f"{_BASE}substitutions must be an array."]
+            )
+
+        substitutions = [
+            Substituter.from_config(sub_cfg) for sub_cfg in subs_cfg
+        ]
+    except ConfigurationError as e:
+        errs.extend(e.errors)
+
     if errs:
-        raise ConfigurationError(errors_to_human_strings(errs))
+        raise ConfigurationError(errs)
 
     return Config(
-        config["content-type"],
-        _load_fragments(config["fragments"]),
-        [
-            Substituter.from_config(sub_cfg)
-            for sub_cfg in config.get("substitutions", [])
-        ],
+        content_type=cast(str, ct),
+        fragments=fragments,
+        substitutions=substitutions,
     )
 
 
-def _load_fragments(config: list[dict[str, str]]) -> list[Fragment]:
+def _load_fragments(config: list[dict[str, str]] | None) -> list[Fragment]:
     """
     Load fragments from *config*.
-
-    This is a bit more complicated because validating the fragments field using
-    `oneOf` leads to unhelpful error messages that are difficult to convert
-    into something humanly meaningful.
-
-    So we detect first, validate using jsonschema and try to load them. They
-    still may fail loading if they refer to files and lack markers / the
-    pattern doesn't match.
     """
+    if config is None:
+        raise ConfigurationError([f"{_BASE}fragments is missing."])
+    if not config:
+        raise ConfigurationError([f"{_BASE}fragments must not be empty."])
+
     frags = []
     errs = []
 
-    for i, frag_cfg in enumerate(config):
+    for frag_cfg in config:
         for frag in VALID_FRAGMENTS:
             if frag.key not in frag_cfg:
                 continue
 
             try:
-                ves = sorted(
-                    frag.validator.iter_errors(frag_cfg),
-                    key=jsonschema.exceptions.relevance,
-                )
-                if ves:
-                    raise ConfigurationError(
-                        errors_to_human_strings(ves, ("fragments", i))
-                    )
                 frags.append(frag.from_config(frag_cfg))
             except ConfigurationError as e:
                 errs.extend(e.errors)
 
-            # We have either detecte and added or detected and errored, but in
+            # We have either detected and added or detected and errored, but in
             # any case we're done with this fragment.
             break
         else:

src/hatch_fancy_pypi_readme/_fragments.py

@@ -11,47 +11,17 @@
 from pathlib import Path
 from typing import ClassVar, Iterable
 
-from jsonschema import Validator
-
 
 if sys.version_info >= (3, 8):
     from typing import Protocol
 else:
     from typing_extensions import Protocol
 
-from ._validators import CustomValidator
 from .exceptions import ConfigurationError
 
 
-TEXT_V = CustomValidator(
-    {
-        "$schema": CustomValidator.META_SCHEMA["$id"],
-        "type": "object",
-        "properties": {"text": {"type": "string", "minLength": 1}},
-        "required": ["text"],
-        "additionalProperties": False,
-    }
-)
-
-FILE_V = CustomValidator(
-    {
-        "$schema": CustomValidator.META_SCHEMA["$id"],
-        "type": "object",
-        "properties": {
-            "path": {"type": "string", "minLength": 1},
-            "start-after": {"type": "string", "minLength": 1},
-            "end-before": {"type": "string", "minLength": 1},
-            "pattern": {"type": "string", "regex": True},
-        },
-        "required": ["path"],
-        "additionalProperties": False,
-    }
-)
-
-
 class Fragment(Protocol):
     key: ClassVar[str]
-    validator: ClassVar[Validator]
 
     @classmethod
     def from_config(self, cfg: dict[str, str]) -> Fragment:
@@ -68,13 +38,16 @@ class TextFragment:
     """
 
     key: ClassVar[str] = "text"
-    validator: ClassVar[Validator] = TEXT_V
 
     _text: str
 
     @classmethod
     def from_config(cls, cfg: dict[str, str]) -> Fragment:
-        return cls(cfg[cls.key])
+        text = cfg[cls.key]
+        if not text:
+            raise ConfigurationError(["Text fragments must not be empty."])
+
+        return cls(text)
 
     def render(self) -> str:
         return self._text
@@ -87,7 +60,6 @@ class FileFragment:
     """
 
     key: ClassVar[str] = "path"
-    validator: ClassVar[Validator] = FILE_V
 
     _contents: str
 

src/hatch_fancy_pypi_readme/_humanize_validation_errors.py

@@ -7,6 +7,9 @@
 import re
 
 from dataclasses import dataclass
+from typing import cast
+
+from hatch_fancy_pypi_readme.exceptions import ConfigurationError
 
 
 @dataclass
@@ -16,16 +19,37 @@ class Substituter:
 
     @classmethod
     def from_config(cls, cfg: dict[str, str]) -> Substituter:
+        errs = []
         flags = 0
 
         ignore_case = cfg.get("ignore-case", False)
+        if not isinstance(ignore_case, bool):
+            errs.append(
+                f"Value {ignore_case!r} for 'ignore-case' is not a bool."
+            )
+
         if ignore_case:
             flags += re.IGNORECASE
 
-        pattern = re.compile(cfg["pattern"], flags=flags)
-        replacement = cfg["replacement"]
-
-        return cls(pattern, replacement)
+        try:
+            pattern = re.compile(cfg["pattern"], flags=flags)
+        except KeyError:
+            errs.append(f"Substitution {cfg} is missing a 'pattern' key.")
+        except re.error as e:
+            errs.append(
+                f"{cfg['pattern']!r} is not a valid regular expression: {e}"
+            )
+
+        replacement = cfg.get("replacement")
+        if replacement is None:
+            errs.append(f"Substitution {cfg} is missing a 'replacement' key.")
+        elif not isinstance(replacement, str):
+            errs.append(f"Replacement value {replacement!r} is not a string.")
+
+        if errs:
+            raise ConfigurationError(errs)
+
+        return cls(pattern, cast(str, replacement))
 
     def substitute(self, text: str) -> str:
         return self.pattern.sub(self.replacement, text)