jev-gate 0.0.2__py3-none-any.whl

jev_gate/__main__.py

@@ -0,0 +1,30 @@
+import os
+import sys
+
+from jev_gate.anywhere import Anywhere
+from jev_gate.application import Application
+from jev_gate.github_log import GithubLog
+from jev_gate.typesafe_connection import TypeSafeConnection
+
+
+def main() -> int:
+    log = GithubLog(sys.stdout)
+    try:
+        code = Application(
+            sys.argv[1:],
+            TypeSafeConnection(os.environ.get("TYPESAFE_API_KEY", "")),
+            log,
+        ).code()
+    except Exception as e:
+        reasons = []
+        cause: BaseException | None = e
+        while cause is not None:
+            reasons.append(str(cause))
+            cause = cause.__cause__
+        log.error(Anywhere("jev-gate"), "jev-gate", " <- ".join(reasons))
+        code = 2
+    return code
+
+
+if __name__ == "__main__":
+    sys.exit(main())

jev_gate/answers.py

@@ -0,0 +1,41 @@
+from jev_gate.contracts import Answer, Answers
+
+
+class Probability(Answer):
+    def __init__(self, value: float):
+        self.value = value
+
+    def oversized(self) -> bool:
+        return False
+
+    def probability(self) -> float:
+        return self.value
+
+
+class Oversized(Answer):
+    def __init__(self, reason: str):
+        self.reason = reason
+
+    def oversized(self) -> bool:
+        return True
+
+    def probability(self) -> float:
+        raise Exception(f"An oversized candidate has no probability: {self.reason}")
+
+
+class Probabilities(Answers):
+    def __init__(self, values: dict[str, float]):
+        self.values = values
+
+    def answer(self, key: str) -> Answer:
+        if key not in self.values:
+            raise Exception(f"Jev returned no answer for the '{key}' question")
+        return Probability(self.values[key])
+
+
+class OversizedAnswers(Answers):
+    def __init__(self, reason: str):
+        self.reason = reason
+
+    def answer(self, key: str) -> Answer:
+        return Oversized(self.reason)

jev_gate/anywhere.py

@@ -0,0 +1,15 @@
+from jev_gate.contracts import Lines, Place
+
+
+class Anywhere(Place):
+    def __init__(self, label: str):
+        self.label = label
+
+    def touches(self, lines: Lines) -> bool:
+        return True
+
+    def properties(self) -> dict[str, str]:
+        return {}
+
+    def __str__(self) -> str:
+        return self.label

jev_gate/application.py

