prettycsharp 1.0.0__py3-none-any.whl

prettycsharp/__init__.py

@@ -0,0 +1,9 @@
+"""An opinionated formatter for C#, in the spirit of Prettier."""
+
+from prettycsharp.formatter import FormattingError, format_source
+from prettycsharp.parsing import CSharpSyntaxError
+from prettycsharp.settings import Settings, SettingsError
+
+__version__ = "1.0.0"
+
+__all__ = ["CSharpSyntaxError", "FormattingError", "Settings", "SettingsError", "__version__", "format_source"]

prettycsharp/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from prettycsharp.cli import main
+
+sys.exit(main())

prettycsharp/cli.py

@@ -0,0 +1,250 @@
+"""The prettycsharp command line.
+
+    prettycsharp format PATH...   rewrite files in place     (alias --write)
+    prettycsharp check PATH...    exit 1 if any would change (alias --check)
+    prettycsharp diff PATH...     print a unified diff        (alias --diff)
+    prettycsharp PATH             print the formatted file to stdout
+    prettycsharp -                format stdin to stdout
+
+A PATH is a .cs file, a folder, a .csproj, or a .sln or .slnx. Exit status:
+0 when nothing needs to change, 1 when check or diff found a file that
+would change, 2 when a file could not be read, parsed or formatted, or the
+settings are wrong.
+"""
+
+from __future__ import annotations
+
+import argparse
+import difflib
+import os
+import shutil
+import sys
+import tempfile
+from collections.abc import Iterator, Sequence
+from pathlib import Path
+
+from prettycsharp import __version__, config, ignore, project
+from prettycsharp.config import settings_for
+from prettycsharp.formatter import FormattingError, format_source
+from prettycsharp.ignore import Ignorer
+from prettycsharp.parsing import CSharpSyntaxError
+from prettycsharp.project import compiled_files, lang_version_for, solution_projects
+from prettycsharp.settings import Settings, SettingsError
+
+_BOM = chr(0xFEFF)
+_MODES = {"format": "write", "check": "check", "diff": "diff"}
+
+
+class _Options:
+    def __init__(self, namespace: argparse.Namespace) -> None:
+        self.overrides: dict[str, object] = {}
+        for item in namespace.option or []:
+            key, sep, value = item.partition("=")
+            if not sep or not key.strip():
+                raise SettingsError(f"--option {item!r}: use KEY=VALUE")
+            self.overrides[key.strip()] = value.strip()
+        self.config: Path | None = namespace.config
+        self.no_ignore: bool = namespace.no_ignore
+        self.ignorer = Ignorer(respect_gitignore=not self.no_ignore, use_ignore_files=not self.no_ignore)
+        self.stdin_filepath: Path | None = namespace.stdin_filepath
+
+    def ignorer_for(self, target: Path) -> Ignorer:
+        """The skipping rules for a target, honouring its respect_gitignore setting."""
+        if self.no_ignore:
+            return self.ignorer
+        probe = target / "probe.cs" if target.is_dir() else target
+        settings = settings_for(probe, self.overrides, self.config)
+        return Ignorer(respect_gitignore=settings.respect_gitignore, use_ignore_files=True)
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+    # Settings, project and ignore files are cached for one run, not across runs.
+    config.clear_caches()
+    project.clear_caches()
+    ignore.clear_caches()
+    mode = "stdout"
+    if args and args[0] in _MODES:
+        mode = _MODES[args.pop(0)]
+
+    parser = argparse.ArgumentParser(prog="prettycsharp", description="Format C# source files.")
+    parser.add_argument("paths", nargs="+", help=".cs files, folders, .csproj or .sln files, or - for stdin")
+    parser.add_argument("--version", action="version", version=f"prettycsharp {__version__}")
+    flags = parser.add_mutually_exclusive_group()
+    flags.add_argument("--write", action="store_const", const="write", dest="mode", help="same as format")
+    flags.add_argument("--check", action="store_const", const="check", dest="mode", help="same as check")
+    flags.add_argument("--diff", action="store_const", const="diff", dest="mode", help="same as diff")
+    parser.add_argument("--config", type=Path, help="use this settings file instead of searching for one")
+    parser.add_argument(
+        "-o", "--option", action="append", metavar="KEY=VALUE", help="set one setting, over every settings file"
+    )
+    parser.add_argument("--no-ignore", action="store_true", help="do not skip files .gitignore or .prettycsharpignore lists")
+    parser.add_argument("--stdin-filepath", type=Path, help="the path stdin stands for, to find its settings")
+    namespace = parser.parse_args(args)
+    if namespace.mode is not None:
+        if mode != "stdout" and namespace.mode != mode:
+            parser.error("give a subcommand or a flag, not two different ones")
+        mode = namespace.mode
+
+    try:
+        options = _Options(namespace)
+        if namespace.config is not None and not namespace.config.is_file():
+            raise SettingsError(f"--config {namespace.config}: no such file")
+    except SettingsError as error:
+        print(f"prettycsharp: {error}", file=sys.stderr)
+        return 2
+
+    if namespace.paths == ["-"]:
+        return _run_stdin(options)
+    if "-" in namespace.paths:
+        parser.error("- (stdin) cannot be combined with other paths")
+
+    files, status = _collect(namespace.paths, options)
+    if mode == "stdout" and len(files) != 1:
+        if status:
+            return status
+        parser.error("printing to stdout takes exactly one file; use format, check or diff")
+    for path in files:
+        status = max(status, _run(path, mode, options))
+    return status
+
+
+def _collect(targets: Sequence[str], options: _Options) -> tuple[list[Path], int]:
+    files: list[Path] = []
+    seen: set[Path] = set()
+    status = 0
+    for target in targets:
+        path = Path(target)
+        if not path.exists():
+            print(f"{path}: no such file or folder", file=sys.stderr)
+            status = 2
+            continue
+        try:
+            ignorer = options.ignorer_for(path)
+        except SettingsError as error:
+            print(f"prettycsharp: {error}", file=sys.stderr)
+            status = 2
+            continue
+        for found in _expand(path, ignorer):
+            key = found.resolve()
+            if key not in seen:
+                seen.add(key)
+                files.append(found)
+    return files, status
+
+
+def _expand(path: Path, ignorer: Ignorer) -> Iterator[Path]:
+    suffix = path.suffix.lower()
+    if path.is_dir():
+        for folder, subfolders, names in os.walk(path):
+            here = Path(folder)
+            subfolders[:] = sorted(s for s in subfolders if not ignorer.skip_folder(here / s))
+            for name in sorted(names):
+                candidate = here / name
+                if name.lower().endswith(".cs") and not ignorer.skip_file(candidate):
+                    yield candidate
+    elif suffix == ".csproj":
+        for found in compiled_files(path):
+            if not ignorer.skip_file(found):
+                yield found
+    elif suffix in (".sln", ".slnx"):
+        for project in solution_projects(path):
+            if project.is_file():
+                yield from _expand(project, ignorer)
+    elif not ignorer.skip_file(path):
+        yield path
+
+
+def _settings(path: Path, options: _Options) -> Settings:
+    return settings_for(path, options.overrides, options.config)
+
+
+def _format_text(text: str, path: Path, settings: Settings) -> str:
+    """Format text read from ``path``, keeping or changing its byte order mark."""
+    bom = _BOM if text.startswith(_BOM) else ""
+    lang = lang_version_for(path) if settings.lang_version == "auto" else None
+    formatted = format_source(text[len(bom) :], settings, lang_version=lang)
+    if settings.charset == "utf-8-bom":
+        bom = _BOM
+    elif settings.charset == "utf-8":
+        bom = ""
+    return bom + formatted
+
+
+def _run_stdin(options: _Options) -> int:
+    path = options.stdin_filepath or Path("stdin.cs")
+    text = sys.stdin.read()
+    if options.stdin_filepath is not None and options.ignorer.skip_file(path):
+        sys.stdout.write(text)
+        return 0
+    try:
+        formatted = _format_text(text, path, _settings(path, options))
+    except (CSharpSyntaxError, FormattingError, SettingsError) as error:
+        print(f"{path}: {error}; not formatted", file=sys.stderr)
+        return 2
+    sys.stdout.write(formatted.lstrip(_BOM))
+    return 0
+
+
+def _run(path: Path, mode: str, options: _Options) -> int:
+    try:
+        settings = _settings(path, options)
+    except SettingsError as error:
+        print(f"prettycsharp: {error}", file=sys.stderr)
+        return 2
+    try:
+        # newline="" keeps the file's own line endings.
+        with path.open(encoding="utf-8", newline="") as handle:
+            original = handle.read()
+    except (OSError, UnicodeDecodeError) as error:
+        print(f"{path}: cannot read: {error}", file=sys.stderr)
+        return 2
+
+    try:
+        formatted = _format_text(original, path, settings)
+    except CSharpSyntaxError as error:
+        print(f"{path}: {error}; not formatted", file=sys.stderr)
+        return 2
+    except FormattingError as error:
+        print(f"{path}: not formatted: {error}", file=sys.stderr)
+        return 2
+
+    if mode == "stdout":
+        sys.stdout.write(formatted.lstrip(_BOM))
+        return 0
+    if formatted == original:
+        return 0
+    if mode == "write":
+        try:
+            _replace(path, formatted)
+        except OSError as error:
+            print(f"{path}: cannot write: {error}", file=sys.stderr)
+            return 2
+        print(f"formatted {path}")
+        return 0
+    if mode == "diff":
+        sys.stdout.writelines(
+            difflib.unified_diff(
+                original.splitlines(keepends=True),
+                formatted.splitlines(keepends=True),
+                fromfile=str(path),
+                tofile=str(path),
+            )
+        )
+    else:
+        print(f"would format {path}")
+    return 1
+
+
+def _replace(path: Path, text: str) -> None:
+    # Write beside the file, then swap it in, so a failed write never leaves
+    # the original half-written. The new file keeps the original's mode.
+    handle, temporary = tempfile.mkstemp(dir=path.parent, prefix=f".{path.name}.", suffix=".tmp")
+    try:
+        with os.fdopen(handle, "w", encoding="utf-8", newline="") as stream:
+            stream.write(text)
+        shutil.copymode(path, temporary)
+        os.replace(temporary, path)
+    except BaseException:
+        Path(temporary).unlink(missing_ok=True)
+        raise

