habit-hooks-java 1.3.0__tar.gz

habit_hooks_java-1.3.0/.gitignore

@@ -0,0 +1,26 @@
+# Per-plugin Node tool deps (installed via pnpm install; see pnpm-workspace.yaml)
+node_modules/
+dist
+coverage
+.DS_Store
+.idea
+.claude-channel/
+*.tgz
+*.log
+.vscode/
+.venv/
+__pycache__/
+*.pyc
+.pytest_cache/
+.spec-runs/
+
+# Workflow orchestration script (run from ~/.claude, never a repo deliverable)
+.claude/workflows-build-overnight.js
+
+# Agent worktrees (created by the harness inside the checkout)
+.claude/worktrees/
+/scratches/
+
+# unsupervised-issues run signals (live mode switch + stop flag)
+.unsupervised-issues.mode
+.unsupervised-issues.stop

habit_hooks_java-1.3.0/PKG-INFO

@@ -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/docs/java-plugin.spec.md

@@ -0,0 +1,215 @@
+# The java plugin — acceptance
+
+The java plugin runs its sensor through the real `habit-sensors` pipeline. These
+cases run the **actual** tool (PMD, from the system `PATH`) against a fixture
+with a known smell and assert the canonical finding comes out, mapped to the
+smell keys in [smell-vocabulary.md](smell-vocabulary.md).
+
+`habit-sensors` is the installed CLI; `pmd` is on the system `PATH`. The sensor
+runs `pmd check --format json`, normalises PMD's exit-4-on-violations into a
+clean run, and reaches for a ruleset the project wrote only after checking the
+conventional Java locations, then falls back to the bundled `pmd-ruleset.xml`
+when the project has none (PMD itself never discovers one).
+
+📄.habit-hooks/config.toml
+```toml
+plugins = ["java"]
+```
+
+## pmd sensor maps rule names to canonical smells
+
+The `pmd` sensor runs PMD with the bundled fallback ruleset and shapes each
+violation into one finding per smell, stamping `source: "pmd:<rule>"` on each
+issue. A five-parameter constructor trips `ExcessiveParameterList` →
+`too-many-parameters`, an unused import trips `UnnecessaryImport` →
+`unused-import`, and a dead local trips `UnusedLocalVariable` →
+`unused-variable`.
+
+📄Billing.java
+```java
+import java.io.File;
+import java.io.IOException;
+class Billing {
+    double charge(double a, double b, double c, double d, double e) {
+        int dead = 1;
+        return a + b + c + d + e;
+    }
+}
+```
+
+```bash
+habit-sensors --all | jq 'sort_by(.smell)[] | {smell, language, key: (.issues[0].key | sub(".*/"; "")), line: .issues[0].details.line, source: .issues[0].details.source}'
+```
+
+🖥️ ✅
+```json
+{
+  "smell": "too-many-parameters",
+  "language": "java",
+  "key": "Billing.java",
+  "line": 4,
+  "source": "pmd:ExcessiveParameterList"
+}
+{
+  "smell": "unused-import",
+  "language": "java",
+  "key": "Billing.java",
+  "line": 1,
+  "source": "pmd:UnnecessaryImport"
+}
+{
+  "smell": "unused-variable",
+  "language": "java",
+  "key": "Billing.java",
+  "line": 5,
+  "source": "pmd:UnusedLocalVariable"
+}
+```
+
+## pmd sensor maps a deeply-branched method to high-complexity
+
+A method whose conditions are littered with `||` exceeds PMD's cyclomatic
+complexity threshold, tripping `CyclomaticComplexity` → `high-complexity` — while
+staying short enough on NCSS that the method is not also flagged oversized.
+
+📄Report.java
+```java
+class Report {
+    int classify(int n) {
+        if (n == 1 || n == 2 || n == 3 || n == 4 || n == 5) return 1;
+        if (n == 6 || n == 7 || n == 8 || n == 9 || n == 10) return 2;
+        if (n == 11 || n == 12 || n == 13 || n == 14 || n == 15) return 3;
+        if (n == 16 || n == 17 || n == 18) return 4;
+        return 0;
+    }
+}
+```
+
+```bash
+habit-sensors --all | jq '.[] | {smell, language, source: .issues[0].details.source}'
+```
+
+🖥️ ✅
+```json
+{
+  "smell": "high-complexity",
+  "language": "java",
+  "source": "pmd:CyclomaticComplexity"
+}
+```
+
+## A project's own ruleset wins over the bundled one
+
+PMD never discovers a project ruleset, so the sensor reaches for one only where
+the Java ecosystem conventionally keeps it. A `src/main/resources/pmd/ruleset.xml`
+that lowers the parameter threshold is in force for the run — the bundled
+fallback is only the answer to "this project has none".
+
+📄src/main/resources/pmd/ruleset.xml
+```xml
+<?xml version="1.0"?>
+<ruleset name="custom" 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>two parameters is already too many</description>
+ <rule ref="category/java/design.xml/ExcessiveParameterList">
+  <properties><property name="minimum" value="2"/></properties>
+ </rule>
+</ruleset>
+```
+
+📄Project.java
+```java
+class Project {
+    void save(String a, String b) {
+    }
+}
+```
+
+```bash
+habit-sensors --all | jq '.[] | {smell, language, key: (.issues[0].key | sub(".*/"; ""))}'
+```
+
+🖥️ ✅
+```json
+{
+  "smell": "too-many-parameters",
+  "language": "java",
+  "key": "Project.java"
+}
+```
+
+## `[sensors.pmd] args` reaches PMD directly
+
+`args` is spliced into the sensor's command as `${args} -- ${files}`, so a real
+PMD flag — not just a ruleset — passes straight through to `pmd check`.
+`ExcessiveParameterList` reports at priority 3 and `UnnecessaryImport` at
+priority 4, so `--minimum-priority 3` keeps the parameter-list violation and
+drops the import one: proof the flag reached PMD's own filtering rather than
+becoming a bogus file argument the sensor could not find.
+
+📄.habit-hooks/config.toml
+```toml
+plugins = ["java"]
+
+[sensors.pmd]
+args = ["--minimum-priority", "3"]
+```
+
+📄Billing.java
+```java
+import java.io.File;
+class Billing {
+    double charge(double a, double b, double c, double d, double e) {
+        return a + b + c + d + e;
+    }
+}
+```
+
+```bash
+habit-sensors --all | jq '.[] | {smell, source: .issues[0].details.source}'
+```
+
+🖥️ ✅
+```json
+{
+  "smell": "too-many-parameters",
+  "source": "pmd:ExcessiveParameterList"
+}
+```
+
+## A crashing pmd fails the run, never reports clean
+
+PMD exits non-zero on a file it cannot parse. The sensor surfaces that as a
+failure — a crashed tool is never a clean run. It exits with a code outside the
+findings range, so `habit-sensors` raises, names the sensor on stderr, and exits
+1 rather than printing an empty (false-clean) result. The failed run carries only
+the reserved `incomplete-run` marker on stdout
+([habit-sensors.spec.md](../../../docs/habit-sensors.spec.md)).
+
+The notice carries PMD's own diagnosis after that first line.
+
+📄broken.java
+```java
+class Broken {
+    void oops( {
+}
+```
+
+```bash
+habit-sensors --all | jq -c '[.[].smell]'
+```
+
+🖥️ ❌ 1
+```json
+["incomplete-run"]
+```
+
+```bash
+habit-sensors --all 2>&1 >/dev/null | sed -n 1p
+```
+
+🖥️ ❌ 1
+```text
+habit-sensors: sensor 'pmd' failed: ${python} ${dir}/pmd_sensor.py ${args} -- ${files}
+```