@@ -0,0 +1,95 @@
+import argparse
+import os
+
+import yaml
+
+from jev_gate.contracts import Connection, Log, Settings, Sources
+from jev_gate.diff_sources import DiffSources
+from jev_gate.directory import PackDirectory
+from jev_gate.full_sources import FullSources
+from jev_gate.gates_file import GatesFile
+from jev_gate.git import GitRepository
+from jev_gate.joined import Joined
+from jev_gate.selection import Selection
+from jev_gate.trial import Trial
+from jev_gate.valid_gates_file import ValidGatesFile
+from jev_gate.worktree import Worktree
+
+
+class Application:
+    def __init__(self, args: list[str], connection: Connection, log: Log):
+        self.args = args
+        self.connection = connection
+        self.log = log
+
+    def code(self) -> int:
+        options = self._options()
+        settings = self._settings(options.config)
+        gates = settings.gates(options.mode)
+        model = self.connection.model(settings.model())
+        sources = self._sources(options, settings)
+        candidates = Joined(
+            [sources.candidates(scope) for scope in settings.scopes(options.mode)]
+        )
+        verdicts = Trial(gates, candidates, model, options.jobs).verdicts()
+        for verdict in verdicts:
+            verdict.report(self.log)
+        code = max([verdict.code() for verdict in verdicts], default=0)
+        self.log.info(
+            f"jev-gate: {len(gates)} gate(s) in {options.mode} mode gave "
+            f"{len(verdicts)} verdict(s), "
+            f"{sum(1 for verdict in verdicts if verdict.code() == 1)} violation(s), "
+            f"exit code {code}"
+        )
+        return code
+
+    def _options(self) -> argparse.Namespace:
+        parser = argparse.ArgumentParser(prog="jev-gate", exit_on_error=False)
+        parser.add_argument("--config", default=".github/jev-gates.yml")
+        parser.add_argument("--mode", choices=["diff", "full"], default="diff")
+        parser.add_argument("--base", default="")
+        parser.add_argument("--root", default=".")
+        parser.add_argument("--jobs", type=int, default=8)
+        try:
+            options = parser.parse_args(self.args)
+        except (argparse.ArgumentError, SystemExit) as e:
+            raise Exception(f"The arguments {self.args} are not understood") from e
+        if options.mode == "diff" and not options.base.strip():
+            raise Exception(
+                "Diff mode needs --base, the commit the change is compared with"
+            )
+        if options.jobs < 1:
+            raise Exception("--jobs must be at least 1")
+        return options
+
+    def _settings(self, path: str) -> Settings:
+        try:
+            with open(path, encoding="utf-8") as stream:
+                text = stream.read()
+        except OSError as e:
+            raise Exception(f"The gates file '{path}' cannot be read") from e
+        with open(
+            os.path.join(os.path.dirname(__file__), "scopes.yml"), encoding="utf-8"
+        ) as stream:
+            catalog = yaml.safe_load(stream)
+        return ValidGatesFile(GatesFile(text, catalog), text, catalog)
+
+    def _sources(self, options: argparse.Namespace, settings: Settings) -> Sources:
+        repository = GitRepository(options.root)
+        tree = Selection(Worktree(repository, options.root), settings.mask())
+        packs = (
+            PackDirectory(os.path.join(os.path.dirname(__file__), "packs"))
+            .packs()
+            .extended(settings.queries())
+        )
+        result: Sources = FullSources(tree, packs)
+        if options.mode == "diff":
+            try:
+                base = repository.output("merge-base", options.base, "HEAD").strip()
+            except Exception as e:
+                raise Exception(
+                    f"The base '{options.base}' is not in the history; "
+                    "check out with 'fetch-depth: 0'"
+                ) from e
+            result = DiffSources(repository, base, tree, packs)
+        return result

jev_gate/candidate.py

@@ -0,0 +1,28 @@
+from jev_gate.contracts import Candidate, Place, State
+from jev_gate.state import KnownState, UnknownState
+
+
+class FieldCandidate(Candidate):
+    def __init__(self, scope: str, name: str, place: Place, fields: dict[str, str]):
+        self.kind = scope
+        self.label = name
+        self.spot = place
+        self.fields = fields
+
+    def scope(self) -> str:
+        return self.kind
+
+    def name(self) -> str:
+        return self.label
+
+    def place(self) -> Place:
+        return self.spot
+
+    def state(self, fields: tuple[str, ...]) -> State:
+        absent = [field for field in fields if field not in self.fields]
+        result: State = (
+            UnknownState(absent[0])
+            if absent
+            else KnownState({field: self.fields[field] for field in fields})
+        )
+        return result

jev_gate/changed_tests.py

@@ -0,0 +1,45 @@
+from collections.abc import Iterator
+
+from jev_gate.candidate import FieldCandidate
+from jev_gate.contracts import Candidate, Candidates, Lines, Tree
+from jev_gate.listed import Listed
+from jev_gate.packs import Packs
+from jev_gate.selection import Selection
+from jev_gate.syntax_candidates import SyntaxCandidates
+from jev_gate.touched import Touched
+
+
+class ChangedTests(Candidates):
+    def __init__(self, before: Tree, after: Tree, packs: Packs, lines: Lines):
+        self.before = before
+        self.after = after
+        self.packs = packs
+        self.lines = lines
+
+    def __iter__(self) -> Iterator[Candidate]:
+        edited = list(
+            Touched(SyntaxCandidates(self.after, self.packs, "test"), self.lines)
+        )
+        paths = sorted({test.place().properties()["file"] for test in edited})
+        previous = {
+            (test.place().properties()["file"], test.name()): self._source(test)
+            for test in SyntaxCandidates(
+                Selection(
+                    self.before, Listed([p for p in paths if self.before.present(p)])
+                ),
+                self.packs,
+                "test",
+            )
+        }
+        for test in edited:
+            key = (test.place().properties()["file"], test.name())
+            if key in previous and previous[key] != self._source(test):
+                yield FieldCandidate(
+                    "changed_test",
+                    test.name(),
+                    test.place(),
+                    {"before": previous[key], "after": self._source(test)},
+                )
+
+    def _source(self, test: Candidate) -> str:
+        return test.state(("source",)).payload()["source"]