prettycsharp/config.py

@@ -0,0 +1,263 @@
+"""Finding the settings for a source file.
+
+Settings come from, highest precedence first: the command line, the
+nearest ``.prettycsharp.toml`` or ``pyproject.toml`` with a
+``[tool.prettycsharp]`` table, the standard keys of ``.editorconfig``, and
+the defaults in ``Settings``.
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from collections.abc import Mapping
+from functools import cache
+from pathlib import Path
+
+from prettycsharp.settings import Settings, SettingsError
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:  # pragma: no cover - exercised on Python 3.10 only
+    import tomli as tomllib
+
+CONFIG_NAME = ".prettycsharp.toml"
+
+
+def settings_for(path: Path, overrides: Mapping[str, object] | None = None, config_file: Path | None = None) -> Settings:
+    """The settings for the source file at ``path``."""
+    directory = path.resolve().parent
+    settings = Settings()
+    settings = settings.with_values(editorconfig_values(path.resolve()), ".editorconfig")
+    if config_file is not None:
+        values, source = read_config(config_file.resolve())
+    else:
+        found = find_config(directory)
+        values, source = ({}, "") if found is None else read_config(found)
+    if values:
+        settings = settings.with_values(values, source)
+    if overrides:
+        settings = settings.with_values(overrides, "command line")
+    return settings
+
+
+@cache
+def find_config(directory: Path) -> Path | None:
+    """The nearest .prettycsharp.toml, or pyproject.toml with our table, at or above ``directory``."""
+    for folder in (directory, *directory.parents):
+        candidate = folder / CONFIG_NAME
+        if candidate.is_file():
+            return candidate
+        pyproject = folder / "pyproject.toml"
+        if pyproject.is_file() and "prettycsharp" in _tool_tables(_load_toml(pyproject)):
+            return pyproject
+    return None
+
+
+def _tool_tables(data: dict[str, object]) -> dict[str, object]:
+    tool = data.get("tool", {})
+    return tool if isinstance(tool, dict) else {}
+
+
+@cache
+def read_config(path: Path) -> tuple[dict[str, object], str]:
+    data = _load_toml(path)
+    table: object = _tool_tables(data).get("prettycsharp", {}) if path.name == "pyproject.toml" else data
+    if not isinstance(table, dict):
+        raise SettingsError(f"{path}: [tool.prettycsharp] must be a table")
+    return dict(table), str(path)
+
+
+def _load_toml(path: Path) -> dict[str, object]:
+    try:
+        with path.open("rb") as handle:
+            return tomllib.load(handle)
+    except tomllib.TOMLDecodeError as error:
+        raise SettingsError(f"{path}: {error}") from None
+    except OSError as error:
+        raise SettingsError(f"{path}: cannot read: {error}") from None
+
+
+# .editorconfig ------------------------------------------------------------
+
+
+def editorconfig_values(path: Path) -> dict[str, object]:
+    """Our settings from the .editorconfig files that apply to ``path``."""
+    files: list[Path] = []
+    for folder in path.parents:
+        candidate = folder / ".editorconfig"
+        if candidate.is_file():
+            files.append(candidate)
+            if _parse_editorconfig(candidate)[0]:
+                break
+    raw: dict[str, str] = {}
+    # The file nearest the source wins, so apply the farthest first.
+    for config in reversed(files):
+        _, sections = _parse_editorconfig(config)
+        relative = path.relative_to(config.parent).as_posix()
+        for pattern, values in sections:
+            if _section_matches(pattern, relative):
+                raw.update(values)
+    return _map_editorconfig(raw)
+
+
+@cache
+def _parse_editorconfig(path: Path) -> tuple[bool, tuple[tuple[str, dict[str, str]], ...]]:
+    root = False
+    sections: list[tuple[str, dict[str, str]]] = []
+    try:
+        lines = path.read_text(encoding="utf-8-sig").splitlines()
+    except (OSError, UnicodeDecodeError):
+        return False, ()
+    for line in lines:
+        text = line.strip()
+        if not text or text[0] in "#;":
+            continue
+        if text.startswith("[") and text.endswith("]"):
+            sections.append((text[1:-1], {}))
+            continue
+        if "=" not in text:
+            continue
+        key, value = (part.strip() for part in text.split("=", 1))
+        key = key.lower()
+        if not sections:
+            if key == "root":
+                root = value.lower() == "true"
+            continue
+        sections[-1][1][key] = value
+    return root, tuple(sections)
+
+
+def _section_matches(pattern: str, relative: str) -> bool:
+    if "/" not in pattern:
+        pattern = "**/" + pattern
+    elif pattern.startswith("/"):
+        pattern = pattern[1:]
+    return re.fullmatch(_editorconfig_regex(pattern), relative) is not None
+
+
+@cache
+def _editorconfig_regex(pattern: str) -> str:
+    out: list[str] = []
+    i = 0
+    depth = 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 + 1)
+            if end < 0:
+                out.append(re.escape(c))
+            else:
+                body = pattern[i + 1 : end]
+                negate = body.startswith("!")
+                body = body[1:] if negate else body
+                out.append("[" + ("^" if negate else "") + body.replace("\\", "\\\\") + "]")
+                i = end + 1
+                continue
+        elif c == "{":
+            end = pattern.find("}", i)
+            body = pattern[i + 1 : end] if end > 0 else ""
+            numbers = re.fullmatch(r"(-?\d+)\.\.(-?\d+)", body)
+            if end > 0 and numbers:
+                low, high = sorted(int(n) for n in numbers.groups())
+                out.append("(?:" + "|".join(str(n) for n in range(low, high + 1)) + ")")
+                i = end + 1
+                continue
+            if end > 0 and "," in body:
+                out.append("(?:")
+                depth += 1
+            else:
+                out.append(re.escape(c))
+        elif c == "," and depth:
+            out.append("|")
+        elif c == "}" and depth:
+            out.append(")")
+            depth -= 1
+        else:
+            out.append(re.escape(c))
+        i += 1
+    return "".join(out)
+
+
+def _map_editorconfig(raw: Mapping[str, str]) -> dict[str, object]:
+    values: dict[str, object] = {}
+
+    def text(key: str) -> str | None:
+        value = raw.get(key)
+        if value is None:
+            return None
+        # Roslyn options can carry a severity: true:warning.
+        return value.split(":")[0].strip().lower()
+
+    style = text("indent_style")
+    if style in ("space", "tab"):
+        values["indent_style"] = style
+    size = text("indent_size")
+    if size is not None and size.isdigit() and int(size) > 0:
+        values["indent_size"] = int(size)
+    elif size == "tab":
+        width = text("tab_width")
+        if width is not None and width.isdigit() and int(width) > 0:
+            values["indent_size"] = int(width)
+    length = text("max_line_length")
+    if length is not None and length.isdigit():
+        values["max_line_length"] = int(length)
+    elif length == "off":
+        values["max_line_length"] = 0
+    eol = text("end_of_line")
+    if eol in ("lf", "crlf", "cr"):
+        values["end_of_line"] = eol
+    charset = text("charset")
+    if charset in ("utf-8", "utf-8-bom"):
+        values["charset"] = charset
+    for key in ("insert_final_newline", "trim_trailing_whitespace"):
+        flag = text(key)
+        if flag in ("true", "false"):
+            values[key] = flag == "true"
+    brace = text("csharp_new_line_before_open_brace")
+    if brace == "all":
+        values["brace_style"] = "allman"
+    elif brace == "none":
+        values["brace_style"] = "kr"
+    if any(text(f"csharp_new_line_before_{k}") == "false" for k in ("else", "catch", "finally")):
+        values["continuation_keywords"] = "same_line"
+    if text("dotnet_sort_system_directives_first") == "true":
+        values["using_order"] = "system_first"
+    namespaces = text("csharp_style_namespace_declarations")
+    if namespaces == "file_scoped":
+        values["namespace_style"] = "file_scoped"
+    elif namespaces == "block_scoped":
+        values["namespace_style"] = "block"
+    braces = text("csharp_prefer_braces")
+    if braces == "true":
+        values["braces"] = "always"
+    elif braces == "when_multiline":
+        values["braces"] = "single_line_only"
+    elif braces == "false":
+        values["braces"] = "preserve"
+    order = raw.get("csharp_preferred_modifier_order")
+    if order:
+        values["modifier_order"] = [m.strip() for m in order.split(":")[0].split(",") if m.strip()]
+    return values
+
+
+def clear_caches() -> None:
+    find_config.cache_clear()
+    read_config.cache_clear()
+    _parse_editorconfig.cache_clear()