add support for pyproject.toml

.github/workflows/ci.yaml

@@ -22,12 +22,12 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install pytest
+        pip install pytest pytest-mock
         pip install pyyaml==6.0
         pip install -e .[test]
     - name: Run tests
       run: |
-        pytest -vv tests/
+        pytest -vv
 
   coverage:
     name: "Coverage"
@@ -41,12 +41,12 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install pytest pytest-cov coveralls
+        pip install pytest pytest-cov pytest-mock coveralls
         pip install pyyaml==6.0
         pip install -e .[test]
     - name: Run tests
       run: |
-        pytest --cov=ssort -v tests/
+        pytest --cov=ssort -v
     - name: Upload coverage report to coveralls
       run: |
         coveralls --service=github
@@ -102,7 +102,7 @@ jobs:
         pip install -e .
     - name: Run ssort
       run: |
-        ssort --check --diff src/ tests/
+        ssort --check --diff .
 
   pyflakes:
     name: "PyFlakes"

pyproject.toml

@@ -64,6 +64,11 @@ exclude = "test_data/samples/*"
 ignore_missing_imports = true
 module = "pathspec"
 
+[tool.pytest.ini_options]
+testpaths = [
+    "tests"
+]
+
 [tool.setuptools]
 include-package-data = false
 license-files = [
@@ -75,3 +80,10 @@ attr = "ssort.__version__"
 
 [tool.setuptools.packages.find]
 where = ["src"]
+
+[tool.ssort]
+extend_skip = [
+    ".pytest_cache",
+    "__pycache__",
+    "test_data"
+]

src/ssort/_config.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+
+if sys.version_info >= (3, 11):
+    from tomllib import load
+else:
+    from tomli import load
+
+
+__all__ = ["get_config_from_root"]
+
+
+DEFAULT_SKIP = frozenset(
+    {
+        ".bzr",
+        ".direnv",
+        ".eggs",
+        ".git",
+        ".hg",
+        ".mypy_cache",
+        ".nox",
+        ".pants.d",
+        ".pytype",
+        ".ruff_cache",
+        ".svn",
+        ".tox",
+        ".venv",
+        "__pypackages__",
+        "_build",
+        "buck-out",
+        "build",
+        "dist",
+        "node_modules",
+        "venv",
+    }
+)
+
+
+def iter_valid_python_files_recursive(folder, *, is_invalid):
+    for child in folder.iterdir():
+        if is_invalid(child):
+            continue
+
+        elif child.is_file() and child.suffix == ".py":
+            yield child
+
+        elif child.is_dir():
+            yield from iter_valid_python_files_recursive(
+                child, is_invalid=is_invalid
+            )
+
+
+@dataclass(frozen=True)
+class Config:
+    skip: frozenset | list = DEFAULT_SKIP
+    skip_glob: list = field(default_factory=list)
+    extend_skip: list = field(default_factory=list)
+
+    def is_invalid(self, path):
+        if path.name in (set(self.skip) | set(self.extend_skip)):
+            return True
+
+        for pat in self.skip_glob:
+            if path.is_file() and path.match(pat):
+                return True
+
+        return False
+
+    def iterate_files_matching_patterns(self, pattern):
+        for pat in pattern:
+            path = Path(pat).resolve()
+
+            if path.is_file() and path.suffix == ".py":
+                yield path
+
+            elif path.is_dir():
+                yield from iter_valid_python_files_recursive(
+                    path, is_invalid=self.is_invalid
+                )
+
+
+def parse_pyproject_toml(path):
+    with open(path, "rb") as fh:
+        pyproject_toml = load(fh)
+
+    return pyproject_toml.get("tool", {}).get("ssort", {})
+
+
+def get_config_from_root(root):
+    path_pyproject_toml = root / "pyproject.toml"
+
+    if path_pyproject_toml.exists():
+        config_dict = parse_pyproject_toml(path_pyproject_toml)
+    else:
+        config_dict = {}
+
+    return Config(**config_dict)

src/ssort/_files.py

@@ -1,72 +1,33 @@
-from __future__ import annotations
+from pathlib import Path
 
-import os
-import pathlib
-from typing import Iterable
+__all__ = ["find_project_root"]
 
-import pathspec
 
-from ssort._utils import memoize
+def current_working_dir():
+    return Path(".").resolve()
 
-_EMPTY_PATH_SPEC = pathspec.PathSpec([])
 
+def find_project_root(patterns):
+    all_patterns = [current_working_dir()]
 
-@memoize
-def _is_project_root(path: pathlib.Path) -> bool:
-    if path == path.root or path == path.parent:
-        return True
+    if patterns:
+        all_patterns.extend(patterns)
 
-    if (path / ".git").is_dir():
-        return True
+    paths = [Path(p).resolve() for p in all_patterns]
+    parents_and_self = [
+        list(reversed(p.parents)) + ([p] if p.is_dir() else []) for p in paths
+    ]
 
-    return False
+    *_, (common_base, *_) = (
+        common_parent
+        for same_lvl_parent in zip(*parents_and_self)
+        if len(common_parent := set(same_lvl_parent)) == 1
+    )
 
+    for directory in (common_base, *common_base.parents):
+        if (directory / ".git").exists() or (
+            directory / "pyproject.toml"
+        ).is_file():
+            return directory
 
-@memoize
-def _get_ignore_patterns(path: pathlib.Path) -> pathspec.PathSpec:
-    git_ignore = path / ".gitignore"
-    if git_ignore.is_file():
-        with git_ignore.open() as f:
-            return pathspec.PathSpec.from_lines("gitwildmatch", f)
-
-    return _EMPTY_PATH_SPEC
-
-
-def is_ignored(path: str | os.PathLike) -> bool:
-    # Can't use pathlib.Path.resolve() here because we want to maintain
-    # symbolic links.
-    path = pathlib.Path(os.path.abspath(path))
-
-    for part in (path, *path.parents):
-        patterns = _get_ignore_patterns(part)
-        if patterns.match_file(path.relative_to(part)):
-            return True
-
-        if _is_project_root(part):
-            return False
-
-    return False
-
-
-def find_python_files(
-    patterns: Iterable[str | os.PathLike[str]],
-) -> Iterable[pathlib.Path]:
-    if not patterns:
-        patterns = ["."]
-
-    paths_set = set()
-    for pattern in patterns:
-        path = pathlib.Path(pattern)
-        if not path.is_dir():
-            subpaths = [path]
-        else:
-            subpaths = [
-                subpath
-                for subpath in path.glob("**/*.py")
-                if not is_ignored(subpath) and subpath.is_file()
-            ]
-
-        for subpath in sorted(subpaths):
-            if subpath not in paths_set:
-                paths_set.add(subpath)
-                yield subpath
+    return common_base

src/ssort/_main.py

@@ -3,8 +3,9 @@
 import re
 import sys
 
+from ssort._config import get_config_from_root
 from ssort._exceptions import UnknownEncodingError
-from ssort._files import find_python_files
+from ssort._files import find_project_root
 from ssort._ssort import ssort
 from ssort._utils import (
     detect_encoding,
@@ -42,19 +43,14 @@ def main():
     unsortable = 0
     unchanged = 0
 
-    for path in find_python_files(args.files):
+    root = find_project_root(args.files)
+    config = get_config_from_root(root)
+
+    for path in config.iterate_files_matching_patterns(args.files):
         errors = False
 
         try:
             original_bytes = path.read_bytes()
-        except FileNotFoundError:
-            sys.stderr.write(f"ERROR: {escape_path(path)} does not exist\n")
-            unsortable += 1
-            continue
-        except IsADirectoryError:
-            sys.stderr.write(f"ERROR: {escape_path(path)} is a directory\n")
-            unsortable += 1
-            continue
         except PermissionError:
             sys.stderr.write(f"ERROR: {escape_path(path)} is not readable\n")
             unsortable += 1