habit_hooks_java-1.3.0/pyproject.toml

@@ -0,0 +1,16 @@
+[project]
+name = "habit-hooks-java"
+version = "1.3.0"
+description = "The Java Habit Hooks plugin"
+requires-python = ">=3.11"
+dependencies = []
+
+[project.entry-points."habit_hooks.plugins"]
+java = "habit_hooks_java"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/habit_hooks_java"]

habit_hooks_java-1.3.0/src/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-1.3.0/src/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-1.3.0/src/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-1.3.0/src/habit_hooks_java/sensors/pmd.toml

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

habit_hooks_java-1.3.0/src/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/tests/test_a_java_pmd_nobody_installed_is_named.py

@@ -0,0 +1,35 @@
+"""The tool this plugin does not ship must still answer in one line.
+
+The plugin does not bundle the PMD distribution, so ``pmd`` is the command that
+goes missing — and it is spawned from Python, where an absent tool is a
+``FileNotFoundError`` and twenty lines of internals would otherwise become the
+sensor's diagnosis (#114).
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+SENSOR = (
+    Path(__file__).resolve().parents[1] / "src/habit_hooks_java/sensors/pmd_sensor.py"
+)
+
+
+def test_a_java_pmd_nobody_installed_answers_the_way_a_shell_does(
+    tmp_path: Path,
+) -> None:
+    (tmp_path / "App.java").write_text("class App {}\n")
+
+    result = subprocess.run(
+        [sys.executable, str(SENSOR), "App.java"],
+        cwd=tmp_path,
+        capture_output=True,
+        text=True,
+        env={"PATH": "/nonexistent"},
+    )
+
+    assert result.returncode != 0
+    assert result.stdout.strip() == ""
+    assert result.stderr.strip() == "pmd: command not found"

habit_hooks_java-1.3.0/tests/test_class_level_metric_violations_are_dropped.py

@@ -0,0 +1,129 @@
+"""NcssCount and CyclomaticComplexity report classes as well as methods and
+constructors, off one rule each. The catalogue has a smell only for an
+over-complex or oversized *method* — `high-complexity`'s guide says "extract
+one function per branch" — so a class-level violation of either rule must be
+dropped, not forwarded as if it named a function.
+
+The bundled ruleset only sets `methodReportLevel`, leaving
+`CyclomaticComplexity`'s `classReportLevel` at PMD's default of 80: a class of
+many simple methods trips it, and before this fix `smell_of` filtered
+class-level violations for `NcssCount` only, so the class-level
+`CyclomaticComplexity` slipped through as `high-complexity` with no
+over-complex function anywhere in the file.
+"""
+
+from __future__ import annotations
+
+from habit_hooks_java.sensors.pmd_sensor import findings, smell_of
+
+
+def _entry(rule: str, description: str, beginline: int = 1) -> dict:
+    return {
+        "file": "Fat.java",
+        "violation": {
+            "rule": rule,
+            "description": description,
+            "beginline": beginline,
+        },
+    }
+
+
+def test_a_class_level_cyclomatic_complexity_violation_is_dropped() -> None:
+    entry = _entry(
+        "CyclomaticComplexity",
+        "The class 'Fat' has a total cyclomatic complexity of 100 (highest 5).",
+    )
+
+    assert smell_of(entry) is None
+
+
+def test_a_method_level_cyclomatic_complexity_violation_is_high_complexity() -> None:
+    entry = _entry(
+        "CyclomaticComplexity", "The method 'f(int)' has a cyclomatic complexity of 12."
+    )
+
+    assert smell_of(entry) == "high-complexity"
+
+
+def test_a_constructor_level_cyclomatic_complexity_violation_is_high_complexity() -> (
+    None
+):
+    entry = _entry(
+        "CyclomaticComplexity",
+        "The constructor 'Both(int)' has a cyclomatic complexity of 12.",
+    )
+
+    assert smell_of(entry) == "high-complexity"
+
+
+def test_a_class_level_ncss_count_violation_is_still_dropped() -> None:
+    """The behaviour the original filter already had, kept while the filter
+    generalises from one rule to two."""
+    entry = _entry("NcssCount", "The class 'Fat' has an NCSS line count of 200.")
+
+    assert smell_of(entry) is None
+
+
+def test_a_method_level_ncss_count_violation_is_still_oversized_function() -> None:
+    entry = _entry("NcssCount", "The method 'f()' has an NCSS line count of 40.")
+
+    assert smell_of(entry) == "oversized-function"
+
+
+def test_an_enum_level_ncss_count_violation_is_dropped() -> None:
+    """PMD also words this one as 'The enum', 'The interface' and 'The
+    record' — none of them a method or a constructor."""
+    entry = _entry("NcssCount", "The enum 'Kind' has an NCSS line count of 90.")
+
+    assert smell_of(entry) is None
+
+
+def test_excessive_parameter_list_still_maps_to_too_many_parameters() -> None:
+    entry = _entry(
+        "ExcessiveParameterList", "Avoid long parameter lists.", beginline=4
+    )
+
+    assert smell_of(entry) == "too-many-parameters"
+
+
+def test_unnecessary_import_still_maps_to_unused_import() -> None:
+    entry = _entry("UnnecessaryImport", "Unused import 'java.io.File'.")
+
+    assert smell_of(entry) == "unused-import"
+
+
+def test_unused_local_variable_still_maps_to_unused_variable() -> None:
+    entry = _entry(
+        "UnusedLocalVariable", "Avoid unused local variables such as 'dead'."
+    )
+
+    assert smell_of(entry) == "unused-variable"
+
+
+def test_empty_catch_block_still_maps_to_swallowed_exception() -> None:
+    entry = _entry("EmptyCatchBlock", "Avoid empty catch blocks.")
+
+    assert smell_of(entry) == "swallowed-exception"
+
+
+def test_a_class_level_violation_never_reaches_findings() -> None:
+    """The whole shape a real PMD run would produce: a class-level
+    complexity violation sitting beside a real method-level one — only the
+    method-level violation survives into the findings the mapper sees."""
+    entries = [
+        _entry(
+            "CyclomaticComplexity",
+            "The class 'Fat' has a total cyclomatic complexity of 100 (highest 5).",
+        ),
+        _entry(
+            "CyclomaticComplexity",
+            "The method 'f(int)' has a cyclomatic complexity of 12.",
+            beginline=3,
+        ),
+    ]
+
+    result = findings(entries)
+
+    assert len(result) == 1
+    assert result[0]["smell"] == "high-complexity"
+    assert len(result[0]["issues"]) == 1

