habit-hooks-java 1.3.0__py3-none-any.whl

habit_hooks_java/__init__.py

@@ -0,0 +1 @@
+"""The java Habit Hooks plugin: package data discovered via the habit_hooks.plugins entry point."""

habit_hooks_java/config.toml

@@ -0,0 +1,21 @@
+# Java plugin defaults.
+language = "java"
+# A project naming no `files` of its own scans what its plugins declare, so this
+# is the first run for anyone `habit-hooks init` set up. `target/` is where
+# Maven puts generated sources and `build/` is where Gradle puts its own — code
+# the project did not write and cannot change.
+#
+# The exclusions name `*.java` rather than the whole directory because a
+# plugin's exclusions bind the union of every active plugin's globs, not just
+# its own (docs/config.md). `node_modules`, `vendor` and `site-packages` are
+# names no language keeps source under, so excluding those wholesale is free;
+# `build` is not in that class, and a bare `!**/build/**` here stopped a
+# python+java project scanning its own `scripts/build/*.py`.
+files = ["**/*.java", "!**/target/**/*.java", "!**/build/**/*.java"]
+sensors = ["pmd"]
+transformers = []
+
+# The pmd sensor spawns the pmd binary directly.
+detectors = [
+  { name = "pmd", kind = "command", install = "brew install pmd" },
+]

habit_hooks_java/sensors/pmd-ruleset.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ruleset name="habit-hooks"
+         xmlns="http://pmd.sourceforge.net/ruleset/2.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://pmd.sourceforge.net/ruleset/2.0.0 https://pmd.sourceforge.io/ruleset_2_0_0.xsd">
+  <description>Habit-hooks structural smell rules. Reached for only when the
+  project names no PMD ruleset of its own; a project's own ruleset wins.</description>
+  <rule ref="category/java/design.xml/ExcessiveParameterList">
+    <properties><property name="minimum" value="4"/></properties>
+  </rule>
+  <rule ref="category/java/design.xml/CyclomaticComplexity">
+    <properties><property name="methodReportLevel" value="10"/></properties>
+  </rule>
+  <rule ref="category/java/design.xml/NcssCount">
+    <properties><property name="methodReportLevel" value="12"/></properties>
+  </rule>
+  <rule ref="category/java/bestpractices.xml/UnusedLocalVariable"/>
+  <rule ref="category/java/codestyle.xml/UnnecessaryImport"/>
+  <rule ref="category/java/errorprone.xml/EmptyCatchBlock"/>
+</ruleset>

habit_hooks_java/sensors/pmd.toml

@@ -0,0 +1 @@
+command = "${python} ${dir}/pmd_sensor.py ${args} -- ${files}"

habit_hooks_java/sensors/pmd_sensor.py

