lint-roller 0.1.0__tar.gz

lint_roller-0.1.0/LICENSE

@@ -0,0 +1,17 @@
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lint_roller-0.1.0/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: lint-roller
+Version: 0.1.0
+Summary: Check changes in a code repository for linting violations to iteratively improve them.
+License-Expression: MIT
+Requires-Python: >=3.14
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: attrs
+Requires-Dist: click
+Requires-Dist: colorama; platform_system == "Windows"
+Requires-Dist: match_diff_lines>=0.3.0
+Requires-Dist: structlog
+Requires-Dist: wcmatch
+Provides-Extra: tracebacks
+Requires-Dist: rich; extra == "tracebacks"
+Dynamic: license-file
+
+===========
+lint-roller
+===========
+
+
+Changelog
+=========
+
+0.1.0 - 2026-03-31
+------------------
+
+* Initial release.
+  [fschulze]

lint_roller-0.1.0/README.rst

@@ -0,0 +1,13 @@
+===========
+lint-roller
+===========
+
+
+Changelog
+=========
+
+0.1.0 - 2026-03-31
+------------------
+
+* Initial release.
+  [fschulze]

lint_roller-0.1.0/pyproject.toml

@@ -0,0 +1,194 @@
+[project]
+name = "lint-roller"
+version = "0.1.0"
+description = "Check changes in a code repository for linting violations to iteratively improve them."
+readme = "README.rst"
+requires-python = ">=3.14"
+license = "MIT"
+license-files = ["LICENSE"]
+dependencies = [
+    "attrs",
+    "click",
+    "colorama;platform_system=='Windows'",
+    "match_diff_lines>=0.3.0",
+    "structlog",
+    "wcmatch",
+]
+
+[project.scripts]
+lint-roller = "lint_roller.cli:cli"
+
+[project.optional-dependencies]
+tracebacks = ["rich"]
+
+[dependency-groups]
+dev = [
+    "PdbEditorSupport",
+    "rich",
+    { include-group = "coverage" },
+    { include-group = "flake8" },
+    { include-group = "mypy" },
+    { include-group = "pytest" },
+    { include-group = "tombi" },
+    { include-group = "tox" },
+]
+coverage = [
+    "coverage",
+]
+flake8 = [
+    "flake8",
+]
+mypy = [
+    "mypy",
+    { include-group = "pytest" },
+]
+pytest = [
+    "pytest",
+    "pytest-asyncio",
+    "tomli-w",
+]
+ruff = [
+    "ruff",
+]
+tombi = [
+    "tombi",
+]
+tox = [
+    "tox",
+    "tox-uv",
+]
+
+[build-system]
+requires = ["setuptools"]
+
+[tool.coverage.run]
+branch = true
+parallel = true
+relative_files = true
+source_pkgs = ["lint_roller"]
+source = [
+    "src/lint_roller/tests",
+]
+
+[tool.lint-roller]
+start-rev = "main"
+
+[tool.pytest]
+addopts = [
+    "-W error::DeprecationWarning",
+    "-W once::ResourceWarning",
+    "-r a",
+]
+asyncio_mode = "auto"
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "COM812",  # missing-trailing-comma - disabled for ruff format
+    "D1",  # undocumented-*
+    "D203",  # incorrect-blank-line-before-class
+    "D213",  # multi-line-summary-second-line
+    "E501",  # line-too-long
+    "PLR2004",  # magic-value-comparison
+    "SLF001",  # private-member-access
+    "TID252",  # flake8-tidy-imports.ban-relative-imports
+]
+
+[tool.ruff.lint.per-file-ignores]
+"src/lint_roller/tests/*.py" = [
+    "INP001",  # implicit-namespace-package
+    "PLC0415",  # import-outside-top-level
+    "PLR0913",  # too-many-arguments
+    "PLR0915",  # too-many-statements
+    "S101",  # assert
+]
+
+[tool.ruff.lint.isort]
+case-sensitive = true
+force-single-line = true
+from-first = true
+lines-after-imports = 2
+no-sections = true
+order-by-type = false
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.tombi.format.rules]
+indent-width = 4
+
+[tool.tombi.lint.rules]
+key-empty = "off"
+
+[tool.tox]
+env_list = [
+    "clean",
+    "coverage_combine",
+    "coverage_report",
+    "flake8",
+    "format",
+    "mypy",
+    { product = [{ prefix = "py3", start = 14 }] },
+    "ruff",
+    "tombi-check",
+    "tombi-format",
+]
+
+[tool.tox.env_run_base]
+base_python = ["python3.14"]
+dependency_groups = ["coverage", "pytest"]
+commands = [["coverage", "run", "-m", "pytest"]]
+depends = ["clean"]
+
+[tool.tox.env.clean]
+dependency_groups = ["coverage"]
+commands = [["coverage", "erase"]]
+skip_install = true
+
+[tool.tox.env.coverage_combine]
+dependency_groups = ["coverage"]
+commands = [["coverage", "combine"]]
+depends = ["py3*"]
+skip_install = true
+
+[tool.tox.env.coverage_report]
+dependency_groups = ["coverage"]
+commands = [
+    ["coverage", "html"],
+    ["coverage", "report", "--fail-under=100"],
+]
+depends = ["coverage_combine"]
+parallel_show_output = true
+skip_install = true
+
+[tool.tox.env.flake8]
+dependency_groups = ["flake8"]
+commands = [["flake8"]]
+skip_install = true
+
+[tool.tox.env.format]
+dependency_groups = ["ruff"]
+commands = [["ruff", "format", "--check"]]
+skip_install = true
+
+[tool.tox.env.mypy]
+dependency_groups = ["mypy"]
+commands = [["mypy"]]
+
+[tool.tox.env.ruff]
+dependency_groups = ["ruff"]
+commands = [["ruff", "check"]]
+skip_install = true
+
+[tool.tox.env.tombi-check]
+dependency_groups = ["tombi"]
+commands = [["tombi", "check", "--error-on-warnings", "--quiet"]]
+skip_install = true
+
+[tool.tox.env.tombi-format]
+dependency_groups = ["tombi"]
+commands = [["tombi", "format", "--check", "--diff", "--quiet"]]
+skip_install = true