habit_hooks_java-1.3.0/tests/test_every_ruleset_spelling_wins.py

@@ -0,0 +1,76 @@
+"""A project's ruleset has to be recognised in every spelling PMD accepts.
+
+The bundled ruleset is only the answer to "this project has none", so a project
+that names its own must get theirs *instead* of ours. That only happens if the
+sensor takes their `-R` out of the args: PMD accepts the option more than once
+and unions what it is given, so a spelling the sensor fails to recognise does
+not fall back to ours — it hands PMD both, and the run reports the smells that
+project's ruleset was written to exclude. Silently, at exit 0.
+
+picocli takes five spellings, and `-R=x` / `-Rx` were the two that got through.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from habit_hooks_java.sensors.pmd_sensor import ruleset_of
+
+BUNDLED = "pmd-ruleset.xml"
+THEIRS = "mine.xml"
+
+
+@pytest.mark.parametrize(
+    "args",
+    [
+        ["--rulesets", THEIRS],
+        ["--rulesets=" + THEIRS],
+        ["-R", THEIRS],
+        ["-R=" + THEIRS],
+        ["-R" + THEIRS],
+    ],
+    ids=["--rulesets X", "--rulesets=X", "-R X", "-R=X", "-RX"],
+)
+def test_a_ruleset_named_in_args_is_the_one_pmd_gets(args: list[str]) -> None:
+    ruleset, remaining = ruleset_of(args, Path("/nowhere"))
+
+    assert ruleset == Path(THEIRS)
+    assert remaining == []
+
+
+def test_the_flags_around_a_ruleset_still_reach_pmd() -> None:
+    ruleset, remaining = ruleset_of(
+        ["--aux-classpath", "lib.jar", "-R=" + THEIRS, "--no-progress"],
+        Path("/nowhere"),
+    )
+
+    assert ruleset == Path(THEIRS)
+    assert remaining == ["--aux-classpath", "lib.jar", "--no-progress"]
+
+
+def test_a_project_naming_none_gets_the_bundled_ruleset(tmp_path: Path) -> None:
+    ruleset, remaining = ruleset_of(["--no-progress"], tmp_path)
+
+    assert ruleset.name == BUNDLED
+    assert remaining == ["--no-progress"]
+
+
+def test_a_conventional_ruleset_beats_the_bundled_one(tmp_path: Path) -> None:
+    theirs = tmp_path / "pmd" / "ruleset.xml"
+    theirs.parent.mkdir()
+    theirs.write_text("<ruleset/>")
+
+    assert ruleset_of([], tmp_path) == (theirs, [])
+
+
+def test_a_ruleset_option_with_nothing_after_it_is_left_for_pmd_to_refuse(
+    tmp_path: Path,
+) -> None:
+    """A bare `-R` names nothing, so it is not a ruleset this sensor can honour.
+    Passing it through is what makes PMD say so; swallowing it would run the
+    bundled ruleset under a project's config that was meant to replace it."""
+    ruleset, remaining = ruleset_of(["-R"], tmp_path)
+
+    assert ruleset.name == BUNDLED
+    assert remaining == ["-R"]

