py-wlcli 0.8.0__py3-none-any.whl

wl_cli/commands/lint/lint_command.py

@@ -0,0 +1,297 @@
+"""Lint command implementation using Click decorators."""
+
+import sys
+from pathlib import Path
+
+import click
+
+from ...utils.logging import log_info_pair
+from ...utils.root import RootKind
+from ...utils.root_fallback import current_root
+from ..format import FormatCommand
+from .lint_executor import LintExecutor
+from .lint_reporter import LintReporter
+from .lint_run import LintRun
+
+
+def _anchor_scope_path(project_root: Path, token: str) -> str:
+    """Anchor one ``wl lint`` scope *token* on the directory it means (#188).
+
+    The format prefix runs from the project root, so a bare ``src`` must mean
+    ``root/src`` no matter where the CLI was started. Three cases, in order:
+
+    * an absolute token is already unambiguous;
+    * a token real under *project_root* becomes ``root/token``;
+    * a token real only against the cwd -- ``cd pkg && wl lint commands`` --
+      becomes its resolved absolute path, the #179 floor;
+    * anything else is returned untouched, so ruff and mypy report it instead
+      of lint silently checking less than asked (the #188 drop bug).
+    """
+    candidate = Path(token)
+    if candidate.is_absolute():
+        return token
+    rooted = project_root / token
+    try:
+        if rooted.exists():
+            return str(rooted)
+        if candidate.exists():
+            return str(candidate.resolve())
+    except OSError:
+        # An unreadable path must not crash command construction; ruff reports
+        # it once it receives the token.
+        pass
+    return token
+
+
+class LintFormatter:
+    """Formatter for code before linting."""
+
+    def format_code(
+        self, project_root: Path, paths: list[str] | None, quiet: bool
+    ) -> int:
+        """Format code before linting; returns the format prefix's exit code.
+
+        ``for_lint`` makes the prefix format only (#180): the coordinator skips
+        its pre-commit run, so ``wl lint`` owns that verdict, while a real
+        ``ruff``/``tool_missing`` failure still comes back non-zero (#166).
+        A ``ruff check`` that leaves unfixable violations is *not* such a
+        failure (#188): the coordinator maps it to ``0`` so lint reaches its
+        own ruff run, mypy, pre-commit and the report.
+
+        ``project_root`` is passed down (#188), so the scope means the same
+        directory wherever the CLI was started from. Each token is anchored
+        before it leaves: absolute as typed, else under *project_root* when it
+        exists there, else resolved against the cwd (``cd pkg && wl lint
+        commands``, the #179 floor), else left untouched for ruff to report.
+        No token is dropped -- silently linting less than asked was the bug.
+        """
+        if not quiet:
+            log_info_pair(
+                "Formatting code before linting...", "在静态检查前先格式化代码..."
+            )
+
+        format_cmd = FormatCommand()
+        valid_paths: list[str] | None = None
+        if paths:
+            valid_paths = [_anchor_scope_path(project_root, p) for p in paths]
+        return format_cmd.run(
+            quiet=quiet,
+            unsafe=True,
+            paths=valid_paths,
+            for_lint=True,
+            project_root=project_root,
+        )
+
+
+class LintCommand:
+    """Implementation of the lint command.
+
+    :meth:`execute` returns the process exit code instead of calling
+    ``sys.exit`` itself -- the same contract as ``GateCommand.execute``. Only
+    the Click wrapper below turns a non-zero code into a ``SystemExit``, so the
+    command stays callable, and testable, as a plain function.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the lint command implementation.
+
+        The ``-> None`` is load-bearing for typing, not decoration: without an
+        annotation mypy skips this body, the three collaborators stay ``Any``,
+        and :meth:`execute` would be returning an unchecked value from inside a
+        ``-> int`` signature.
+        """
+        self.executor = LintExecutor()
+        self.formatter = LintFormatter()
+        self.reporter = LintReporter()
+
+    def execute(
+        self,
+        paths: tuple[str, ...] = (),
+        quiet: bool = False,
+        fix: bool = False,
+        noreport: bool = False,
+        report: bool = False,
+    ) -> int:
+        """
+        Lint code - equivalent to make lint
+        代码静态检查 - 等效于 make lint
+
+        Returns the exit code: the format prefix's, ruff's, or 1 when a tool
+        that was asked to run produced no verdict (ruff missing or signalled;
+        with the report, a mypy that could not start, was signalled, exited
+        with code ``>= 2``, or exited non-zero with no diagnostics too). mypy
+        *type errors* do not change the exit code, and an unexpected exception
+        anywhere returns 1 (fail-closed).
+        """
+        if not quiet:
+            self._log_info("Linting code...", "正在进行代码静态检查...")
+
+        try:
+            # Single-root consumer (#160): the one fallback policy, taken as a
+            # bare Path because that is this command's contract.
+            project_root = current_root(RootKind.PROJECT).path
+
+            format_exit_code = self.formatter.format_code(
+                project_root, list(paths) if paths else None, quiet
+            )
+            if format_exit_code:
+                # Exit contract: any non-zero prefix aborts lint, and the only
+                # degradation is ``pre_commit``-only -- the coordinator's
+                # ``for_lint`` mapping already reduced that verdict to 0. A
+                # non-zero code therefore means ruff/tool_missing and lint
+                # stops before running ruff again (#166). The catch-all below
+                # is fail-closed the same way: an unexpected exception returns
+                # 1 instead of running the remaining tools with a partial
+                # prefix verdict (#172).
+                return format_exit_code
+
+            # Audit patch 3: the caller picks the tool set. ``--noreport`` runs
+            # ruff alone -- no mypy, no pre-commit, no structured output;
+            # ``--report`` and the default path also need mypy and pre-commit
+            # for the report, plus ruff's structured output to group its
+            # findings into the report's per-directory sections. The format
+            # prefix above only formats (#180): it never runs pre-commit, so
+            # this tool set is the single owner of that hook run -- exactly
+            # once by default and with ``--report``, never with ``--noreport``.
+            with_report = report or not noreport
+            run = self.executor.run_all(
+                project_root,
+                list(paths) if paths else None,
+                quiet=quiet,
+                fix=fix,
+                with_mypy=with_report,
+                with_pre_commit=with_report,
+                structured_ruff=with_report,
+                format_code=format_exit_code,
+            )
+
+            if with_report:
+                self.reporter.render(run)
+
+            self._handle_result(run, quiet)
+
+            return run.exit_code
+
+        except FileNotFoundError:
+            self._handle_file_not_found_error(quiet)
+            return 1
+        except Exception as e:
+            self._handle_general_error(e, quiet)
+            return 1
+
+    def _log_info(self, en_msg: str, zh_msg: str) -> None:
+        """Log info message in both English and Chinese."""
+        log_info_pair(
+            en_msg,
+            zh_msg,
+        )
+
+    def _handle_result(self, run: LintRun, quiet: bool) -> None:
+        """Show what failed -- ruff's findings, mypy, hooks -- or clean.
+
+        A non-zero code caused by a mypy launch failure or signal must not
+        announce ruff issues: there is no ruff output to show, so the old
+        branch printed the heading and nothing else (#172). When ruff *does*
+        have findings, they stay the headline, but a mypy non-verdict is
+        still printed under them (review n3).
+
+        A failing pre-commit hook is printed as its own verdict (#188). It is
+        part of :attr:`LintRun.exit_code` now, and the terminal used to print
+        "completed successfully!" for exactly the run the report rendered as
+        ``Failed``; that success line is now reachable only from ``exit_code
+        == 0``, i.e. never on a hook failure.
+        """
+        if run.exit_code != 0 and not quiet:
+            if run.issues_found:
+                self._log_info(
+                    "Linting completed with issues:", "代码静态检查发现以下问题:"
+                )
+                # ``issue_text`` hands back ruff's ``--output-format full``
+                # text verbatim; the reporter owns the rendering (#170).
+                issues = self.reporter.issue_text(run)
+                if issues:
+                    print(issues)
+                if run.ruff.stderr:
+                    print(run.ruff.stderr)
+            # The report is the source of truth, but a mypy that never
+            # produced a verdict should not vanish from the terminal just
+            # because ruff also had findings (review n3).
+            if run.mypy_failure is not None:
+                print(run.mypy_failure)
+            if run.pre_commit is not None and run.pre_commit.hooks_failed:
+                self._log_info("Pre-commit hooks failed:", "pre-commit 钩子检查未通过:")
+                self._print_pre_commit_verdict(run)
+        elif run.exit_code == 0 and not quiet:
+            self._log_info(
+                "Code linting completed successfully!", "代码静态检查成功完成！"
+            )
+
+    def _print_pre_commit_verdict(self, run: LintRun) -> None:
+        """Print the blocks the hook verdict was computed from (#188).
+
+        ``failed_blocks`` is the same source :attr:`PreCommitRun.hooks_failed`
+        reads, so the terminal cannot show an auto-fix block the verdict
+        ignored. A run that failed before printing any hook block falls back to
+        its raw output, the same shape ``wl format`` uses.
+        """
+        pre_commit = run.pre_commit
+        if pre_commit is None:  # pragma: no cover - caller guards on it
+            return
+        blocks = pre_commit.failed_blocks
+        if blocks:
+            print("\n\n".join("\n".join(block) for block in blocks))
+        elif pre_commit.combined_output.strip():
+            print(pre_commit.combined_output.strip())
+
+    def _handle_file_not_found_error(self, quiet: bool) -> None:
+        """Handle FileNotFoundError."""
+        if not quiet:
+            self._log_info(
+                "Error: ruff is not installed or not found in PATH",
+                "错误：未安装 ruff 或在 PATH 中找不到",
+            )
+
+    def _handle_general_error(self, e: Exception, quiet: bool) -> None:
+        """Handle general exceptions."""
+        if not quiet:
+            self._log_info(f"Error during linting: {e}", f"错误：静态检查期间出错: {e}")
+
+
+@click.command()
+@click.argument("paths", nargs=-1)
+@click.option("-q", "--quiet", is_flag=True, help="Suppress detailed output")
+@click.option("--fix", is_flag=True, help="Automatically fix lint errors")
+@click.option(
+    "--noreport",
+    is_flag=True,
+    help="Do not generate lint report in todos folder",
+)
+@click.option(
+    "--report",
+    is_flag=True,
+    help="Generate lint report in todos folder",
+)
+@click.option(
+    "--pre-commit-config",
+    type=str,
+    help="Pre-commit configuration file (for compatibility)",
+)
+def lint_command(
+    paths: tuple[str, ...],
+    quiet: bool,
+    fix: bool,
+    noreport: bool,
+    report: bool,
+    pre_commit_config: str | None = None,
+) -> None:
+    """Lint command Click wrapper."""
+    # The command body returns an exit code; turning a non-zero one into the
+    # process's own exit status is this wrapper's job alone (the ``wl gate``
+    # shape). Zero returns normally, so Click exits 0. Kept as comments, not
+    # docstring: Click renders the docstring into ``wl lint --help`` (#142).
+    cmd = LintCommand()
+    exit_code = cmd.execute(
+        paths=paths, quiet=quiet, fix=fix, noreport=noreport, report=report
+    )
+    if exit_code != 0:
+        sys.exit(exit_code)