fix: add support for gitignore

Fixes: #1887

Author: ssbarnea

codespell_lib/_codespell.py

@@ -24,6 +24,7 @@
 import os
 import re
 import shlex
+import subprocess
 import sys
 import textwrap
 from collections.abc import Iterable, Sequence
@@ -558,6 +559,15 @@ def convert_arg_line_to_args(self, arg_line: str) -> list[str]:
         'you\'d give "*.eps,*.txt" to this option.',
     )
 
+    parser.add_argument(
+        "--use-git-ignore",
+        action="store_true",
+        default=False,
+        dest="use_git_ignore",
+        help="respect .gitignore by using 'git ls-files' to identify files to check. "
+        "Only files tracked by git will be checked.",
+    )
+
     parser.add_argument(
         "-x",
         "--exclude-file",
@@ -1228,6 +1238,56 @@ def flatten_clean_comma_separated_arguments(
     ]
 
 
+def get_git_tracked_files(paths: list[str]) -> list[str]:
+    """Get list of files tracked by git using git ls-files."""
+    try:
+        # If no paths specified, use current directory
+        if not paths:
+            paths = ["."]
+
+        all_files = []
+        for path in paths:
+            # If path is a directory, run git ls-files from within it
+            if os.path.isdir(path):
+                result = subprocess.run(
+                    ["git", "ls-files"],
+                    capture_output=True,
+                    text=True,
+                    check=True,
+                    cwd=path,
+                )
+                # Prepend the path to each file
+                files = [
+                    os.path.join(path, f)
+                    for f in result.stdout.strip().split("\n")
+                    if f
+                ]
+                all_files.extend(files)
+            else:
+                # For specific files, check if they're tracked
+                # Get the directory and filename
+                dirname = os.path.dirname(path) or "."
+                basename = os.path.basename(path)
+                result = subprocess.run(
+                    ["git", "ls-files", "--", basename],
+                    capture_output=True,
+                    text=True,
+                    check=True,
+                    cwd=dirname,
+                )
+                files = result.stdout.strip().split("\n")
+                if files and files[0]:
+                    all_files.append(path)
+
+        return all_files
+    except (subprocess.CalledProcessError, FileNotFoundError) as e:
+        print(
+            f"ERROR: Failed to run 'git ls-files': {e}",
+            file=sys.stderr,
+        )
+        return []
+
+
 def _script_main() -> int:
     """Wrap to main() for setuptools."""
     try:
@@ -1411,52 +1471,21 @@ def main(*args: str) -> int:
         )
 
     bad_count = 0
-    for filename in sorted(options.files):
-        # ignore hidden files
-        if is_hidden(filename, options.check_hidden):
-            continue
 
-        if os.path.isdir(filename):
-            for root, dirs, files in os.walk(filename):
-                if glob_match.match(root):  # skip (absolute) directories
-                    dirs.clear()
-                    continue
-                if is_hidden(root, options.check_hidden):  # dir itself hidden
-                    continue
-                for file_ in sorted(files):
-                    # ignore hidden files in directories
-                    if is_hidden(file_, options.check_hidden):
-                        continue
-                    if glob_match.match(file_):  # skip files
-                        continue
-                    fname = os.path.join(root, file_)
-                    if glob_match.match(fname):  # skip paths
-                        continue
-                    bad_count += parse_file(
-                        fname,
-                        colors,
-                        summary,
-                        misspellings,
-                        ignore_words_cased,
-                        exclude_lines,
-                        file_opener,
-                        word_regex,
-                        ignore_word_regex,
-                        uri_regex,
-                        uri_ignore_words,
-                        context,
-                        options,
-                    )
+    # Use git ls-files if requested
+    if options.use_git_ignore:
+        git_files = get_git_tracked_files(options.files)
+        if not git_files:
+            return EX_OK
 
-                # skip (relative) directories
-                dirs[:] = [
-                    dir_
-                    for dir_ in dirs
-                    if not glob_match.match(dir_)
-                    and not is_hidden(dir_, options.check_hidden)
-                ]
+        for filename in git_files:
+            # Apply skip patterns
+            if glob_match.match(filename):
+                continue
+            # Check if file should be processed (hidden file check)
+            if is_hidden(filename, options.check_hidden):
+                continue
 
