lintro 0.6.2__py3-none-any.whl → 0.17.2__py3-none-any.whl

lintro/utils/tool_utils.py

@@ -27,14 +27,26 @@ from lintro.formatters.tools.darglint_formatter import (
     DarglintTableDescriptor,
     format_darglint_issues,
 )
+from lintro.formatters.tools.eslint_formatter import (
+    EslintTableDescriptor,
+    format_eslint_issues,
+)
 from lintro.formatters.tools.hadolint_formatter import (
     HadolintTableDescriptor,
     format_hadolint_issues,
 )
+from lintro.formatters.tools.markdownlint_formatter import (
+    MarkdownlintTableDescriptor,
+    format_markdownlint_issues,
+)
 from lintro.formatters.tools.prettier_formatter import (
     PrettierTableDescriptor,
     format_prettier_issues,
 )
+from lintro.formatters.tools.pytest_formatter import (
+    PytestFailuresTableDescriptor,
+    format_pytest_issues,
+)
 from lintro.formatters.tools.ruff_formatter import (
     RuffTableDescriptor,
     format_ruff_issues,
@@ -47,9 +59,13 @@ from lintro.parsers.bandit.bandit_parser import parse_bandit_output
 from lintro.parsers.black.black_issue import BlackIssue
 from lintro.parsers.black.black_parser import parse_black_output
 from lintro.parsers.darglint.darglint_parser import parse_darglint_output
+from lintro.parsers.eslint.eslint_issue import EslintIssue
+from lintro.parsers.eslint.eslint_parser import parse_eslint_output
 from lintro.parsers.hadolint.hadolint_parser import parse_hadolint_output
+from lintro.parsers.markdownlint.markdownlint_parser import parse_markdownlint_output
 from lintro.parsers.prettier.prettier_issue import PrettierIssue
 from lintro.parsers.prettier.prettier_parser import parse_prettier_output
+from lintro.parsers.pytest.pytest_parser import parse_pytest_text_output
 from lintro.parsers.ruff.ruff_issue import RuffFormatIssue, RuffIssue
 from lintro.parsers.ruff.ruff_parser import parse_ruff_output
 from lintro.parsers.yamllint.yamllint_parser import parse_yamllint_output
@@ -57,13 +73,16 @@ from lintro.parsers.yamllint.yamllint_parser import parse_yamllint_output
 # Constants
 TOOL_TABLE_FORMATTERS: dict[str, tuple] = {
     "darglint": (DarglintTableDescriptor(), format_darglint_issues),
+    "eslint": (EslintTableDescriptor(), format_eslint_issues),
     "hadolint": (HadolintTableDescriptor(), format_hadolint_issues),
     "black": (BlackTableDescriptor(), format_black_issues),
     "prettier": (PrettierTableDescriptor(), format_prettier_issues),
+    "pytest": (PytestFailuresTableDescriptor(), format_pytest_issues),
     "ruff": (RuffTableDescriptor(), format_ruff_issues),
     "yamllint": (YamllintTableDescriptor(), format_yamllint_issues),
     "actionlint": (ActionlintTableDescriptor(), format_actionlint_issues),
     "bandit": (BanditTableDescriptor(), format_bandit_issues),
+    "markdownlint": (MarkdownlintTableDescriptor(), format_markdownlint_issues),
 }
 VENV_PATTERNS: list[str] = [
     "venv",
@@ -104,7 +123,7 @@ def parse_tool_list(tools_str: str | None) -> list[str]:
         try:
             result.append(ToolEnum[t.upper()])
         except KeyError:
-            raise ValueError(f"Unknown core: {t}")
+            raise ValueError(f"Unknown core: {t}") from None
     return result
 
 
@@ -200,10 +219,7 @@ def get_table_columns(
         columns = expected_columns
     else:
         # Fallback: use all unique keys from the first issue
-        if issues:
-            columns = list(issues[0].keys())
-        else:
-            columns = []
+        columns = list(issues[0].keys()) if issues else []
 
     # Convert issues to rows
     rows: list[list[str]] = []
@@ -307,9 +323,19 @@ def format_tool_output(
                     isinstance(i, RuffIssue) and getattr(i, "fixable", False)
                 )
             if tool == "prettier":
-                return lambda i: isinstance(i, PrettierIssue) or True
+                return lambda i: isinstance(i, PrettierIssue)
             if tool == "black":
-                return lambda i: isinstance(i, BlackIssue) or True
+                return lambda i: isinstance(i, BlackIssue) and getattr(
+                    i,
+                    "fixable",
+                    True,
+                )
+            if tool == "eslint":
+                return lambda i: isinstance(i, EslintIssue) and getattr(
+                    i,
+                    "fixable",
+                    False,
+                )
             return None
 
         is_fixable = _is_fixable_predicate(tool_name)
@@ -367,10 +393,14 @@ def format_tool_output(
         parsed_issues = parse_black_output(output=output)
     elif tool_name == "darglint":
         parsed_issues = parse_darglint_output(output=output)
+    elif tool_name == "eslint":
+        parsed_issues = parse_eslint_output(output=output)
     elif tool_name == "hadolint":
         parsed_issues = parse_hadolint_output(output=output)
     elif tool_name == "yamllint":
         parsed_issues = parse_yamllint_output(output=output)
+    elif tool_name == "markdownlint":
+        parsed_issues = parse_markdownlint_output(output=output)
     elif tool_name == "bandit":
         # Bandit emits JSON; try parsing when raw output is provided
         try:
@@ -379,6 +409,9 @@ def format_tool_output(
             )
         except Exception:
             parsed_issues = []
+    elif tool_name == "pytest":
+        # Pytest emits text output; parse it
+        parsed_issues = parse_pytest_text_output(output=output)
 
     if parsed_issues and tool_name in TOOL_TABLE_FORMATTERS:
         _, formatter_func = TOOL_TABLE_FORMATTERS[tool_name]
@@ -394,21 +427,17 @@ def walk_files_with_excludes(
     exclude_patterns: list[str],
     include_venv: bool = False,
 ) -> list[str]:
-    """Walk through directories and find files matching patterns, excluding
-    specified patterns.
+    """Return files under ``paths`` matching patterns and not excluded.
 
     Args:
-        paths: list[str]: List of file or directory paths to search.
-        file_patterns: list[str]: List of file patterns to include (e.g.,
-            ["*.py", "*.js"]).
-        exclude_patterns: list[str]: List of patterns to exclude (e.g.,
-            ["__pycache__", "*.pyc"]).
-        include_venv: bool: Whether to include virtual environment directories.
+        paths: list[str]: Files or directories to search.
+        file_patterns: list[str]: Glob patterns to include.
+        exclude_patterns: list[str]: Glob patterns to exclude.
+        include_venv: bool: Include virtual environment directories when True.
 
     Returns:
-        list[str]: List of file paths that match the patterns and are not excluded.
+        list[str]: Sorted file paths matching include filters and not excluded.
     """
-
     all_files: list[str] = []
 
     for path in paths:
@@ -438,13 +467,11 @@ def walk_files_with_excludes(
                             matches_pattern = True
                             break
 
-                    if matches_pattern:
-                        # Check if file should be excluded
-                        if not should_exclude_path(
-                            path=rel_path,
-                            exclude_patterns=exclude_patterns,
-                        ):
-                            all_files.append(file_path)
+                    if matches_pattern and not should_exclude_path(
+                        path=rel_path,
+                        exclude_patterns=exclude_patterns,
+                    ):
+                        all_files.append(file_path)
 
     return sorted(all_files)