Refactor step 1: remove _utily.py

.github/workflows/ci.yaml

@@ -27,7 +27,7 @@ jobs:
         pip install -e .[test]
     - name: Run tests
       run: |
-        pytest -vv tests/
+        pytest -vv
 
   coverage:
     name: "Coverage"
@@ -46,7 +46,7 @@ jobs:
         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

@@ -17,12 +17,13 @@ classifiers = [
     "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
     "Programming Language :: Python",
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Topic :: Software Development :: Quality Assurance"
 ]
 dependencies = [
-    "pathspec >=0.9.0"
+    "tomli; python_version<'3.11'"
 ]
 description = "The python statement sorter"
 dynamic = [
@@ -60,9 +61,10 @@ profile = "black"
 [tool.mypy]
 exclude = "test_data/samples/*"
 
-[[tool.mypy.overrides]]
-ignore_missing_imports = true
-module = "pathspec"
+[tool.pytest.ini_options]
+testpaths = [
+    "tests"
+]
 
 [tool.setuptools]
 include-package-data = false
@@ -75,3 +77,10 @@ attr = "ssort.__version__"
 
 [tool.setuptools.packages.find]
 where = ["src"]
+
+[tool.ssort]
+extend_skip = [
+    ".pytest_cache",
+    "__pycache__",
+    "test_data"
+]

src/ssort/_ast.py

@@ -4,7 +4,7 @@
 import sys
 from typing import Iterable
 
-from ssort._utils import single_dispatch
+from ssort._single_dispatch import single_dispatch
 
 
 @single_dispatch

src/ssort/_bindings.py

@@ -5,7 +5,7 @@
 from typing import Iterable
 
 from ssort._ast import iter_child_nodes
-from ssort._utils import single_dispatch
+from ssort._single_dispatch import single_dispatch
 
 
 @single_dispatch

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,95 @@
 from __future__ import annotations
 
-import os
-import pathlib
-from typing import Iterable
-
-import pathspec
-
-from ssort._utils import memoize
-
-_EMPTY_PATH_SPEC = pathspec.PathSpec([])
-
-
-@memoize
-def _is_project_root(path: pathlib.Path) -> bool:
-    if path == path.root or path == path.parent:
-        return True
-
-    if (path / ".git").is_dir():
-        return True
-
-    return False
-
-
-@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
+import io
+import re
+import shlex
+import sys
+import tokenize
+from pathlib import Path
+
+from ssort._exceptions import UnknownEncodingError
+
+__all__ = [
+    "detect_encoding",
+    "detect_newline",
+    "escape_path",
+    "find_project_root",
+    "normalize_newlines",
+]
+
+
+_NEWLINE_RE = re.compile("(\r\n)|(\r)|(\n)")
+
+
+def current_working_dir():
+    return Path(".").resolve()
+
+
+def find_project_root(patterns):
+    all_patterns = [current_working_dir()]
+
+    if patterns:
+        all_patterns.extend(patterns)
+
+    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
+    ]
+
+    *_, (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
+
+    return common_base
+
+
+def escape_path(path):
+    """
+    Takes a `pathlib.Path` object and returns a string representation that can
+    be safely copied into the system shell.
+    """
+    if sys.platform == "win32":
+        # TODO
+        return str(path)
+    else:
+        return shlex.quote(str(path))
+
+
+def detect_encoding(bytestring):
+    """
+    Detect the encoding of a python source file based on "coding" comments, as
+    defined in [PEP 263](https://www.python.org/dev/peps/pep-0263/).
+    """
+    try:
+        encoding, _ = tokenize.detect_encoding(io.BytesIO(bytestring).readline)
+    except SyntaxError as exc:
+        raise UnknownEncodingError(
+            exc.msg, encoding=re.match("unknown encoding: (.*)", exc.msg)[1]
+        ) from exc
+    return encoding
+
+
+def detect_newline(text):
+    """
+    Detects the newline character used in a source file based on the first
+    occurence of '\\n', '\\r' or '\\r\\n'.
+    """
+    match = re.search(_NEWLINE_RE, text)
+    if match is None:
+        return "\n"
+    return match[0]
+
+
+def normalize_newlines(text):
+    """
+    Replaces all occurrences of '\r' and '\\r\\n' with \n.
+    """
+    return re.sub(_NEWLINE_RE, "\n", text)

src/ssort/_graphs.py

@@ -2,8 +2,6 @@
 
 from typing import Callable, Generic, Hashable, TypeVar
 
-from ssort._utils import sort_key_from_iter
-
 _T = TypeVar("_T", bound=Hashable)
 
 
@@ -140,6 +138,11 @@ def is_topologically_sorted(nodes: list[_T], graph: Graph[_T]) -> bool:
     return True
 
 
+def sort_key_from_iter(values):
+    index = {statement: index for index, statement in enumerate(values)}
+    return lambda value: index[value]
+
+
 def topological_sort(
     target: Graph[_T] | list[_T], /, *, graph: Graph[_T] | None = None
 ) -> list[_T]: