Meilleurs scripts
This commit is contained in:
julien
+112
-198
@@ -1,21 +1,30 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Vérifie la structure des contenus, le vocabulaire et les signes."""
|
||||
"""Vérifie que chaque fiche contient les champs prévus pour son modèle."""
|
||||
|
||||
import re
|
||||
import sys
|
||||
import tomllib
|
||||
import unicodedata
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
from _schema import KNOWN_SECTIONS, VOCABULARY_FIELDS
|
||||
from _schema import (
|
||||
CONTENT_SECTIONS,
|
||||
LIST_FIELDS,
|
||||
SECTION_FIELDS,
|
||||
UPDATED_LINE_RE,
|
||||
VOCABULARY_FIELDS,
|
||||
)
|
||||
|
||||
ROOT_DIR = Path(__file__).resolve().parent.parent
|
||||
CONTENT_DIR = ROOT_DIR / "src" / "content"
|
||||
|
||||
MZL_FILENAME_RE = re.compile(r"mzl-([0-9]{3})\.md")
|
||||
MZL_VALUE_RE = re.compile(r"[0-9]{3}")
|
||||
COMMON_FIELDS = {
|
||||
"title": str,
|
||||
"date": datetime,
|
||||
"description": str,
|
||||
"draft": bool,
|
||||
}
|
||||
|
||||
|
||||
|
||||
class Validator:
|
||||
@@ -23,10 +32,7 @@ class Validator:
|
||||
self.errors = 0
|
||||
|
||||
def error(self, path: Path | None, message: str) -> None:
|
||||
if path is None:
|
||||
label = ""
|
||||
else:
|
||||
label = f"{path.relative_to(ROOT_DIR).as_posix()} : "
|
||||
label = f"{path.relative_to(ROOT_DIR).as_posix()} : " if path else ""
|
||||
print(f"ERREUR : {label}{message}", file=sys.stderr)
|
||||
self.errors += 1
|
||||
|
||||
@@ -35,24 +41,16 @@ class Validator:
|
||||
return 1 if self.errors else 0
|
||||
|
||||
|
||||
def is_non_empty_string(value: Any) -> bool:
|
||||
return isinstance(value, str) and bool(value.strip())
|
||||
|
||||
|
||||
def read_front_matter(path: Path, validator: Validator) -> dict[str, Any] | None:
|
||||
def read_front_matter(
|
||||
path: Path,
|
||||
validator: Validator,
|
||||
) -> tuple[dict[str, Any], str] | None:
|
||||
try:
|
||||
text = path.read_text(encoding="utf-8")
|
||||
except UnicodeDecodeError as exc:
|
||||
validator.error(path, f"fichier non valide en UTF-8 ({exc})")
|
||||
return None
|
||||
except OSError as exc:
|
||||
lines = path.read_text(encoding="utf-8").splitlines()
|
||||
except (OSError, UnicodeError) as exc:
|
||||
validator.error(path, f"lecture impossible ({exc})")
|
||||
return None
|
||||
|
||||
if not unicodedata.is_normalized("NFC", text):
|
||||
validator.error(path, "contenu non normalisé en Unicode NFC")
|
||||
|
||||
lines = text.splitlines()
|
||||
if not lines or lines[0] != "+++":
|
||||
validator.error(path, "front matter TOML initial absent")
|
||||
return None
|
||||
@@ -63,231 +61,147 @@ def read_front_matter(path: Path, validator: Validator) -> dict[str, Any] | None
|
||||
validator.error(path, "délimiteur final +++ absent")
|
||||
return None
|
||||
|
||||
source = "\n".join(lines[1:closing_index])
|
||||
try:
|
||||
return tomllib.loads("\n".join(lines[1:closing_index]))
|
||||
return tomllib.loads(source), source
|
||||
except tomllib.TOMLDecodeError as exc:
|
||||
validator.error(path, f"front matter TOML invalide ({exc})")
|
||||
return None
|
||||
|
||||
|
||||
def require_table(
|
||||
metadata: dict[str, Any],
|
||||
key: str,
|
||||
def check_type(
|
||||
value: Any,
|
||||
expected_type: type,
|
||||
label: str,
|
||||
path: Path,
|
||||
validator: Validator,
|
||||
) -> dict[str, Any] | None:
|
||||
value = metadata.get(key)
|
||||
if not isinstance(value, dict):
|
||||
validator.error(path, f"{key} doit être une table TOML")
|
||||
return None
|
||||
return value
|
||||
) -> bool:
|
||||
if isinstance(value, expected_type):
|
||||
return True
|
||||
|
||||
validator.error(path, f"{label} doit être de type {expected_type.__name__}")
|
||||
return False
|
||||
|
||||
|
||||
def require_string(
|
||||
def check_string_list(
|
||||
value: Any,
|
||||
label: str,
|
||||
path: Path,
|
||||
validator: Validator,
|
||||
) -> bool:
|
||||
if isinstance(value, list) and all(isinstance(item, str) for item in value):
|
||||
return True
|
||||
|
||||
validator.error(path, f"{label} doit être un tableau de chaînes")
|
||||
return False
|
||||
|
||||
|
||||
def check_fields(
|
||||
metadata: dict[str, Any],
|
||||
key: str,
|
||||
table_name: str,
|
||||
fields: tuple[str, ...],
|
||||
path: Path,
|
||||
validator: Validator,
|
||||
) -> None:
|
||||
if not is_non_empty_string(metadata.get(key)):
|
||||
validator.error(path, f"{key} doit être une chaîne non vide")
|
||||
|
||||
|
||||
def require_timestamp(
|
||||
metadata: dict[str, Any],
|
||||
key: str,
|
||||
path: Path,
|
||||
validator: Validator,
|
||||
*,
|
||||
optional: bool = False,
|
||||
) -> None:
|
||||
value = metadata.get(key)
|
||||
if optional and value is None:
|
||||
table = metadata.get(table_name)
|
||||
if not isinstance(table, dict):
|
||||
validator.error(path, f"{table_name} doit être une table TOML")
|
||||
return
|
||||
if not isinstance(value, datetime) or value.tzinfo is None or value.utcoffset() is None:
|
||||
validator.error(
|
||||
path,
|
||||
f"{key} doit être un horodatage TOML avec fuseau horaire",
|
||||
)
|
||||
|
||||
missing = [field for field in fields if field not in table]
|
||||
if missing:
|
||||
validator.error(path, f"champs {table_name} manquants : {', '.join(missing)}")
|
||||
|
||||
for field in fields:
|
||||
if field not in table:
|
||||
continue
|
||||
|
||||
label = f"{table_name}.{field}"
|
||||
if field in LIST_FIELDS:
|
||||
check_string_list(table[field], label, path, validator)
|
||||
else:
|
||||
check_type(table[field], str, label, path, validator)
|
||||
|
||||
|
||||
def check_structure(
|
||||
path: Path,
|
||||
metadata: dict[str, Any],
|
||||
validator: Validator,
|
||||
) -> tuple[str, bool] | None:
|
||||
relative_path = path.relative_to(CONTENT_DIR)
|
||||
section = relative_path.parts[0] if len(relative_path.parts) > 1 else ""
|
||||
|
||||
if not unicodedata.is_normalized("NFC", relative_path.as_posix()):
|
||||
validator.error(path, "chemin non normalisé en Unicode NFC")
|
||||
|
||||
if section and section not in KNOWN_SECTIONS:
|
||||
validator.error(path, f"section inconnue « {section} »")
|
||||
|
||||
if path.name == "_index.md":
|
||||
require_string(metadata, "title", path, validator)
|
||||
return None
|
||||
|
||||
draft = metadata.get("draft")
|
||||
if not isinstance(draft, bool):
|
||||
validator.error(path, "draft doit être un booléen")
|
||||
return None
|
||||
|
||||
if draft:
|
||||
return section, True
|
||||
|
||||
require_string(metadata, "title", path, validator)
|
||||
if section:
|
||||
require_timestamp(metadata, "date", path, validator)
|
||||
require_timestamp(metadata, "updated", path, validator, optional=True)
|
||||
return section, False
|
||||
|
||||
|
||||
def vocabulary_nature(
|
||||
def check_common_fields(
|
||||
metadata: dict[str, Any],
|
||||
front_matter: str,
|
||||
path: Path,
|
||||
validator: Validator,
|
||||
) -> str | None:
|
||||
taxonomies = require_table(metadata, "taxonomies", path, validator)
|
||||
if taxonomies is None:
|
||||
return None
|
||||
) -> None:
|
||||
for field, expected_type in COMMON_FIELDS.items():
|
||||
if field not in metadata:
|
||||
validator.error(path, f"champ manquant : {field}")
|
||||
else:
|
||||
check_type(metadata[field], expected_type, field, path, validator)
|
||||
|
||||
natures = taxonomies.get("natures")
|
||||
if not isinstance(natures, list) or len(natures) != 1:
|
||||
validator.error(path, "taxonomies.natures doit contenir exactement une nature")
|
||||
return None
|
||||
updated_lines = len(UPDATED_LINE_RE.findall(front_matter))
|
||||
if updated_lines != 1:
|
||||
validator.error(path, "la fiche doit contenir exactement une ligne updated")
|
||||
|
||||
nature = natures[0]
|
||||
if not isinstance(nature, str):
|
||||
validator.error(path, "taxonomies.natures doit contenir une chaîne")
|
||||
return None
|
||||
|
||||
if nature not in VOCABULARY_FIELDS:
|
||||
validator.error(path, f"nature grammaticale inconnue « {nature} »")
|
||||
return None
|
||||
|
||||
return nature
|
||||
if "updated" in metadata:
|
||||
check_type(metadata["updated"], datetime, "updated", path, validator)
|
||||
|
||||
|
||||
def check_vocabulary(
|
||||
path: Path,
|
||||
metadata: dict[str, Any],
|
||||
path: Path,
|
||||
validator: Validator,
|
||||
) -> None:
|
||||
nature = vocabulary_nature(metadata, path, validator)
|
||||
extra = require_table(metadata, "extra", path, validator)
|
||||
if nature is None or extra is None:
|
||||
taxonomies = metadata.get("taxonomies")
|
||||
if not isinstance(taxonomies, dict):
|
||||
validator.error(path, "taxonomies doit être une table TOML")
|
||||
return
|
||||
|
||||
expected_fields = VOCABULARY_FIELDS[nature]
|
||||
expected_keys = set(expected_fields)
|
||||
actual_keys = set(extra)
|
||||
|
||||
missing_fields = [field for field in expected_fields if field not in actual_keys]
|
||||
if missing_fields:
|
||||
validator.error(
|
||||
path,
|
||||
"champs extra manquants pour "
|
||||
f"la nature « {nature} » : {', '.join(missing_fields)}",
|
||||
)
|
||||
|
||||
unexpected_fields = sorted(actual_keys - expected_keys)
|
||||
if unexpected_fields:
|
||||
validator.error(
|
||||
path,
|
||||
"champs extra inattendus pour "
|
||||
f"la nature « {nature} » : {', '.join(unexpected_fields)}",
|
||||
)
|
||||
|
||||
for field in expected_fields:
|
||||
if field not in extra:
|
||||
continue
|
||||
|
||||
value = extra[field]
|
||||
if field == "logograms":
|
||||
if not isinstance(value, list) or not all(
|
||||
is_non_empty_string(item) for item in value
|
||||
):
|
||||
validator.error(
|
||||
path,
|
||||
"extra.logograms doit être un tableau de chaînes non vides",
|
||||
)
|
||||
elif not isinstance(value, str):
|
||||
validator.error(path, f"extra.{field} doit être une chaîne")
|
||||
|
||||
required_fields = ("meaning", "stem") if nature == "verbe" else ("meaning",)
|
||||
for field in required_fields:
|
||||
value = extra.get(field)
|
||||
if isinstance(value, str) and not value.strip():
|
||||
validator.error(path, f"extra.{field} doit être une chaîne non vide")
|
||||
|
||||
|
||||
def filename_mzl(path: Path, validator: Validator) -> str | None:
|
||||
match = MZL_FILENAME_RE.fullmatch(path.name)
|
||||
if match is None:
|
||||
validator.error(path, "le nom du fichier doit suivre le format mzl-XXX.md")
|
||||
return None
|
||||
|
||||
value = match.group(1)
|
||||
if int(value) == 0:
|
||||
validator.error(path, "le numéro MZL doit être compris entre 001 et 999")
|
||||
return None
|
||||
return value
|
||||
|
||||
|
||||
def check_sign(
|
||||
path: Path,
|
||||
metadata: dict[str, Any],
|
||||
expected_mzl: str | None,
|
||||
validator: Validator,
|
||||
) -> None:
|
||||
extra = require_table(metadata, "extra", path, validator)
|
||||
if extra is None:
|
||||
if "natures" not in taxonomies:
|
||||
validator.error(path, "champ taxonomies manquant : natures")
|
||||
return
|
||||
|
||||
require_string(extra, "sign", path, validator)
|
||||
natures = taxonomies["natures"]
|
||||
if not check_string_list(natures, "taxonomies.natures", path, validator):
|
||||
return
|
||||
|
||||
declared_mzl = extra.get("mzl")
|
||||
if not isinstance(declared_mzl, str) or MZL_VALUE_RE.fullmatch(declared_mzl) is None:
|
||||
validator.error(path, "extra.mzl doit être une chaîne de trois chiffres ASCII")
|
||||
if len(natures) != 1:
|
||||
validator.error(path, "taxonomies.natures doit contenir exactement une nature")
|
||||
return
|
||||
if int(declared_mzl) == 0:
|
||||
validator.error(path, "extra.mzl doit être compris entre 001 et 999")
|
||||
|
||||
nature = natures[0]
|
||||
if nature not in VOCABULARY_FIELDS:
|
||||
validator.error(path, f"nature grammaticale inconnue : {nature!r}")
|
||||
return
|
||||
if expected_mzl is not None and declared_mzl != expected_mzl:
|
||||
validator.error(
|
||||
path,
|
||||
f'extra.mzl vaut "{declared_mzl}", mais le fichier indique MZL {expected_mzl}',
|
||||
)
|
||||
|
||||
check_fields(metadata, "extra", VOCABULARY_FIELDS[nature], path, validator)
|
||||
|
||||
|
||||
def main() -> int:
|
||||
validator = Validator()
|
||||
|
||||
if not CONTENT_DIR.is_dir():
|
||||
validator.error(None, f"répertoire introuvable : {CONTENT_DIR}")
|
||||
return validator.finish()
|
||||
|
||||
print("Vérification des contenus…", flush=True)
|
||||
print("Vérification des fiches…", flush=True)
|
||||
for path in sorted(CONTENT_DIR.rglob("*.md")):
|
||||
metadata = read_front_matter(path, validator)
|
||||
if metadata is None:
|
||||
relative_path = path.relative_to(CONTENT_DIR)
|
||||
if path.name == "_index.md" or len(relative_path.parts) == 1:
|
||||
continue
|
||||
|
||||
structure = check_structure(path, metadata, validator)
|
||||
if structure is None:
|
||||
section = relative_path.parts[0]
|
||||
if section not in CONTENT_SECTIONS:
|
||||
validator.error(path, f"section inconnue : {section}")
|
||||
continue
|
||||
|
||||
section, is_draft = structure
|
||||
expected_mzl = filename_mzl(path, validator) if section == "signes" else None
|
||||
if is_draft:
|
||||
result = read_front_matter(path, validator)
|
||||
if result is None:
|
||||
continue
|
||||
metadata, front_matter = result
|
||||
|
||||
check_common_fields(metadata, front_matter, path, validator)
|
||||
|
||||
if section == "vocabulaire":
|
||||
check_vocabulary(path, metadata, validator)
|
||||
elif section == "signes":
|
||||
check_sign(path, metadata, expected_mzl, validator)
|
||||
check_vocabulary(metadata, path, validator)
|
||||
else:
|
||||
for table_name, fields in SECTION_FIELDS[section].items():
|
||||
check_fields(metadata, table_name, fields, path, validator)
|
||||
|
||||
return validator.finish()
|
||||
|
||||
|
||||
Reference in New Issue
Block a user