-        elif not glob_match.match(filename):  # skip files
             bad_count += parse_file(
                 filename,
                 colors,
@@ -1472,6 +1501,69 @@ def main(*args: str) -> int:
                 context,
                 options,
             )
+    else:
+        # Original directory walking behavior
+        for filename in sorted(options.files):
+            # ignore hidden files
+            if is_hidden(filename, options.check_hidden):
+                continue
+
+            if os.path.isdir(filename):
+                for root, dirs, files in os.walk(filename):
+                    if glob_match.match(root):  # skip (absolute) directories
+                        dirs.clear()
+                        continue
+                    if is_hidden(root, options.check_hidden):  # dir itself hidden
+                        continue
+                    for file_ in sorted(files):
+                        # ignore hidden files in directories
+                        if is_hidden(file_, options.check_hidden):
+                            continue
+                        if glob_match.match(file_):  # skip files
+                            continue
+                        fname = os.path.join(root, file_)
+                        if glob_match.match(fname):  # skip paths
+                            continue
+                        bad_count += parse_file(
+                            fname,
+                            colors,
+                            summary,
+                            misspellings,
+                            ignore_words_cased,
+                            exclude_lines,
+                            file_opener,
+                            word_regex,
+                            ignore_word_regex,
+                            uri_regex,
+                            uri_ignore_words,
+                            context,
+                            options,
+                        )
+
+                    # skip (relative) directories
+                    dirs[:] = [
+                        dir_
+                        for dir_ in dirs
+                        if not glob_match.match(dir_)
+                        and not is_hidden(dir_, options.check_hidden)
+                    ]
+
+            elif not glob_match.match(filename):  # skip files
+                bad_count += parse_file(
+                    filename,
+                    colors,
+                    summary,
+                    misspellings,
+                    ignore_words_cased,
+                    exclude_lines,
+                    file_opener,
+                    word_regex,
+                    ignore_word_regex,
+                    uri_regex,
+                    uri_ignore_words,
+                    context,
+                    options,
+                )
 
     if summary:
         print("\n-------8<-------\nSUMMARY:")

codespell_lib/tests/test_basic.py

@@ -1524,3 +1524,72 @@ def test_args_from_file(
     print("Testing with direct call to cs_.main()")
     r = cs_.main(*args[1:])
     print(f"{r=}")
+
+
+def test_use_git_ignore(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    """Test --use-git-ignore option respects .gitignore."""
+    # Initialize a git repo
+    subprocess.run(["git", "init"], cwd=tmp_path, check=True, capture_output=True)
+    subprocess.run(
+        ["git", "config", "user.email", "test@test.com"],
+        cwd=tmp_path,
+        check=True,
+        capture_output=True,
+    )
+    subprocess.run(
+        ["git", "config", "user.name", "Test User"],
+        cwd=tmp_path,
+        check=True,
+        capture_output=True,
+    )
+    # Disable hooks to avoid any pre-commit issues
+    subprocess.run(
+        ["git", "config", "core.hooksPath", "/dev/null"],
+        cwd=tmp_path,
+        check=True,
+        capture_output=True,
+    )
+
+    # Create files
+    tracked_file = tmp_path / "tracked.txt"
+    ignored_file = tmp_path / "ignored.txt"
+    gitignore = tmp_path / ".gitignore"
+
+    tracked_file.write_text("abandonned\n")
+    ignored_file.write_text("abandonned\n")
+    gitignore.write_text("ignored.txt\n")
+
+    # Add and commit tracked file and .gitignore
+    subprocess.run(
+        ["git", "add", "tracked.txt", ".gitignore"],
+        cwd=tmp_path,
+        check=True,
+        capture_output=True,
+    )
+    result = subprocess.run(
+        ["git", "commit", "-m", "Initial commit", "--no-gpg-sign"],
+        cwd=tmp_path,
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        # Print debug info if commit fails
+        print(f"Git commit failed: {result.stderr}")
+        pytest.skip("Git commit failed, possibly due to hooks")
+
+    # Run codespell with --use-git-ignore
+    # Should only check tracked.txt, not ignored.txt
+    code, stdout, stderr = cs.main(
+        "--use-git-ignore",
+        tmp_path,
+        std=True,
+    )
+
+    # Should find error in tracked.txt
+    assert "tracked.txt:1: abandonned ==> abandoned" in stdout
+    # Should NOT find error in ignored.txt
+    assert "ignored.txt" not in stdout
+    assert code == 1  # Should have found 1 error