jev_gate/commits.py

@@ -0,0 +1,66 @@
+from collections.abc import Iterator
+
+from jev_gate.candidate import FieldCandidate
+from jev_gate.contracts import Candidate, Candidates, Mask, Repository
+from jev_gate.listed import Listed
+from jev_gate.packs import Packs
+from jev_gate.patch import Patch
+from jev_gate.revision import Revision
+from jev_gate.selection import Selection
+from jev_gate.sha import Sha
+from jev_gate.syntax_candidates import SyntaxCandidates
+from jev_gate.touched import Touched
+
+
+class Commits(Candidates):
+    def __init__(self, repository: Repository, base: str, mask: Mask, packs: Packs):
+        self.repository = repository
+        self.base = base
+        self.mask = mask
+        self.packs = packs
+
+    def __iter__(self) -> Iterator[Candidate]:
+        log = self.repository.output(
+            "log",
+            "--reverse",
+            "--no-merges",
+            "--format=%H%x1f%s%x1f%b%x1e",
+            f"{self.base}..HEAD",
+        )
+        for record in log.split("\x1e"):
+            if record.strip("\n"):
+                sha, subject, body = record.strip("\n").split("\x1f", 2)
+                yield self._candidate(sha, subject, body.strip())
+
+    def _candidate(self, sha: str, subject: str, body: str) -> Candidate:
+        patch = Patch(
+            self.repository.output(
+                "show", "--format=", "--no-color", "--no-ext-diff", "--no-renames", sha
+            )
+        )
+        sections = [
+            section for section in patch.sections() if self.mask.matches(section.path())
+        ]
+        tests = Touched(
+            SyntaxCandidates(
+                Selection(
+                    Revision(self.repository, sha), Listed([s.path() for s in sections])
+                ),
+                self.packs,
+                "test",
+            ),
+            patch,
+        )
+        return FieldCandidate(
+            "commit",
+            subject,
+            Sha(sha),
+            {
+                "subject": subject,
+                "message": body,
+                "diff": "".join(str(section) for section in sections),
+                "tests": "\n".join(
+                    test.state(("phrase",)).payload()["phrase"] for test in tests
+                ),
+            },
+        )

jev_gate/contracts.py

