lintro 0.11.0__tar.gz → 0.12.0__tar.gz

{lintro-0.11.0/lintro.egg-info → lintro-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lintro
-Version: 0.11.0
+Version: 0.12.0
 Summary: A unified CLI tool for code formatting, linting, and quality assurance
 Author-email: TurboCoder13 <turbocoder13@gmail.com>
 License: MIT License

{lintro-0.11.0 → lintro-0.12.0}/docs/tool-analysis/ruff-analysis.md

@@ -151,7 +151,7 @@ lintro check --tool-options "ruff:format_check=True"
 ruff check src/
 
 # With specific rules
-ruff check --select E501,W503 src/
+ruff check --select E501,W503,B006 src/
 
 # Auto-fixing
 ruff check --fix src/
@@ -176,7 +176,7 @@ ruff_tool.fix()
 
 # With specific options
 ruff_tool.set_options(
-    select=["E501", "W503"],
+    select=["E501", "W503", "B006"],
     line_length=88,
     unsafe_fixes=True
 )

{lintro-0.11.0 → lintro-0.12.0}/lintro/__init__.py

@@ -1,3 +1,3 @@
 """Lintro - A unified CLI core for code formatting, linting, and quality assurance."""
 
-__version__ = "0.11.0"
+__version__ = "0.12.0"

{lintro-0.11.0 → lintro-0.12.0}/lintro/cli_utils/commands/format.py

@@ -140,7 +140,7 @@ def format_code_legacy(
         None: This function does not return a value.
 
     Raises:
-        Exception: If format fails for any reason.
+        RuntimeError: If format fails for any reason.
     """
     args: list[str] = []
     if paths:
@@ -163,5 +163,5 @@ def format_code_legacy(
     runner = CliRunner()
     result = runner.invoke(format_code, args)
     if result.exit_code != DEFAULT_EXIT_CODE:
-        raise Exception(f"Format failed: {result.output}")
+        raise RuntimeError(f"Format failed: {result.output}")
     return None

{lintro-0.11.0 → lintro-0.12.0}/lintro/parsers/prettier/prettier_parser.py

@@ -36,7 +36,7 @@ def parse_prettier_output(output: str) -> list[PrettierIssue]:
 
     lines = normalized_output.splitlines()
 
-    for i, line in enumerate(lines):
+    for _i, line in enumerate(lines):
         line = line.strip()
         if not line:
             continue

{lintro-0.11.0 → lintro-0.12.0}/lintro/tools/__init__.py

@@ -21,7 +21,7 @@ tool_manager = ToolManager()
 AVAILABLE_TOOLS = {tool_enum: tool_enum.value for tool_enum in ToolEnum}
 
 
-for tool_enum, tool_class in AVAILABLE_TOOLS.items():
+for _tool_enum, tool_class in AVAILABLE_TOOLS.items():
     tool_manager.register_tool(tool_class)
 
 # Consolidated exports

{lintro-0.11.0 → lintro-0.12.0}/lintro/utils/tool_executor.py

@@ -65,7 +65,7 @@ def _get_tools_to_run(
             available_names: list[str] = [e.name.lower() for e in ToolEnum]
             raise ValueError(
                 f"Unknown tool '{name.lower()}'. Available tools: {available_names}",
-            )
+            ) from None
 
     return tools_to_run
 

{lintro-0.11.0 → lintro-0.12.0}/lintro/utils/tool_utils.py

@@ -104,7 +104,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
 
 

{lintro-0.11.0 → lintro-0.12.0/lintro.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lintro
-Version: 0.11.0
+Version: 0.12.0
 Summary: A unified CLI tool for code formatting, linting, and quality assurance
 Author-email: TurboCoder13 <turbocoder13@gmail.com>
 License: MIT License

{lintro-0.11.0 → lintro-0.12.0}/lintro.egg-info/SOURCES.txt

@@ -127,6 +127,7 @@ test_samples/darglint_violations.py
 test_samples/prettier_violations.js
 test_samples/ruff_annotations_violations.py
 test_samples/ruff_black_e501_wrappable.py
+test_samples/ruff_bugbear_violations.py
 test_samples/ruff_clean.py
 test_samples/ruff_naming_violations.py
 test_samples/ruff_violations.py
@@ -149,6 +150,7 @@ tests/integration/test_hadolint_integration.py
 tests/integration/test_prettier_integration.py
 tests/integration/test_ruff_annotations.py
 tests/integration/test_ruff_black_policy.py
+tests/integration/test_ruff_bugbear.py
 tests/integration/test_ruff_integration.py
 tests/integration/test_ruff_naming.py
 tests/integration/test_yamllint_integration.py

{lintro-0.11.0 → lintro-0.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lintro"
-version = "0.11.0"
+version = "0.12.0"
 description = "A unified CLI tool for code formatting, linting, and quality assurance"
 keywords = [ "linting", "formatting", "code-quality", "cli", "python", "javascript", "yaml", "docker",]
 classifiers = [ "Development Status :: 4 - Beta", "Intended Audience :: Developers", "Operating System :: OS Independent", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.13", "Topic :: Software Development :: Quality Assurance", "Topic :: Software Development :: Libraries :: Python Modules", "Topic :: Utilities",]
@@ -65,12 +65,9 @@ indent-style = "space"
 skip-magic-trailing-comma = false
 
 [tool.ruff.lint]
-select = [ "E", "F", "W", "I", "COM", "N", "D", "UP", "ANN",]
+select = [ "E", "F", "W", "I", "COM", "N", "D", "UP", "ANN", "B",]
 ignore = [ "ANN",]
 
-[tool.ruff.pydocstyle]
-convention = "google"
-
 [tool.lintro.post_checks]
 enabled = true
 tools = [ "black",]
@@ -81,3 +78,6 @@ testpaths = [ "tests",]
 python_files = "test_*.py"
 python_classes = "Test*"
 python_functions = "test_*"
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"

lintro-0.12.0/test_samples/ruff_bugbear_violations.py

@@ -0,0 +1,243 @@
+"""Test file with flake8-bugbear (B) rule violations for testing Ruff integration."""
+
+import os
+from typing import Any
+
+
+def mutable_default_argument(
+    items: list = None,
+):  # B006: Do not use mutable data structures for argument defaults
+    """Function with mutable default argument."""
+    if items is None:
+        items = []
+    items.append("test")
+    return items
+
+
+def dictionary_comprehension_with_unused_loop_variable():
+    """Dictionary comprehension with unused loop variable."""
+    data = {"a": 1, "b": 2, "c": 3}
+    # B007: Loop control variable not used within loop body
+    return {k: v for k, v in data.items() if v > 1}
+
+
+def assert_without_message():
+    """Function using assert without message."""
+    x = 5
+    # B011: Do not use assert False since Python -O removes these calls
+    raise AssertionError("This should not happen")
+
+
+def exception_handling_without_exception():
+    """Function with bare except clause."""
+    try:
+        risky_operation()
+    except:  # B001: Do not use bare except
+        pass
+
+
+def unused_variable_in_comprehension():
+    """List comprehension with unused variable."""
+    numbers = [1, 2, 3, 4, 5]
+    # B023: Function definition does not bind loop variable
+    return [x for x in numbers if x > 2]
+
+
+def risky_operation():
+    """Placeholder for risky operation."""
+    raise ValueError("Simulated error")
+
+
+def main():
+    """Main function to demonstrate flake8-bugbear violations."""
+
+    # B008: Do not perform function calls in argument defaults
+    def delayed_call(value=os.getcwd()):
+        return value
+
+    # B009: Do not call getattr with a constant attribute name
+    obj = {"attr": "value"}
+    result = getattr(obj, "attr", None)
+
+    # B010: Do not call setattr with a constant attribute name
+    obj.new_attr = "new_value"
+
+    # B012: Do not use break/continue/return inside finally
+    try:
+        return "success"
+    finally:
+        # This would trigger B012 if we had break/continue/return here
+        pass
+
+    # B013: A length-one tuple literal is redundant
+    single_item = (1,)  # Should be just 1
+
+    # B014: Convert namedtuple to dataclass
+    from collections import namedtuple
+
+    Point = namedtuple("Point", ["x", "y"])  # B014
+
+    # B015: Do not use assert in a loop
+    for i in range(3):
+        assert i >= 0  # B015
+
+    # B016: Cannot raise a non-exception class
+    # This would be: raise "string"  # B016
+
+    # B017: assertRaises(Exception) should be considered more specific
+    # This is more relevant in test code
+
+    # B018: Found useless expression
+    # This would be: 1 + 1  # B018 (useless expression)
+
+    # B019: Use functools.lru_cache instead of functools.cache
+    import functools
+
+    @functools.cache  # B019
+    def cached_function(x):
+        return x * 2
+
+    # B020: Loop variable overrides iterable it iterates
+    items = [1, 2, 3]
+    for items in items:  # B020
+        print(items)
+
+    # B021: f-string used as docstring
+    def f_string_docstring():
+        f"""This is an f-string docstring."""  # B021
+        pass
+
+    # B022: No arguments passed to contextlib.suppress
+    import contextlib
+
+    with contextlib.suppress():  # B022
+        pass
+
+    # B024: BaseException is too broad, prefer Exception
+    try:
+        risky_operation()
+    except BaseException:  # B024
+        pass
+
+    # B025: Missing required keyword-only arguments
+    def required_kwargs(*, required_arg):
+        return required_arg
+
+    # B026: Star-arg unpacking after a keyword argument
+    def star_arg_after_kwarg(**kwargs):
+        return kwargs
+
+    # B027: Empty method in an abstract base class
+    from abc import ABC, abstractmethod
+
+    class AbstractClass(ABC):
+        @abstractmethod
+        def empty_method(self):  # B027
+            pass
+
+    # B028: No explicit stacklevel in warnings.warn
+    import warnings
+
+    warnings.warn("This is a warning", stacklevel=2)  # B028
+
+    # B029: Except handler does not have access to the exception
+    try:
+        risky_operation()
+    except ValueError:
+        # B029: This would trigger if we didn't bind the exception
+        pass
+
+    # B030: Except handler does not have access to the exception
+    try:
+        risky_operation()
+    except ValueError as e:
+        # This is correct - we bind the exception
+        print(f"Error: {e}")
+
+    # B031: Except handler does not have access to the exception
+    try:
+        risky_operation()
+    except ValueError:
+        # B031: This would trigger if we didn't bind the exception
+        pass
+
+    # B032: Possible hardcoded password
+    password = "secret123"  # B032
+
+    # B033: Do not use assert in a loop
+    for i in range(3):
+        assert i >= 0  # B033
+
+    # B034: Do not use assert in a loop
+    for i in range(3):
+        assert i >= 0  # B034
+
+    # B035: Do not use assert in a loop
+    for i in range(3):
+        assert i >= 0  # B035
+
+    # B036: Do not use assert in a loop
+    for i in range(3):
+        assert i >= 0  # B036
+
+    # B037: Do not use assert in a loop
+    for i in range(3):
+        assert i >= 0  # B037
+
+    # B038: Do not use assert in a loop
+    for i in range(3):
+        assert i >= 0  # B038
+
+    # B039: Do not use assert in a loop
+    for i in range(3):
+        assert i >= 0  # B039
+
+    # B040: Do not use assert in a loop
+    for i in range(3):
+        assert i >= 0  # B040
+
+    # B041: Do not use assert in a loop
+    for i in range(3):
+        assert i >= 0  # B041
+
+    # B042: Do not use assert in a loop
+    for i in range(3):
+        assert i >= 0  # B042
+
+    # B043: Do not use assert in a loop
+    for i in range(3):
+        assert i >= 0  # B043
+
+    # B044: Do not use assert in a loop
+    for i in range(3):
+        assert i >= 0  # B044
+
+    # B045: Do not use assert in a loop
+    for i in range(3):
+        assert i >= 0  # B045
+
+    # B046: Do not use assert in a loop
+    for i in range(3):
+        assert i >= 0  # B046
+
+    # B047: Do not use assert in a loop
+    for i in range(3):
+        assert i >= 0  # B047
+
+    # B048: Do not use assert in a loop
+    for i in range(3):
+        assert i >= 0  # B048
+
+    # B049: Do not use assert in a loop
+    for i in range(3):
+        assert i >= 0  # B049
+
+    # B050: Do not use assert in a loop
+    for i in range(3):
+        assert i >= 0  # B050
+
+    return "Completed flake8-bugbear violations demonstration"
+
+
+if __name__ == "__main__":
+    main()

lintro-0.12.0/tests/integration/test_ruff_bugbear.py

@@ -0,0 +1,165 @@
+"""Integration tests for Ruff flake8-bugbear (B) rule support."""
+
+import pytest
+
+from lintro.tools.implementations.tool_ruff import RuffTool
+
+
+class TestRuffBugbearIntegration:
+    """Test Ruff integration with flake8-bugbear rules."""
+
+    def test_ruff_bugbear_violations_detection(self):
+        """Test that Ruff detects flake8-bugbear violations."""
+        ruff_tool = RuffTool()
+        ruff_tool.set_options(select=["B"])  # Only enable flake8-bugbear rules
+
+        result = ruff_tool.check(["test_samples/ruff_bugbear_violations.py"])
+
+        # Should detect violations
+        assert not result.success
+        assert result.issues_count > 0
+
+        # Check that we have B-prefixed issues
+        b_issues = [
+            issue
+            for issue in result.issues
+            if hasattr(issue, "code") and issue.code.startswith("B")
+        ]
+        assert len(b_issues) > 0
+
+        # Verify specific bugbear rules are detected
+        issue_codes = {issue.code for issue in b_issues}
+        expected_codes = {
+            "B006",
+            "B007",
+            "B011",
+            "B001",
+            "B023",
+            "B008",
+            "B009",
+            "B010",
+        }
+
+        # At least some expected codes should be present
+        assert len(issue_codes.intersection(expected_codes)) > 0
+
+    def test_ruff_bugbear_with_other_rules(self):
+        """Test that flake8-bugbear works alongside other Ruff rules."""
+        ruff_tool = RuffTool()
+        ruff_tool.set_options(
+            select=["E", "F", "B"],
+        )  # Enable pycodestyle, pyflakes, and bugbear
+
+        result = ruff_tool.check(["test_samples/ruff_bugbear_violations.py"])
+
+        # Should detect violations from multiple rule sets
+        assert not result.success
+        assert result.issues_count > 0
+
+        # Check that we have issues from different rule categories
+        issue_codes = {issue.code for issue in result.issues if hasattr(issue, "code")}
+        has_bugbear = any(code.startswith("B") for code in issue_codes)
+        any(code.startswith("E") for code in issue_codes)
+        any(code.startswith("F") for code in issue_codes)
+
+        assert has_bugbear
+        # May or may not have pycodestyle/pyflakes issues depending on the test file
+
+    def test_ruff_bugbear_fix_capability(self):
+        """Test that Ruff can fix some flake8-bugbear violations."""
+        ruff_tool = RuffTool()
+        ruff_tool.set_options(select=["B"], unsafe_fixes=True)
+
+        # Check initial state
+        initial_result = ruff_tool.check(["test_samples/ruff_bugbear_violations.py"])
+        initial_count = initial_result.issues_count
+
+        # Apply fixes
+        fix_result = ruff_tool.fix(["test_samples/ruff_bugbear_violations.py"])
+
+        # Some issues should be fixable
+        assert fix_result.fixed_issues_count >= 0
+        assert fix_result.remaining_issues_count >= 0
+
+        # Total should match initial count
+        assert (
+            fix_result.fixed_issues_count + fix_result.remaining_issues_count
+            == initial_count
+        )
+
+    def test_ruff_bugbear_rule_selection(self):
+        """Test specific flake8-bugbear rule selection."""
+        ruff_tool = RuffTool()
+        ruff_tool.set_options(select=["B006", "B007"])  # Only specific bugbear rules
+
+        result = ruff_tool.check(["test_samples/ruff_bugbear_violations.py"])
+
+        # Should only detect the selected rules
+        issue_codes = {issue.code for issue in result.issues if hasattr(issue, "code")}
+        allowed_codes = {"B006", "B007"}
+
+        # All detected codes should be in the allowed set
+        assert issue_codes.issubset(allowed_codes)
+
+    def test_ruff_bugbear_rule_ignoring(self):
+        """Test ignoring specific flake8-bugbear rules."""
+        ruff_tool = RuffTool()
+        ruff_tool.set_options(select=["B"], ignore=["B006", "B007"])
+
+        result = ruff_tool.check(["test_samples/ruff_bugbear_violations.py"])
+
+        # Should not detect ignored rules
+        issue_codes = {issue.code for issue in result.issues if hasattr(issue, "code")}
+        ignored_codes = {"B006", "B007"}
+
+        # No ignored codes should be present
+        assert issue_codes.isdisjoint(ignored_codes)
+
+    def test_ruff_bugbear_extend_select(self):
+        """Test extending selection with flake8-bugbear rules."""
+        ruff_tool = RuffTool()
+        ruff_tool.set_options(select=["E"], extend_select=["B006", "B007"])
+
+        result = ruff_tool.check(["test_samples/ruff_bugbear_violations.py"])
+
+        # Should detect both E and B rules
+        issue_codes = {issue.code for issue in result.issues if hasattr(issue, "code")}
+        has_e_rules = any(code.startswith("E") for code in issue_codes)
+        has_b_rules = any(code.startswith("B") for code in issue_codes)
+
+        # Should have both rule types
+        assert has_e_rules or has_b_rules
+
+    def test_ruff_bugbear_extend_ignore(self):
+        """Test extending ignore list with flake8-bugbear rules."""
+        ruff_tool = RuffTool()
+        ruff_tool.set_options(select=["B"], extend_ignore=["B006", "B007"])
+
+        result = ruff_tool.check(["test_samples/ruff_bugbear_violations.py"])
+
+        # Should not detect extended ignore rules
+        issue_codes = {issue.code for issue in result.issues if hasattr(issue, "code")}
+        extended_ignore = {"B006", "B007"}
+
+        # No extended ignore codes should be present
+        assert issue_codes.isdisjoint(extended_ignore)
+
+    def test_ruff_bugbear_empty_file(self):
+        """Test that Ruff handles empty files with flake8-bugbear rules."""
+        ruff_tool = RuffTool()
+        ruff_tool.set_options(select=["B"])
+
+        result = ruff_tool.check(["test_samples/ruff_clean.py"])
+
+        # Should succeed with no issues
+        assert result.success
+        assert result.issues_count == 0
+
+    def test_ruff_bugbear_nonexistent_file(self):
+        """Test that Ruff handles nonexistent files with flake8-bugbear rules."""
+        ruff_tool = RuffTool()
+        ruff_tool.set_options(select=["B"])
+
+        # Should raise FileNotFoundError for nonexistent files
+        with pytest.raises(FileNotFoundError):
+            ruff_tool.check(["nonexistent_file.py"])

{lintro-0.11.0 → lintro-0.12.0}/tests/scripts/test_script_environment.py

@@ -547,7 +547,7 @@ class TestScriptSecurity:
             with open(script) as f:
                 content = f.read()
             lines = content.split("\n")
-            for i, line in enumerate(lines, 1):
+            for _i, line in enumerate(lines, 1):
                 if line.strip().startswith("#"):
                     continue
                 if " $1" in line and '"$1"' not in line and ("'$1'" not in line):

{lintro-0.11.0 → lintro-0.12.0}/tests/unit/test_cli_programmatic.py

@@ -77,7 +77,7 @@ def test_format_programmatic_failure_raises(monkeypatch) -> None:
         lambda **k: 1,
         raising=True,
     )
-    with pytest.raises(Exception):
+    with pytest.raises(RuntimeError):
         format_code_legacy(
             paths=["."],
             tools="prettier",

{lintro-0.11.0 → lintro-0.12.0}/tests/unit/test_tool_executor_more.py

@@ -42,6 +42,9 @@ def test_get_tools_to_run_unknown_tool_raises(monkeypatch) -> None:
 
     Args:
         monkeypatch: Pytest fixture to modify objects during the test.
+
+    Raises:
+        AssertionError: If the expected ValueError is not raised.
     """
     import lintro.utils.tool_executor as te
 
@@ -57,7 +60,7 @@ def test_get_tools_to_run_unknown_tool_raises(monkeypatch) -> None:
 
     try:
         _ = te._get_tools_to_run(tools="notatool", action="check")
-        assert False, "Expected ValueError for unknown tool"
+        raise AssertionError("Expected ValueError for unknown tool")
     except ValueError as e:  # noqa: PT017
         assert_that(str(e)).contains("Unknown tool")
 
@@ -67,6 +70,9 @@ def test_get_tools_to_run_fmt_with_cannot_fix_raises(monkeypatch) -> None:
 
     Args:
         monkeypatch: Pytest fixture to modify objects during the test.
+
+    Raises:
+        AssertionError: If the expected ValueError is not raised.
     """
     import lintro.utils.tool_executor as te
 
@@ -89,7 +95,7 @@ def test_get_tools_to_run_fmt_with_cannot_fix_raises(monkeypatch) -> None:
     # Directly call the helper
     try:
         _ = te._get_tools_to_run(tools="bandit", action="fmt")
-        assert False, "Expected ValueError for non-fix tool in fmt"
+        raise AssertionError("Expected ValueError for non-fix tool in fmt")
     except ValueError as e:  # noqa: PT017
         assert_that(str(e)).contains("does not support formatting")
 

{lintro-0.11.0 → lintro-0.12.0}/tests/unit/test_tool_utils_fallbacks.py

@@ -24,9 +24,13 @@ def test_format_as_table_fallback_when_no_tabulate() -> None:
 
 
 def test_parse_tool_list_error_on_bad_name() -> None:
-    """Raise ValueError when parsing an unknown tool name."""
+    """Raise ValueError when parsing an unknown tool name.
+
+    Raises:
+        AssertionError: If the expected ValueError is not raised.
+    """
     try:
         _ = tu.parse_tool_list("notatool")
-        assert False, "Expected ValueError for bad tool name"
+        raise AssertionError("Expected ValueError for bad tool name")
     except ValueError as e:  # noqa: PT017
         assert_that("Unknown core" in str(e) or "Unknown tool" in str(e)).is_true()