prettycsharp 1.0.0__py3-none-any.whl

prettycsharp/ignore.py

@@ -0,0 +1,184 @@
+"""Deciding which files to skip.
+
+Skipped always: ``bin/`` and ``obj/`` folders, hidden folders, and generated
+files (``*.g.cs``, ``*.Designer.cs`` and the like, and files marked
+``<auto-generated``). Skipped by pattern: ``.gitignore`` files inside a git
+repository and ``.prettycsharpignore`` files anywhere above a file, both in
+gitignore syntax, where the last matching pattern wins.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from functools import cache
+from pathlib import Path
+
+IGNORE_FILE = ".prettycsharpignore"
+_GENERATED_SUFFIXES = (".g.cs", ".g.i.cs", ".designer.cs", ".generated.cs", ".assemblyattributes.cs")
+_SKIPPED_FOLDERS = frozenset({"bin", "obj"})
+
+
+def glob_regex(pattern: str) -> str:
+    """A regular expression for a gitignore-style glob, matched against a relative path."""
+    out: list[str] = []
+    i = 0
+    while i < len(pattern):
+        c = pattern[i]
+        if c == "\\" and i + 1 < len(pattern):
+            out.append(re.escape(pattern[i + 1]))
+            i += 2
+            continue
+        if c == "*":
+            if pattern[i : i + 3] == "**/":
+                out.append("(?:.*/)?")
+                i += 3
+                continue
+            if pattern[i : i + 2] == "**":
+                out.append(".*")
+                i += 2
+                continue
+            out.append("[^/]*")
+        elif c == "?":
+            out.append("[^/]")
+        elif c == "[":
+            end = pattern.find("]", i + 2)
+            if end < 0:
+                out.append(re.escape(c))
+            else:
+                body = pattern[i + 1 : end]
+                negate = body[:1] in ("!", "^")
+                body = body[1:] if negate else body
+                out.append("[" + ("^" if negate else "") + body.replace("\\", "\\\\") + "]")
+                i = end + 1
+                continue
+        else:
+            out.append(re.escape(c))
+        i += 1
+    return "".join(out)
+
+
+@dataclass(frozen=True)
+class _Rule:
+    regex: re.Pattern[str]
+    negated: bool
+    directory_only: bool
+
+
+@cache
+def _rules(path: Path) -> tuple[_Rule, ...]:
+    try:
+        lines = path.read_text(encoding="utf-8-sig", errors="replace").splitlines()
+    except OSError:
+        return ()
+    rules: list[_Rule] = []
+    for line in lines:
+        text = line.rstrip()
+        if text.endswith("\\") and line.endswith(" "):
+            text += " "
+        if not text or text.startswith("#"):
+            continue
+        negated = text.startswith("!")
+        if negated:
+            text = text[1:]
+        elif text.startswith("\\"):
+            text = text[1:]
+        directory_only = text.endswith("/")
+        text = text.rstrip("/")
+        if not text:
+            continue
+        anchored = "/" in text
+        text = text.lstrip("/")
+        regex = glob_regex(text)
+        if not anchored:
+            regex = "(?:.*/)?" + regex
+        rules.append(_Rule(re.compile(regex), negated, directory_only))
+    return tuple(rules)
+
+
+@cache
+def git_root(directory: Path) -> Path | None:
+    for folder in (directory, *directory.parents):
+        if (folder / ".git").exists():
+            return folder
+    return None
+
+
+class Ignorer:
+    def __init__(self, respect_gitignore: bool = True, use_ignore_files: bool = True) -> None:
+        self.respect_gitignore = respect_gitignore
+        self.use_ignore_files = use_ignore_files
+
+    def skip_folder(self, folder: Path) -> bool:
+        name = folder.name
+        if name.lower() in _SKIPPED_FOLDERS or (name.startswith(".") and name not in (".", "..")):
+            return True
+        return self._matched(folder.resolve(), is_dir=True)
+
+    def skip_file(self, path: Path) -> bool:
+        resolved = path.resolve()
+        if resolved.name.lower().endswith(_GENERATED_SUFFIXES):
+            return True
+        for parent in resolved.parents:
+            if parent.name.lower() in _SKIPPED_FOLDERS:
+                return True
+        if self._matched(resolved, is_dir=False):
+            return True
+        # A folder above the file may be ignored too.
+        for parent in resolved.parents:
+            if parent == parent.parent:
+                break
+            if self._matched(parent, is_dir=True):
+                return True
+        return is_generated(resolved)
+
+    def _matched(self, path: Path, *, is_dir: bool) -> bool:
+        ignored = False
+        for owner, rules in self._rule_sets(path.parent):
+            try:
+                relative = path.relative_to(owner).as_posix()
+            except ValueError:
+                continue
+            for rule in rules:
+                if rule.directory_only and not is_dir:
+                    continue
+                if rule.regex.fullmatch(relative):
+                    ignored = not rule.negated
+        return ignored
+
+    def _rule_sets(self, directory: Path) -> list[tuple[Path, tuple[_Rule, ...]]]:
+        sets: list[tuple[Path, tuple[_Rule, ...]]] = []
+        root = git_root(directory) if self.respect_gitignore else None
+        for folder in reversed((directory, *directory.parents)):
+            if self.respect_gitignore and root is not None and (folder == root or root in folder.parents):
+                gitignore = folder / ".gitignore"
+                if gitignore.is_file():
+                    sets.append((folder, _rules(gitignore)))
+            if self.use_ignore_files:
+                own = folder / IGNORE_FILE
+                if own.is_file():
+                    sets.append((folder, _rules(own)))
+        return sets
+
+
+def is_generated(path: Path) -> bool:
+    """Whether the file says it was generated, in a comment near its top."""
+    try:
+        with path.open("r", encoding="utf-8-sig", errors="replace") as handle:
+            head = handle.read(2048)
+    except OSError:
+        return False
+    for line in head.splitlines():
+        text = line.strip()
+        if not text:
+            continue
+        if not (text.startswith("//") or text.startswith("/*") or text.startswith("*")):
+            return False
+        if "<auto-generated" in text.lower():
+            return True
+    return False
+
+
+def clear_caches() -> None:
+    _rules.cache_clear()
+    git_root.cache_clear()

prettycsharp/parsing.py

@@ -0,0 +1,53 @@
+"""Parsing C# source into a tree-sitter concrete syntax tree."""
+
+from __future__ import annotations
+
+import tree_sitter_c_sharp
+from tree_sitter import Language, Node, Parser, Tree
+
+_LANGUAGE = Language(tree_sitter_c_sharp.language())
+
+
+class CSharpSyntaxError(ValueError):
+    """The source does not parse as C#, so it is not formatted.
+
+    ``line`` and ``column`` are 1-based and point at the first error the
+    parser found.
+    """
+
+    def __init__(self, line: int, column: int, hint: str = "") -> None:
+        super().__init__(f"syntax error at line {line}, column {column}{hint}")
+        self.line = line
+        self.column = column
+
+
+_CONDITIONAL_HINT = (
+    " (the parser reads every #if branch as code, so a declaration or statement"
+    " split between branches cannot be parsed)"
+)
+
+
+def parse(source: str) -> Tree:
+    """Parse ``source`` and return its tree, or raise CSharpSyntaxError."""
+    tree = Parser(_LANGUAGE).parse(source.encode("utf-8"))
+    if tree.root_node.has_error:
+        node = _first_error(tree.root_node)
+        row, column = node.start_point if node is not None else (0, 0)
+        hint = _CONDITIONAL_HINT if "#if" in source else ""
+        raise CSharpSyntaxError(row + 1, column + 1, hint)
+    return tree
+
+
+def _first_error(root: Node) -> Node | None:
+    # An ERROR node often wraps a whole declaration, so follow the first
+    # erroneous child down to the innermost error, which is where the
+    # problem is. A loop, so deep nesting cannot exhaust the Python stack.
+    found = None
+    node = root
+    while True:
+        if node.is_error or node.is_missing:
+            found = node
+        child = next((c for c in node.children if c.is_error or c.is_missing or c.has_error), None)
+        if child is None:
+            return found
+        node = child

prettycsharp/printer/__init__.py

@@ -0,0 +1,28 @@
+"""The C# printer: from the syntax model to formatted text."""
+
+from __future__ import annotations
+
+from prettycsharp.doc import print_doc
+from prettycsharp.printer.declarations import Declarations
+from prettycsharp.settings import Settings
+from prettycsharp.syntax import SourceFile
+
+
+class CSharpPrinter(Declarations):
+    """Every handler, from the file down to a token."""
+
+
+def eol_for(settings: Settings, file: SourceFile) -> str:
+    return {"lf": "\n", "crlf": "\r\n", "cr": "\r"}.get(settings.end_of_line, file.eol)
+
+
+def print_file(file: SourceFile, settings: Settings, lang_version: float) -> str:
+    printer = CSharpPrinter(settings, file, lang_version)
+    doc = printer.print(file.root)
+    indent_width = settings.indent_size
+    eol = eol_for(settings, file)
+    text = print_doc(doc, settings.width, settings.indent_unit, indent_width, eol)
+    text = text.lstrip("\r\n")
+    if settings.insert_final_newline and text:
+        text = text.rstrip("\r\n") + eol
+    return text