habit_hooks_java-1.3.0/tests/test_sensor_args_reach_pmd_not_the_file_list.py

@@ -0,0 +1,90 @@
+"""``[sensors.pmd] args`` must reach PMD itself, not become a file to scan.
+
+Before this fix ``main()`` turned every argv token that was not the ruleset
+into a ``-d <path>`` PMD file argument, so a genuine PMD flag such as
+``--minimum-priority`` broke the run outright (picocli: "Expected parameter
+for option '--dir' but found '--minimum-priority'"). The sensor's command now
+spells ``${args} -- ${files}``, and the wrapper splits ``sys.argv[1:]`` on the
+*last* ``--``: everything before it goes to PMD verbatim, everything after
+becomes a file. A ``--rulesets``/``-R`` on the PMD-flag half is still pulled
+out for `-R`, exactly as it was before this split existed.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+SENSOR = (
+    Path(__file__).resolve().parents[1] / "src/habit_hooks_java/sensors/pmd_sensor.py"
+)
+
+FIVE_PARAMETER_METHOD_WITH_UNUSED_IMPORT = """import java.io.File;
+class Billing {
+    double charge(double a, double b, double c, double d, double e) {
+        return a + b + c + d + e;
+    }
+}
+"""
+
+TWO_PARAMETER_METHOD = """class Project {
+    void save(String a, String b) {
+    }
+}
+"""
+
+TWO_IS_TOO_MANY_RULESET = """<?xml version="1.0"?>
+<ruleset name="custom" 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>two parameters is already too many</description>
+ <rule ref="category/java/design.xml/ExcessiveParameterList">
+  <properties><property name="minimum" value="2"/></properties>
+ </rule>
+</ruleset>
+"""
+
+
+def _run(cwd: Path, arguments: list[str]) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        [sys.executable, str(SENSOR), *arguments],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+    )
+
+
+def test_a_pmd_flag_in_args_reaches_pmd(tmp_path: Path) -> None:
+    """ExcessiveParameterList reports at priority 3 and UnnecessaryImport at
+    priority 4 (verified against PMD 7.26.0), so ``--minimum-priority 3``
+    keeps the first and drops the second — proof the flag reached PMD's own
+    filtering rather than becoming a bogus ``-d`` file argument. A threshold
+    that dropped every rule would pass as trivially as one that reached
+    nothing at all, so the assertion has to be a smell that survives, not an
+    empty result."""
+    (tmp_path / "Billing.java").write_text(FIVE_PARAMETER_METHOD_WITH_UNUSED_IMPORT)
+
+    without_the_flag = _run(tmp_path, ["--", "Billing.java"])
+    with_the_flag = _run(tmp_path, ["--minimum-priority", "3", "--", "Billing.java"])
+
+    assert without_the_flag.returncode == 0, without_the_flag.stderr
+    without_smells = {finding["smell"] for finding in json.loads(without_the_flag.stdout)}
+    assert without_smells == {"too-many-parameters", "unused-import"}
+
+    assert with_the_flag.returncode == 0, with_the_flag.stderr
+    with_smells = {finding["smell"] for finding in json.loads(with_the_flag.stdout)}
+    assert with_smells == {"too-many-parameters"}
+
+
+def test_a_ruleset_named_in_args_is_still_honoured(tmp_path: Path) -> None:
+    (tmp_path / "Project.java").write_text(TWO_PARAMETER_METHOD)
+    ruleset = tmp_path / "strict.xml"
+    ruleset.write_text(TWO_IS_TOO_MANY_RULESET)
+
+    result = _run(tmp_path, ["--rulesets", str(ruleset), "--", "Project.java"])
+
+    assert result.returncode == 0, result.stderr
+    findings = json.loads(result.stdout)
+    assert [finding["smell"] for finding in findings] == ["too-many-parameters"]

habit_hooks_java-1.3.0/tests/test_the_java_files_leave_build_output_alone.py

@@ -0,0 +1,66 @@
+"""What this plugin means when it says which files are its language's.
+
+A project that names no ``files`` of its own scans what its plugins declare, and
+``habit-hooks init`` writes exactly such a config — so what is declared here *is*
+the first run for anyone init set up. A bare ``**/*.java`` reaches into
+``target/``, where Maven puts generated sources, and ``build/``, where Gradle
+puts its own — code the project did not write and cannot change.
+"""
+
+from __future__ import annotations
+
+import tomllib
+from pathlib import Path
+
+import pathspec
+
+PACKAGE = Path(__file__).resolve().parents[1] / "src" / "habit_hooks_java"
+
+PROJECT_SOURCE = (
+    "src/main/java/com/example/Billing.java",
+    "src/test/java/com/example/BillingTest.java",
+)
+BUILD_OUTPUT = (
+    "target/generated-sources/annotations/com/example/Generated.java",
+    "build/generated/sources/annotationProcessor/java/main/com/example/Generated.java",
+)
+OTHER_LANGUAGES = (
+    "scripts/build/deploy.py",
+    "packages/app/build/config.ts",
+)
+
+
+def _declared_globs() -> list[str]:
+    config = tomllib.loads((PACKAGE / "config.toml").read_text(encoding="utf-8"))
+    return config["files"]
+
+
+def _declared_files() -> pathspec.PathSpec:
+    return pathspec.PathSpec.from_lines("gitignore", _declared_globs())
+
+
+def test_the_project_s_own_java_is_source() -> None:
+    spec = _declared_files()
+
+    assert [path for path in PROJECT_SOURCE if spec.match_file(path)] == list(
+        PROJECT_SOURCE
+    )
+
+
+def test_generated_build_output_is_not_this_project_s_source() -> None:
+    spec = _declared_files()
+
+    assert [path for path in BUILD_OUTPUT if spec.match_file(path)] == []
+
+
+def test_another_language_s_build_directory_is_left_to_its_own_plugin() -> None:
+    """A plugin's exclusions bind the union of every active plugin's globs, not
+    only its own (docs/config.md), so a directory-wide `!**/build/**` here would
+    stop a python+java project scanning its own `scripts/build/*.py`."""
+    spec = pathspec.PathSpec.from_lines(
+        "gitignore", ["**/*.py", "**/*.ts", *_declared_globs()]
+    )
+
+    assert [path for path in OTHER_LANGUAGES if spec.match_file(path)] == list(
+        OTHER_LANGUAGES
+    )