@@ -0,0 +1,184 @@
+from abc import ABC, abstractmethod
+from collections.abc import Iterator
+
+
+class Repository(ABC):
+    @abstractmethod
+    def output(self, *args: str) -> str:
+        pass
+
+
+class Tree(ABC):
+    @abstractmethod
+    def paths(self) -> list[str]:
+        pass
+
+    @abstractmethod
+    def text(self, path: str) -> str:
+        pass
+
+    @abstractmethod
+    def present(self, path: str) -> bool:
+        pass
+
+
+class Mask(ABC):
+    @abstractmethod
+    def matches(self, path: str) -> bool:
+        pass
+
+
+class Lines(ABC):
+    @abstractmethod
+    def touched(self, path: str, first: int, last: int) -> bool:
+        pass
+
+
+class Place(ABC):
+    @abstractmethod
+    def touches(self, lines: Lines) -> bool:
+        pass
+
+    @abstractmethod
+    def properties(self) -> dict[str, str]:
+        pass
+
+
+class State(ABC):
+    @abstractmethod
+    def known(self) -> bool:
+        pass
+
+    @abstractmethod
+    def payload(self) -> dict[str, str]:
+        pass
+
+    @abstractmethod
+    def missing(self) -> str:
+        pass
+
+
+class Candidate(ABC):
+    @abstractmethod
+    def scope(self) -> str:
+        pass
+
+    @abstractmethod
+    def name(self) -> str:
+        pass
+
+    @abstractmethod
+    def place(self) -> Place:
+        pass
+
+    @abstractmethod
+    def state(self, fields: tuple[str, ...]) -> State:
+        pass
+
+
+class Candidates(ABC):
+    @abstractmethod
+    def __iter__(self) -> Iterator[Candidate]:
+        pass
+
+
+class Answer(ABC):
+    @abstractmethod
+    def oversized(self) -> bool:
+        pass
+
+    @abstractmethod
+    def probability(self) -> float:
+        pass
+
+
+class Answers(ABC):
+    @abstractmethod
+    def answer(self, key: str) -> Answer:
+        pass
+
+
+class Model(ABC):
+    @abstractmethod
+    def answers(self, state: dict[str, str], questions: dict[str, str]) -> Answers:
+        pass
+
+
+class Log(ABC):
+    @abstractmethod
+    def error(self, place: Place, title: str, text: str):
+        pass
+
+    @abstractmethod
+    def warning(self, place: Place, title: str, text: str):
+        pass
+
+    @abstractmethod
+    def info(self, text: str):
+        pass
+
+
+class Verdict(ABC):
+    @abstractmethod
+    def report(self, log: Log):
+        pass
+
+    @abstractmethod
+    def code(self) -> int:
+        pass
+
+
+class Gate(ABC):
+    @abstractmethod
+    def name(self) -> str:
+        pass
+
+    @abstractmethod
+    def admits(self, candidate: Candidate) -> bool:
+        pass
+
+    @abstractmethod
+    def fields(self) -> tuple[str, ...]:
+        pass
+
+    @abstractmethod
+    def question(self) -> str:
+        pass
+
+    @abstractmethod
+    def verdict(self, candidate: Candidate, answer: Answer) -> Verdict:
+        pass
+
+
+class Sources(ABC):
+    @abstractmethod
+    def candidates(self, scope: str) -> Candidates:
+        pass
+
+
+class Connection(ABC):
+    @abstractmethod
+    def model(self, version: str) -> Model:
+        pass
+
+
+class Settings(ABC):
+    @abstractmethod
+    def model(self) -> str:
+        pass
+
+    @abstractmethod
+    def gates(self, mode: str) -> list[Gate]:
+        pass
+
+    @abstractmethod
+    def scopes(self, mode: str) -> list[str]:
+        pass
+
+    @abstractmethod
+    def queries(self) -> dict[str, dict[str, dict]]:
+        pass
+
+    @abstractmethod
+    def mask(self) -> Mask:
+        pass

jev_gate/diff_sources.py

@@ -0,0 +1,56 @@
+from functools import cached_property
+
+from jev_gate.changed_tests import ChangedTests
+from jev_gate.commits import Commits
+from jev_gate.contracts import Candidates, Repository, Sources
+from jev_gate.full_sources import FullSources
+from jev_gate.hunks import Hunks
+from jev_gate.packs import Packs
+from jev_gate.patch import Patch
+from jev_gate.revision import Revision
+from jev_gate.selection import Selection
+from jev_gate.touched import Touched
+
+
+class DiffSources(Sources):
+    def __init__(
+        self, repository: Repository, base: str, tree: Selection, packs: Packs
+    ):
+        self.repository = repository
+        self.base = base
+        self.tree = tree
+        self.packs = packs
+
+    def candidates(self, scope: str) -> Candidates:
+        special = {
+            "hunk": lambda: Hunks(self._patch, self.tree),
+            "commit": lambda: Commits(
+                self.repository, self.base, self.tree, self.packs
+            ),
+            "changed_test": lambda: ChangedTests(
+                Selection(Revision(self.repository, self.base), self.tree),
+                self.tree,
+                self.packs,
+                self._patch,
+            ),
+        }
+        return special.get(
+            scope,
+            lambda: Touched(
+                FullSources(self.tree, self.packs).candidates(scope), self._patch
+            ),
+        )()
+
+    @cached_property
+    def _patch(self) -> Patch:
+        return Patch(
+            self.repository.output(
+                "diff",
+                "--no-color",
+                "--no-ext-diff",
+                "--no-renames",
+                "-U3",
+                self.base,
+                "--",
+            )
+        )