lint_roller-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

lint_roller-0.1.0/src/lint_roller/cli.py

@@ -0,0 +1,334 @@
+from __future__ import annotations
+
+from .lint import BaseOutput
+from .lint import LintResults
+from .lint import LintResultsCoroutine
+from .workspace import Workspace
+from abc import abstractmethod
+from attrs import define
+from functools import cached_property
+from functools import wraps
+from pathlib import Path
+from subprocess import CalledProcessError
+from traceback import format_exception_only
+from typing import TYPE_CHECKING
+import asyncio
+import click
+import logging
+import structlog
+import sys
+
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable
+    from collections.abc import Callable
+    from collections.abc import Iterator
+    from typing import Any
+
+
+log = structlog.stdlib.get_logger()
+
+
+def checkers_options[**P, R](f: Callable[P, R]) -> Callable[P, R]:
+    @click.option(
+        "--default-checks/--no-default-checks",
+        "run_default_checks",
+        default=None,
+        help="Run/omit default checks.",
+    )
+    @click.option(
+        "--flake8/--no-flake8",
+        "run_flake8",
+        default=None,
+        help="Run/omit flake8 checks.",
+    )
+    @click.option(
+        "--ruff-check/--no-ruff-check",
+        "run_ruff_check",
+        default=None,
+        help="Run/omit ruff check checks.",
+    )
+    @click.option(
+        "--ruff-format/--no-ruff-format",
+        "run_ruff_format",
+        default=None,
+        help="Run/omit ruff format checks.",
+    )
+    @wraps(f)
+    def wrapper_checkers_options(*args: P.args, **kwargs: P.kwargs) -> R:
+        return f(*args, **kwargs)
+
+    return wrapper_checkers_options
+
+
+def common_output_options[**P, R](f: Callable[P, R]) -> Callable[P, R]:
+    @click.option(
+        "--show-full-diff/--hide-full-diff",
+        default=False,
+        show_default=True,
+        help="Show the full diff",
+    )
+    @click.option(
+        "--show-full-diff-ranges/--hide-full-diff-ranges",
+        default=False,
+        show_default=True,
+        help="Show line ranges of diff",
+    )
+    @click.option(
+        "--show-start-rev/--hide-start-rev",
+        default=True,
+        show_default=True,
+        help="Show determined start rev",
+    )
+    @click.option(
+        "--show-tool-versions/--hide-tool-versions",
+        default=False,
+        show_default=True,
+        help="Show versions of used tools",
+    )
+    @click.option("-v", "--verbose", count=True, help="Enables verbose mode")
+    @wraps(f)
+    def wrapper_common_output_options(*args: P.args, **kwargs: P.kwargs) -> R:
+        return f(*args, **kwargs)
+
+    return wrapper_common_output_options
+
+
+def start_rev_option[**P, R](f: Callable[P, R]) -> Callable[P, R]:
+    @click.option(
+        "--start-rev",
+        metavar="REV",
+        help="The commit or symbolic name to check against.  [default: main]",
+    )
+    @wraps(f)
+    def wrapper_start_rev_option(*args: P.args, **kwargs: P.kwargs) -> R:
+        return f(*args, **kwargs)
+
+    return wrapper_start_rev_option
+
+
+@click.group()
+def cli() -> None: ...
+
+
+@define(kw_only=True)
+class Output(BaseOutput):
+    cli_show_full_diff: bool
+    cli_show_full_diff_ranges: bool
+    cli_show_start_rev: bool
+    cli_show_tool_versions: bool
+    verbose: int
+
+    def _iter_exceptions(self, e: BaseException) -> Iterator[BaseException]:
+        if isinstance(e, (BaseExceptionGroup, ExceptionGroup)):
+            for se in e.exceptions:
+                yield from self._iter_exceptions(se)
+        else:
+            yield e
+
+    def _log_exception(self, msg: str, e: BaseException) -> None:
+        if self.log_for(logging.INFO):
+            log.exception("%s:", msg, exc_info=e)
+        else:
+            log.error(
+                "%s (use -v for more details): %s",
+                msg,
+                "".join(format_exception_only(e)).rstrip(),
+            )
+        if isinstance(e, CalledProcessError):
+            if e.stdout:  # pragma: no cover
+                click.echo(e.stdout)
+            if e.stderr:  # pragma: no cover
+                click.echo(e.stderr)
+
+    def log_exception(self, e: BaseException) -> None:
+        for se in self._iter_exceptions(e):
+            msg = (
+                "A sub-process call failed"
+                if isinstance(se, CalledProcessError)
+                else "Exception"
+            )
+            self._log_exception(msg, se)
+
+    def log_for(self, level: int) -> bool:
+        return self.log_level <= level
+
+    @cached_property
+    def log_level(self) -> int:
+        if not self.verbose:
+            return logging.WARNING
+        if self.verbose > 1:
+            return logging.DEBUG
+        return logging.INFO
+
+    def log_start_rev(self, workspace: Workspace) -> None:
+        if self.show_start_rev():
+            click.echo(
+                f"Checking commits from {workspace.commit_hash} ({workspace.commit_names}) in {Path().absolute()}"
+            )
+
+    def log_versions(self, workspace: Workspace) -> None:
+        if self.show_tool_versions():
+            click.echo(f"git {workspace.git.version}")
+
+    async def log_full_python_diff(self, workspace: Workspace) -> None:
+        if self.show_full_diff():
+            click.echo((await workspace.full_python_diff_task).colored())
+        elif self.show_full_diff_ranges():
+            click.echo((await workspace.full_python_diff_task).format_ranges())
+
+    def show_fixes_for(self, _kind: str, /) -> bool:
+        return True
+
+    @property
+    def show_format_trigger_lines(self) -> bool:
+        return bool(self.verbose)
+
+    def show_full_diff(self) -> bool:
+        return self.cli_show_full_diff or self.log_for(logging.DEBUG)
+
+    def show_full_diff_ranges(self) -> bool:
+        return self.cli_show_full_diff_ranges or self.log_for(logging.INFO)
+
+    def show_start_rev(self) -> bool:
+        return self.cli_show_start_rev or self.log_for(logging.INFO)
+
+    def show_tool_versions(self) -> bool:
+        return self.cli_show_tool_versions or self.log_for(logging.INFO)
+
+
+@define(kw_only=True)
+class BaseCommand[C: Awaitable[Any], R]:
+    output: Output
+    flake8: bool
+    ruff_check: bool
+    ruff_format: bool
+    workspace: Workspace
+
+    @abstractmethod
+    def finish(self) -> None: ...
+
+    @abstractmethod
+    def get_tasks(self) -> list[C]: ...
+
+    @abstractmethod
+    def process_results(self, results: R) -> None: ...
+
+    async def run_tasks(self, tasks: list[C]) -> bool:
+        exceptions = []
+        task_failed = False
+        output = self.output
+        for task in tasks:
+            try:
+                results = await task
+            except CalledProcessError as e:
+                output._log_exception("Task failed", e)
+                task_failed = True
+            except BaseException as e:  # noqa: BLE001
+                exceptions.append(e)
+            else:
+                self.process_results(results)
+        if exceptions:
+            msg = "Unhandled exceptions in run_tasks"
+            raise BaseExceptionGroup(msg, exceptions)
+        return task_failed
+
+    async def run(self) -> None:
+        workspace = self.workspace
+        output = self.output
+        await output.log_full_python_diff(workspace)
+        tasks = self.get_tasks()
+        if not tasks:
+            log.error("No tasks selected.")
+            sys.exit(5)
+        task_failed = await self.run_tasks(tasks)
+        if task_failed:
+            sys.exit(6)
+        self.finish()
+
+
+def run_linter(*, linter: bool | None, default: bool | None) -> bool:
+    if (default or default is None) and linter is None:
+        return True
+    return bool(linter)
+
+
+class CheckCommand(BaseCommand[LintResultsCoroutine, LintResults]):
+    failed = False
+
+    def finish(self) -> None:
+        if self.failed:
+            sys.exit(4)
+
+    def get_tasks(self) -> list[LintResultsCoroutine]:
+        tasks: list[LintResultsCoroutine] = []
+        if self.ruff_format:
+            tasks.extend(self.workspace.ruff_format.check_tasks())
+        if self.ruff_check:
+            tasks.extend(self.workspace.ruff_check.check_tasks())
+        if self.flake8:
+            tasks.extend(self.workspace.flake8.check_tasks())
+        return tasks
+
+    def process_results(self, results: LintResults) -> None:
+        self.failed = self.failed or results.failed
+        for result in results:
+            click.echo(result.format(self.output))
+
+
+@cli.command()
+@click.argument("rev", envvar="LINT_ROLLER_START_REV", required=False)
+@checkers_options
+@common_output_options
+@start_rev_option
+def check(  # noqa: PLR0913
+    *,
+    rev: str | None,
+    show_full_diff: bool,
+    show_full_diff_ranges: bool,
+    show_start_rev: bool,
+    show_tool_versions: bool,
+    start_rev: str | None,
+    verbose: int,
+    run_default_checks: bool | None,
+    run_ruff_check: bool | None,
+    run_flake8: bool | None,
+    run_ruff_format: bool | None,
+) -> None:
+    """Check for any violations.
+
+    The optional REV argument is the commit hash or symbolic name from which the git diff is taken.
+    """
+    output = Output(
+        cli_show_full_diff=show_full_diff,
+        cli_show_full_diff_ranges=show_full_diff_ranges,
+        cli_show_start_rev=show_start_rev,
+        cli_show_tool_versions=show_tool_versions,
+        verbose=verbose,
+    )
+    workspace = Workspace(cli_rev=rev, cli_start_rev=start_rev)
+    structlog.configure(
+        wrapper_class=structlog.make_filtering_bound_logger(output.log_level),
+    )
+    try:
+        output.log_versions(workspace)
+        output.log_start_rev(workspace)
+        asyncio.run(
+            CheckCommand(
+                flake8=run_linter(linter=run_flake8, default=run_default_checks),
+                output=output,
+                ruff_check=run_linter(
+                    linter=run_ruff_check, default=run_default_checks
+                ),
+                ruff_format=run_linter(
+                    linter=run_ruff_format, default=run_default_checks
+                ),
+                workspace=workspace,
+            ).run()
+        )
+    except (CalledProcessError, ExceptionGroup) as e:
+        (se, *_oe) = output._iter_exceptions(e)
+        output.log_exception(se)
+        if isinstance(se, CalledProcessError):
+            sys.exit(3)
+        raise se from e

