Kod Linter + ruff

A code linter is a static code analysis tool used to flag programming errors, bugs, stylistic errors, and suspicious constructs. It examines source code without executing it, providing feedback on potential issues. Linters are crucial for maintaining code quality, consistency, and readability across projects, especially in team environments. They help enforce coding standards, catch errors early in the development cycle, and improve code maintainability.

`ruff` is an extremely fast Python linter and code formatter written in Rust. It aims to be a drop-in replacement for a wide array of tools used in the Python ecosystem, including Flake8, isort, Black (for formatting-like fixes), pyupgrade, pydocstyle, and more. `ruff`'s key advantage is its unparalleled speed, often outperforming traditional Python-based linters by orders of magnitude, making it ideal for large codebases and continuous integration pipelines.

Key features and benefits of `ruff`:

- Blazing Fast: Written in Rust, `ruff` processes Python code incredibly quickly, significantly reducing the time spent on linting and formatting.
- All-in-One Tool: It consolidates the functionality of many separate tools into a single, unified solution. This simplifies project dependencies and configuration.
- Extensive Rule Set: `ruff` supports thousands of rules, including those derived from popular linters and formatters, providing comprehensive code analysis.
- Black Compatibility: While `ruff` is primarily a linter, its `fix` capabilities often align with Black's formatting style, allowing it to automatically resolve many stylistic issues without conflicting with Black, or even replacing Black for some users.
- Simple Configuration: `ruff` can be configured easily via `pyproject.toml` (the standard for modern Python projects), making it straightforward to integrate into existing Python projects.

By integrating `ruff` into a development workflow, developers can ensure higher code quality, enforce consistent coding standards, and detect potential issues much faster, leading to more robust and maintainable software.

Example Code

 1. Install ruff (preferably in a virtual environment):
 pip install ruff

 2. Create a Python file named `bad_code.py` with some common linter issues:

 --- bad_code.py ---
import os, sys  F401 (Unused imports) & E401 (Multiple imports on one line)

def my_function(  arg1,arg2 ):  E201 (Whitespace after '('), E202 (Whitespace before ')'), W291 (Trailing whitespace)
     A comment here
    result = arg1 + arg2;  E222 (Multiple spaces after operator), E703 (Statement ends with a semicolon)
    print("Hello World!")  E231 (Missing whitespace after ',')
    if True: pass  E704 (Multiple statements on one line)
    MY_CONSTANT = 10  N806 (Variable `MY_CONSTANT` in function should be lowercase) - usually for local vars, but good for demo
    return result
 -------------------

 3. Run ruff to check for errors in `bad_code.py`:
 ruff check bad_code.py

 Expected output (the exact rule codes and messages might vary slightly with ruff versions):
 bad_code.py:1:8: E401 Multiple imports on one line
 bad_code.py:1:8: F401 [-] `os` imported but unused
 bad_code.py:1:13: F401 [-] `sys` imported but unused
 bad_code.py:3:17: E201 Whitespace after '('
 bad_code.py:3:23: E202 Whitespace before ')'
 bad_code.py:3:2: W291 Trailing whitespace
 bad_code.py:6:21: E222 Multiple spaces after operator
 bad_code.py:6:22: E703 Statement ends with a semicolon
 bad_code.py:7:21: E231 Missing whitespace after ','
 bad_code.py:8:13: E704 Multiple statements on one line (do not use pass on same line)
 bad_code.py:9:5: N806 Variable `MY_CONSTANT` in function should be lowercase (or SCREAMING_SNAKE_CASE if truly global constant)
 Found 10 errors. (9 potentially fixable)

 4. Run ruff to automatically fix many fixable errors:
 ruff check bad_code.py --fix

 `bad_code.py` content after --fix (ruff modifies the file in place):
 import os
 import sys

 def my_function(arg1, arg2):
      A comment here
     result = arg1 + arg2
     print("Hello World!")
     if True: pass
     MY_CONSTANT = 10
     return result

 Note: Some issues like F401 (unused imports), N806 (naming), and E704 (multiple statements) might not be fixed automatically by default, or require specific configuration.
 The --fix command significantly cleans up whitespace and syntax errors.

 5. Example of ruff configuration in `pyproject.toml` (a common practice for project-wide settings):
 Create a `pyproject.toml` file in your project root:

 --- pyproject.toml ---
 [tool.ruff]
 line-length = 88
  Define which rule codes ruff should check. `E` (pycodestyle errors), `F` (Pyflakes), `W` (pycodestyle warnings),
  `I` (isort), `N` (pep8-naming), `D` (pydocstyle), `UP` (pyupgrade) are common.
 select = ["E", "F", "W", "I", "N", "D", "UP"]
 ignore = ["E501"]  Ignore 'line too long' errors, especially if using a separate formatter like Black
 fix = true  Enable auto-fixing by default when running `ruff .` or `ruff --fix`
 target-version = "py39"  Specify target Python version for checks like pyupgrade

 [tool.ruff.per-file-ignores]
  Ignore specific rules for certain files or patterns
 "__init__.py" = ["F401"]  Ignore unused imports in __init__.py files
 "tests/-" = ["D"]  Ignore docstring requirements in test files

 [tool.ruff.isort]
  isort specific settings
 known-first-party = ["my_project", "another_module"]
 force-single-line = false
 -------------------

 6. Now, run `ruff check .` from your project root. Ruff will discover and lint all Python files,
 applying the settings from `pyproject.toml`. Fixes can be applied with `ruff check . --fix`.
 ruff check .  checks all files in the current directory and subdirectories
 ruff check . --fix  checks and applies fixes to all files

Example Code

Related Topics