jev_gate/directory.py

@@ -0,0 +1,24 @@
+import os
+
+import yaml
+
+from jev_gate.pack import Pack
+from jev_gate.packs import Packs
+
+
+class PackDirectory:
+    def __init__(self, path: str):
+        self.path = path
+
+    def packs(self) -> Packs:
+        return Packs(
+            [
+                Pack(os.path.splitext(name)[0], self._data(name))
+                for name in sorted(os.listdir(self.path))
+                if name.endswith(".yml")
+            ]
+        )
+
+    def _data(self, name: str) -> dict:
+        with open(os.path.join(self.path, name), encoding="utf-8") as stream:
+            return yaml.safe_load(stream)

jev_gate/files.py

@@ -0,0 +1,21 @@
+from collections.abc import Iterator
+
+from jev_gate.candidate import FieldCandidate
+from jev_gate.contracts import Candidate, Candidates, Tree
+from jev_gate.span import Span
+
+
+class Files(Candidates):
+    def __init__(self, tree: Tree):
+        self.tree = tree
+
+    def __iter__(self) -> Iterator[Candidate]:
+        for path in self.tree.paths():
+            text = self.tree.text(path)
+            if "\0" not in text:
+                yield FieldCandidate(
+                    "file",
+                    path,
+                    Span(path, 1, max(1, len(text.splitlines()))),
+                    {"path": path, "text": text},
+                )

jev_gate/full_sources.py

@@ -0,0 +1,16 @@
+from jev_gate.contracts import Candidates, Sources, Tree
+from jev_gate.files import Files
+from jev_gate.packs import Packs
+from jev_gate.syntax_candidates import SyntaxCandidates
+
+
+class FullSources(Sources):
+    def __init__(self, tree: Tree, packs: Packs):
+        self.tree = tree
+        self.packs = packs
+
+    def candidates(self, scope: str) -> Candidates:
+        result: Candidates = SyntaxCandidates(self.tree, self.packs, scope)
+        if scope == "file":
+            result = Files(self.tree)
+        return result

jev_gate/gate.py

@@ -0,0 +1,37 @@
+from jev_gate.contracts import Answer, Candidate, Gate, Verdict
+from jev_gate.verdicts import Blocked, Fired, Passed, Skipped
+
+
+class YamlGate(Gate):
+    def __init__(self, data: dict, oversize: str):
+        self.data = data
+        self.oversize = oversize
+
+    def name(self) -> str:
+        return self.data["id"]
+
+    def admits(self, candidate: Candidate) -> bool:
+        return candidate.scope() == self.data[
+            "scope"
+        ] and candidate.name() not in self.data.get("allow", [])
+
+    def fields(self) -> tuple[str, ...]:
+        return tuple(self.data["state"])
+
+    def question(self) -> str:
+        return self.data["ask"]
+
+    def verdict(self, candidate: Candidate, answer: Answer) -> Verdict:
+        result: Verdict = Passed(self.name())
+        if answer.oversized() and self.data.get("oversize", self.oversize) == "skip":
+            result = Skipped(self.name(), candidate)
+        elif answer.oversized():
+            result = Blocked(self.name(), candidate)
+        elif answer.probability() > float(self.data["fail_above"]):
+            result = Fired(
+                self.name(),
+                str(self.data.get("rule", "")),
+                candidate,
+                answer.probability(),
+            )
+        return result