lint_roller-0.1.0/src/lint_roller/diff.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from attrs import define
+from click import style
+from click import unstyle
+from functools import cached_property
+from match_diff_lines import parse_unified_diff as _parse_unified_diff
+from typing import TYPE_CHECKING
+import itertools
+
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from collections.abc import Iterator
+    from pathlib import Path
+
+
+@define(frozen=True)
+class LineRange:
+    start: int
+    stop: int
+
+    def __iter__(self) -> Iterator[int]:
+        yield self.start
+        yield self.stop
+
+
+def ranges(numbers: Iterable[int]) -> Iterator[LineRange]:
+    for _a, _b in itertools.groupby(
+        enumerate(sorted(numbers)), lambda pair: pair[1] - pair[0]
+    ):
+        b = list(_b)
+        yield LineRange(b[0][1], b[-1][1])
+
+
+@define
+class Diff:
+    base: Path
+    raw: str
+
+    def __str__(self) -> str:
+        return self.raw
+
+    def colored(self) -> str:
+        return "\n".join(
+            style(
+                line,
+                fg="green"
+                if line.startswith("+")
+                else "red"
+                if line.startswith("-")
+                else None,
+            )
+            for line in self.raw.splitlines()
+        )
+
+    def format_ranges(self) -> str:
+        base = self.base
+        result = []
+        for fn, _ranges in sorted(self.ranges.items()):
+            ranges = ", ".join(f"{s}" if s == e else f"{s}-{e}" for s, e in _ranges)
+            result.append(f"{style(fn.relative_to(base), bold=True)}: {ranges}")
+        return "\n".join(result)
+
+    @cached_property
+    def path_lines_map(self) -> dict[Path, frozenset[int]]:
+        parsed_diff = parse_unified_diff(self.raw.splitlines())
+        return {self.base / fn: line_nums for fn, line_nums in parsed_diff.items()}
+
+    @cached_property
+    def ranges(self) -> dict[Path, list[LineRange]]:
+        return {
+            fn: list(ranges(lines_nums))
+            for fn, lines_nums in self.path_lines_map.items()
+            if lines_nums
+        }
+
+
+def parse_unified_diff(lines: Iterable[str]) -> dict[str, frozenset[int]]:
+    return {
+        k: frozenset(v)
+        for k, v in _parse_unified_diff(unstyle(line) for line in lines).items()
+    }