habit-hooks-java 1.3.0__tar.gz → 1.4.0rc1__tar.gz

habit_hooks_java-1.4.0rc1/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.5
+Name: habit-hooks-java
+Version: 1.4.0rc1
+Summary: The Java Habit Hooks plugin
+Project-URL: Homepage, https://habit-hooks.com
+Project-URL: Repository, https://github.com/habit-hooks/habit-hooks
+Project-URL: Issues, https://github.com/habit-hooks/habit-hooks/issues
+Project-URL: Changelog, https://github.com/habit-hooks/habit-hooks/blob/main/CHANGELOG.md
+License-Expression: MIT
+Keywords: ai-coding-agents,ci,code-quality,code-review,code-smells,coding-agents,developer-tools,java,linter,refactoring,static-analysis,technical-debt
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# habit-hooks-java
+
+The Java Habit Hooks plugin: wraps [`pmd`](https://pmd.github.io/) for
+structural code-smell detection.
+
+## Install
+
+```sh
+pip install "habit-hooks[java]"
+```
+
+## Enable
+
+```toml
+# .habit-hooks/config.toml
+plugins = ["java", "generic"]
+```
+
+Installing a plugin does not switch it on — it has to be named in
+`plugins` before habit-hooks runs it.
+
+## Detectors
+
+- [`pmd`](https://pmd.github.io/) — `brew install pmd` (it brings its own Java runtime)
+
+Part of [habit-hooks](https://github.com/habit-hooks/habit-hooks).

habit_hooks_java-1.4.0rc1/README.md

@@ -0,0 +1,26 @@
+# habit-hooks-java
+
+The Java Habit Hooks plugin: wraps [`pmd`](https://pmd.github.io/) for
+structural code-smell detection.
+
+## Install
+
+```sh
+pip install "habit-hooks[java]"
+```
+
+## Enable
+
+```toml
+# .habit-hooks/config.toml
+plugins = ["java", "generic"]
+```
+
+Installing a plugin does not switch it on — it has to be named in
+`plugins` before habit-hooks runs it.
+
+## Detectors
+
+- [`pmd`](https://pmd.github.io/) — `brew install pmd` (it brings its own Java runtime)
+
+Part of [habit-hooks](https://github.com/habit-hooks/habit-hooks).

{habit_hooks_java-1.3.0 → habit_hooks_java-1.4.0rc1}/docs/java-plugin.spec.md

@@ -211,5 +211,5 @@ 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-sensors: sensor 'pmd' failed: '${python}' '${dir}/pmd_sensor.py' '${args}' -- '${files}'
 ```

habit_hooks_java-1.4.0rc1/pyproject.toml

@@ -0,0 +1,51 @@
+[project]
+name = "habit-hooks-java"
+version = "1.4.0rc1"
+description = "The Java Habit Hooks plugin"
+readme = "README.md"
+license = "MIT"
+keywords = [
+    "code-quality",
+    "code-smells",
+    "static-analysis",
+    "linter",
+    "ci",
+    "code-review",
+    "technical-debt",
+    "refactoring",
+    "ai-coding-agents",
+    "coding-agents",
+    "developer-tools",
+    "java",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Quality Assurance",
+    "Topic :: Software Development :: Testing",
+    "Topic :: Utilities",
+]
+requires-python = ">=3.11"
+dependencies = []
+
+[project.entry-points."habit_hooks.plugins"]
+java = "habit_hooks_java"
+
+[project.urls]
+Homepage = "https://habit-hooks.com"
+Repository = "https://github.com/habit-hooks/habit-hooks"
+Issues = "https://github.com/habit-hooks/habit-hooks/issues"
+Changelog = "https://github.com/habit-hooks/habit-hooks/blob/main/CHANGELOG.md"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/habit_hooks_java"]

habit_hooks_java-1.4.0rc1/src/habit_hooks_java/sensors/pmd.toml

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

habit_hooks_java-1.4.0rc1/src/habit_hooks_java/sensors/pmd_ruleset.py

@@ -0,0 +1,50 @@
+"""Decide which ruleset PMD is run with.
+
+PMD never discovers a project ruleset on its own — ``-R`` is required — so the
+answer is chosen here: a ``--rulesets``/``-R`` 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".
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+# 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",
+)
+
+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 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

{habit_hooks_java-1.3.0 → habit_hooks_java-1.4.0rc1}/src/habit_hooks_java/sensors/pmd_sensor.py

@@ -4,21 +4,20 @@ 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.
+finding, mapping PMD rule names to smell keys. Which ruleset it runs with is
+the neighbouring ``pmd_ruleset``'s decision.
 
-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".
+The sensor is run as a loose script (``${python} ${dir}/pmd_sensor.py``), so its
+own directory is ``sys.path[0]`` and that neighbour is a plain top-level import
+— the same in the installed package and in a vendored copy, since ``${dir}``
+expands to whichever of the two won the override chain.
 
 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:]``
+The sensor's own argv 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
@@ -32,6 +31,9 @@ import subprocess
 import sys
 from pathlib import Path
 
+from pmd_ruleset import ruleset_of
+from tool_spawn import run_tool
+
 RULE_SMELLS = {
     "ExcessiveParameterList": "too-many-parameters",
     "CyclomaticComplexity": "high-complexity",
@@ -49,24 +51,7 @@ RULE_SMELLS = {
 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]:
@@ -77,13 +62,12 @@ def run_pmd(arguments: list[str]) -> subprocess.CompletedProcess[str]:
     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.
+    missing tool. Looking is ``tool_spawn``'s: PMD ships ``pmd.bat``, which
+    Windows finds by a lookup and cannot spawn by name.
     """
     command = ["pmd", "check", "--no-cache", "--format", "json"]
     try:
-        return subprocess.run(
-            [*command, *arguments], capture_output=True, text=True
-        )
+        return run_tool([*command, *arguments])
     except FileNotFoundError:
         return subprocess.CompletedProcess(command, 127, "", "pmd: command not found\n")
 
@@ -102,25 +86,6 @@ def split_argv(argv: list[str]) -> tuple[list[str], list[str]]:
     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}

habit_hooks_java-1.4.0rc1/src/habit_hooks_java/sensors/tool_spawn.py

@@ -0,0 +1,77 @@
+"""Spawn the third-party tool a sensor wraps, by the file rather than the name.
+
+A local copy of what ``habit_hooks/sensors/spawn.py`` and its ``batch_shell`` do
+for a part's own argv, and it is a copy on purpose: this plugin declares no
+dependency on ``habit-hooks``, so a helper cannot import the core, and four
+small copies beat a dependency that does not exist. The core's modules carry the
+full reasoning; the two rules are Windows' own.
+
+**A bare name is looked up first.** Windows' spawn appends ``.exe`` to a name and
+nothing else, so the ``jscpd.CMD`` npm installs and the ``pmd.bat`` PMD ships are
+found by a lookup and then unreachable by a spawn handed the name — the tool the
+setup cleared, reported missing by the run. This is not a second answer to that
+question: habit-hooks hands a helper a ``PATH`` of the project's own bins
+(``sensors/spawn._path_env``), so ``shutil.which`` here asks exactly what cleared
+the tool, along exactly the same path.
+
+**A batch file's arguments are then ``cmd.exe``'s syntax.** ``CreateProcess``
+runs a ``.bat`` or ``.cmd`` through that shell, which reads ``&``, ``|``, ``<``,
+``>``, ``^``, ``"``, ``%VAR%`` and a newline as its own (CVE-2024-24576; CPython
+closed its half in 3.11.9, and ``>=3.11`` is supported). A sensor's arguments are
+paths out of the work tree, so one is refused rather than escaped: no tool anyone
+wraps needs those characters, and refusing needs no interpreter version to be
+right.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+
+BATCH_SUFFIXES = (".bat", ".cmd")
+
+# Everything ``cmd.exe`` reads as other than text: the separators and pipe, both
+# redirections, its own escape character, the quote that ends a quoted run, the
+# ``%`` that opens a variable, and the newline that ends the line it is reading.
+CMD_SYNTAX = frozenset('&|<>^"%\n\r')
+
+# Found, and refused rather than run — the code a shell keeps for a command it
+# located and would not execute, and outside every wrapped tool's success set.
+REFUSED_EXIT = 126
+
+
+def run_tool(command: list[str]) -> subprocess.CompletedProcess[str]:
+    """What ``command`` said, spawned as the file this project runs for its name.
+
+    A name reaching no file is spawned as it stands, so the caller's own
+    ``FileNotFoundError`` remains the single answer for a tool nobody installed.
+    """
+    program = shutil.which(command[0]) or command[0]
+    unreadable = cmd_syntax(program, command[1:])
+    if unreadable is not None:
+        return subprocess.CompletedProcess(
+            command,
+            REFUSED_EXIT,
+            "",
+            f"{program}: cannot pass {unreadable!r} to a batch file — cmd.exe "
+            "would read it as its own syntax rather than as text\n",
+        )
+    return subprocess.run(
+        [program, *command[1:]],
+        capture_output=True,
+        encoding="utf-8",
+        errors="replace",  # sensors.spawn's policy
+    )
+
+
+def cmd_syntax(program: str, arguments: list[str]) -> str | None:
+    """The first of ``arguments`` ``cmd.exe`` would read as syntax, if it reads any.
+
+    ``None`` where ``program`` is not a batch file: nothing then stands between
+    the spawn and the program, and an ``&`` in a filename is a filename.
+    """
+    if not program.lower().endswith(BATCH_SUFFIXES):
+        return None
+    return next(
+        (argument for argument in arguments if CMD_SYNTAX & set(argument)), None
+    )

habit_hooks_java-1.4.0rc1/tests/conftest.py

@@ -0,0 +1,17 @@
+"""Load the pmd sensor the way it is actually run — as a loose script.
+
+The sensor spec spells ``${python} ${dir}/pmd_sensor.py``, so the interpreter
+puts the helper's own directory first on ``sys.path`` and its neighbour
+``pmd_ruleset`` is a plain top-level import. A unit test here does the same
+rather than reaching the code as ``habit_hooks_java.sensors.pmd_sensor`` — a
+load path no run takes, and the only one that import fails under.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+SENSORS = Path(__file__).resolve().parents[1] / "src" / "habit_hooks_java" / "sensors"
+
+sys.path.insert(0, str(SENSORS))

{habit_hooks_java-1.3.0 → habit_hooks_java-1.4.0rc1}/tests/test_a_java_pmd_nobody_installed_is_named.py

@@ -20,13 +20,14 @@ SENSOR = (
 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")
+    (tmp_path / "App.java").write_text("class App {}\n", encoding="utf-8")
 
     result = subprocess.run(
         [sys.executable, str(SENSOR), "App.java"],
         cwd=tmp_path,
         capture_output=True,
-        text=True,
+        encoding="utf-8",
+        errors="replace",
         env={"PATH": "/nonexistent"},
     )
 

habit_hooks_java-1.4.0rc1/tests/test_a_vendored_sensor_finds_its_neighbour.py

@@ -0,0 +1,58 @@
+"""The route that copies the plugin's files into a project must still import.
+
+Vendoring under ``.habit-hooks/<plugin>/`` is the extras-free install the README
+advertises: the copied files win the override chain, ``${dir}`` in the sensor
+command expands to wherever they landed, and the plugin package is typically not
+installed at all — that is the point of vendoring. The sensor imports
+``pmd_ruleset`` from beside itself, which has to resolve because a loose
+script's own directory is ``sys.path[0]``, never because ``habit_hooks_java``
+happens to be importable.
+
+``-S`` is what tells those two apart: it denies the child the site-packages this
+checkout has the plugin installed into, so an import reaching for the package
+fails here exactly as it would for a project that vendored instead of
+installing. Without it the copy would pass on the installed package's modules
+and prove nothing about the files it just copied.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+SENSORS = Path(__file__).resolve().parents[1] / "src" / "habit_hooks_java" / "sensors"
+
+FIVE_PARAMETER_METHOD = """class Billing {
+    double charge(double a, double b, double c, double d, double e) {
+        return a + b + c + d + e;
+    }
+}
+"""
+
+
+def _vendored_sensor(project: Path) -> Path:
+    """The plugin's sensor files copied where a project vendoring them puts them."""
+    sensors = project / ".habit-hooks" / "java" / "sensors"
+    shutil.copytree(SENSORS, sensors, ignore=shutil.ignore_patterns("__pycache__"))
+    return sensors / "pmd_sensor.py"
+
+
+def test_a_vendored_sensor_reports_a_smell_with_no_package_around_it(
+    tmp_path: Path,
+) -> None:
+    (tmp_path / "Billing.java").write_text(FIVE_PARAMETER_METHOD, encoding="utf-8")
+
+    result = subprocess.run(
+        [sys.executable, "-S", str(_vendored_sensor(tmp_path)), "--", "Billing.java"],
+        cwd=tmp_path,
+        capture_output=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+
+    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 → habit_hooks_java-1.4.0rc1}/tests/test_class_level_metric_violations_are_dropped.py

@@ -14,7 +14,7 @@ over-complex function anywhere in the file.
 
 from __future__ import annotations
 
-from habit_hooks_java.sensors.pmd_sensor import findings, smell_of
+from pmd_sensor import findings, smell_of
 
 
 def _entry(rule: str, description: str, beginline: int = 1) -> dict:

{habit_hooks_java-1.3.0 → habit_hooks_java-1.4.0rc1}/tests/test_every_ruleset_spelling_wins.py

@@ -15,7 +15,7 @@ from __future__ import annotations
 from pathlib import Path
 
 import pytest
-from habit_hooks_java.sensors.pmd_sensor import ruleset_of
+from pmd_ruleset import ruleset_of
 
 BUNDLED = "pmd-ruleset.xml"
 THEIRS = "mine.xml"
@@ -59,7 +59,7 @@ def test_a_project_naming_none_gets_the_bundled_ruleset(tmp_path: Path) -> None:
 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/>")
+    theirs.write_text("<ruleset/>", encoding="utf-8")
 
     assert ruleset_of([], tmp_path) == (theirs, [])
 

{habit_hooks_java-1.3.0 → habit_hooks_java-1.4.0rc1}/tests/test_sensor_args_reach_pmd_not_the_file_list.py

@@ -52,7 +52,8 @@ def _run(cwd: Path, arguments: list[str]) -> subprocess.CompletedProcess[str]:
         [sys.executable, str(SENSOR), *arguments],
         cwd=cwd,
         capture_output=True,
-        text=True,
+        encoding="utf-8",
+        errors="replace",
     )
 
 
@@ -64,7 +65,7 @@ def test_a_pmd_flag_in_args_reaches_pmd(tmp_path: Path) -> None:
     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)
+    (tmp_path / "Billing.java").write_text(FIVE_PARAMETER_METHOD_WITH_UNUSED_IMPORT, encoding="utf-8")
 
     without_the_flag = _run(tmp_path, ["--", "Billing.java"])
     with_the_flag = _run(tmp_path, ["--minimum-priority", "3", "--", "Billing.java"])
@@ -79,9 +80,9 @@ def test_a_pmd_flag_in_args_reaches_pmd(tmp_path: Path) -> None:
 
 
 def test_a_ruleset_named_in_args_is_still_honoured(tmp_path: Path) -> None:
-    (tmp_path / "Project.java").write_text(TWO_PARAMETER_METHOD)
+    (tmp_path / "Project.java").write_text(TWO_PARAMETER_METHOD, encoding="utf-8")
     ruleset = tmp_path / "strict.xml"
-    ruleset.write_text(TWO_IS_TOO_MANY_RULESET)
+    ruleset.write_text(TWO_IS_TOO_MANY_RULESET, encoding="utf-8")
 
     result = _run(tmp_path, ["--rulesets", str(ruleset), "--", "Project.java"])
 

habit_hooks_java-1.3.0/PKG-INFO

@@ -1,5 +0,0 @@
-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/pyproject.toml

@@ -1,16 +0,0 @@
-[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/sensors/pmd.toml

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