@@ -0,0 +1,199 @@
+"""Run PMD and print canonical smell findings.
+
+PMD exits 4 when it finds violations, 0 when clean, and 1/2/5 on exceptions,
+usage errors and recoverable errors (since 7.3.0) — so a bare pipe cannot tell
+a clean run from a crash. This wrapper runs PMD against the scoped files,
+treats only 0/4 as success, and shapes each violation into the canonical
+finding, mapping PMD rule names to smell keys.
+
+PMD never discovers a project ruleset on its own — ``-R`` is required — so the
+ruleset is resolved here: a ``--rulesets`` among the sensor's ``args`` (the
+project naming its config explicitly) wins; then the first conventional ruleset
+file the Java ecosystem's build tools point at, in the project directory only;
+then the plugin's bundled ``pmd-ruleset.xml`` as the answer to "the project has
+none".
+
+PMD 7's picocli reads a positional path that directly follows the ruleset value
+as another ``-R`` value (``-R ruleset.xml file.java`` analyses nothing), so the
+wrapper uses the short forms ``-R`` and per-file ``-d``, which do not. Verified
+against PMD 7.26.0.
+
+The sensor's own command spells ``${args} -- ${files}``, so ``sys.argv[1:]``
+carries both halves of ``[sensors.pmd] args`` on one side of a literal ``--``
+and the scoped files on the other — that is what lets a project pass any PMD
+flag (``--aux-classpath``, ``--minimum-priority``, ...) through untouched
+instead of every argv token becoming a bogus ``-d`` file argument.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+RULE_SMELLS = {
+    "ExcessiveParameterList": "too-many-parameters",
+    "CyclomaticComplexity": "high-complexity",
+    "NcssCount": "oversized-function",
+    "UnusedLocalVariable": "unused-variable",
+    "UnnecessaryImport": "unused-import",
+    "EmptyCatchBlock": "swallowed-exception",
+}
+
+# NcssCount and CyclomaticComplexity each report classes, methods and
+# constructors off one rule, and the catalogue has a smell only for oversized
+# and over-complex methods, so class-level violations are dropped. The
+# distinction lives in PMD's own message template, which is the only structural
+# signal the JSON report carries for it.
+METHOD_LEVEL_RULES = ("NcssCount", "CyclomaticComplexity")
+METHOD_LEVEL_PREFIXES = ("The method", "The constructor")
+
+# The ruleset names Maven and Gradle PMD setups conventionally point at, in
+# the order a project directory is checked. PMD itself offers no discovery
+# signal (it never looks one up), so this is the knip-shaped search for the
+# project's own config; a ``--rulesets`` in the sensor's args overrides it.
+RULESET_LOCATIONS = (
+    "src/main/resources/pmd/ruleset.xml",
+    "pmd/ruleset.xml",
+    "ruleset.xml",
+    "pmd.xml",
+)
+
+SUCCESS_EXIT_CODES = (0, 4)
+RULESET_OPTIONS = ("--rulesets", "-R")
+# The attached spellings picocli also takes, longest prefix first so `-R=x` is
+# not read as a bare `-R` with `=x` on it. A spelling missed here does not fall
+# back: the project's `-R` stays in the tail, ours goes in beside it, and PMD
+# unions the two rulesets rather than using theirs.
+ATTACHED_RULESET_PREFIXES = ("--rulesets=", "-R=", "-R")
+
+
+def run_pmd(arguments: list[str]) -> subprocess.CompletedProcess[str]:
+    """What PMD said, or what a shell says about a PMD nobody installed.
+
+    The plugin does not ship the distribution, so ``pmd`` is the command that
+    goes missing — and an absent one raised a ``FileNotFoundError`` out of
+    here, making twenty lines of Python internals the sensor's diagnosis
+    (#114). This wrapper is what looks for pmd, so it answers the way the
+    shell would have, and that phrase is what the run recognises to name the
+    missing tool.
+    """
+    command = ["pmd", "check", "--no-cache", "--format", "json"]
+    try:
+        return subprocess.run(
+            [*command, *arguments], capture_output=True, text=True
+        )
+    except FileNotFoundError:
+        return subprocess.CompletedProcess(command, 127, "", "pmd: command not found\n")
+
+
+def split_argv(argv: list[str]) -> tuple[list[str], list[str]]:
+    """``argv``, split on the last literal ``--``: PMD's own flags before it,
+    the files to analyse after.
+
+    The template spells ``${args} -- ${files}``, so the separator sits after
+    everything ``args`` can contribute and before every file: the *last* ``--``
+    is always ours, whatever a project wrote into its args.
+    """
+    if "--" not in argv:
+        return argv, []
+    index = len(argv) - 1 - argv[::-1].index("--")
+    return argv[:index], argv[index + 1 :]
+
+
+def ruleset_of(argv: list[str], project: Path) -> tuple[Path, list[str]]:
+    """The ruleset in force, and the remaining args with no ruleset named.
+
+    A ``--rulesets``/``-R`` among the sensor's args is the project's own config
+    and wins over everything; PMD only ever gets one, so it is pulled out of
+    the tail rather than left beside the wrapper's own.
+    """
+    for i, token in enumerate(argv):
+        if token in RULESET_OPTIONS and i + 1 < len(argv):
+            return Path(argv[i + 1]), [*argv[:i], *argv[i + 2 :]]
+        for prefix in ATTACHED_RULESET_PREFIXES:
+            if token.startswith(prefix) and len(token) > len(prefix):
+                return Path(token[len(prefix) :]), [*argv[:i], *argv[i + 1 :]]
+    for name in RULESET_LOCATIONS:
+        if (project / name).is_file():
+            return project / name, argv
+    return Path(__file__).with_name("pmd-ruleset.xml"), argv
+
+
+def violations(report: dict) -> list[dict]:
+    return [
+        {"file": entry["filename"], "violation": violation}
+        for entry in report.get("files", [])
+        for violation in entry["violations"]
+    ]
+
+
+def smell_of(entry: dict) -> str | None:
+    violation = entry["violation"]
+    rule = violation["rule"]
+    if rule in METHOD_LEVEL_RULES and not violation["description"].startswith(
+        METHOD_LEVEL_PREFIXES
+    ):
+        return None
+    return RULE_SMELLS.get(rule)
+
+
+def issue(entry: dict) -> dict:
+    violation = entry["violation"]
+    return {
+        "key": entry["file"],
+        "details": {
+            "file": entry["file"],
+            "line": violation["beginline"],
+            "message": violation["description"],
+            "source": "pmd:" + violation["rule"],
+        },
+    }
+
+
+def findings(entries: list[dict]) -> list[dict]:
+    by_smell: dict[str, list[dict]] = {}
+    for entry in entries:
+        smell = smell_of(entry)
+        if smell is not None:
+            by_smell.setdefault(smell, []).append(issue(entry))
+    return [
+        {"smell": smell, "details": {}, "issues": issues}
+        for smell, issues in by_smell.items()
+    ]
+
+
+def main() -> int:
+    argv = sys.argv[1:]
+    if not argv:
+        print("[]")
+        return 0
+    pmd_args, files = split_argv(argv)
+    ruleset, remaining_args = ruleset_of(pmd_args, Path.cwd())
+    file_args = [token for file in files for token in ("-d", file)]
+    result = run_pmd(["-R", str(ruleset), *remaining_args, *file_args])
+    if result.returncode not in SUCCESS_EXIT_CODES:
+        sys.stderr.write(processing_errors(result.stdout) or result.stderr or result.stdout)
+        return 2
+    print(json.dumps(findings(violations(json.loads(result.stdout)))))
+    return 0
+
+
+def processing_errors(stdout: str) -> str:
+    """What a non-successful run actually failed on.
+
+    PMD's own stderr on a recoverable error is a generic "an error occurred,
+    report a bug" — while the JSON report it still writes to stdout names the
+    file and the parse failure. That message is the one a reader can act on.
+    """
+    try:
+        report = json.loads(stdout)
+    except json.JSONDecodeError:
+        return ""
+    errors = report.get("processingErrors", [])
+    return "".join(f"{entry['filename']}: {entry['message']}\n" for entry in errors)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

habit_hooks_java-1.3.0.dist-info/METADATA

@@ -0,0 +1,5 @@
+Metadata-Version: 2.5
+Name: habit-hooks-java
+Version: 1.3.0
+Summary: The Java Habit Hooks plugin
+Requires-Python: >=3.11

habit_hooks_java-1.3.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+habit_hooks_java/__init__.py,sha256=xHO-Wg-9kTlOdgI7Aw-3MW1FF6H76XlKk9GC_xY8Bis,100
+habit_hooks_java/config.toml,sha256=zcD6rw5-JYAmbZ_E46z7yBT-6PGNmdF-20rccWWtgFs,1009
+habit_hooks_java/sensors/pmd-ruleset.xml,sha256=6bSYSFDpQq9rqtJQaG2dQSRqTPyI79vUxbUjsTmM4n0,1095
+habit_hooks_java/sensors/pmd.toml,sha256=AtlgxHMrGK9pni5Hsx8uUEcPtq4_Im9BvbnQJ8lRlmc,63
+habit_hooks_java/sensors/pmd_sensor.py,sha256=FuH67kn_4VEov89OKb20kxHnfVL9D7EwV3sDeOPy3W4,7840
+habit_hooks_java-1.3.0.dist-info/METADATA,sha256=hEJgJyCbg5N263Uk04vdRSNydoDMNXLLHJTAMzzK8kY,121
+habit_hooks_java-1.3.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+habit_hooks_java-1.3.0.dist-info/entry_points.txt,sha256=i8rJH3dAlFmEO9_aH5KxDsp6pxnXkvKld_zD7jykbbA,46
+habit_hooks_java-1.3.0.dist-info/RECORD,,

habit_hooks_java-1.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

habit_hooks_java-1.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[habit_hooks.plugins]
+java = habit_hooks_java