beautify-bash 2.0.0__py3-none-any.whl

beautify_bash/__init__.py

@@ -0,0 +1,43 @@
+"""beautify_bash - a code formatter for bash and zsh scripts.
+
+Originally written by Paul Lutus; revived with a package layout, a Typer
+command line interface and dialect support.
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _version
+
+from .beautifier import (
+    Beautifier,
+    BeautifyBash,
+    FormatError,
+    FormatResult,
+    beautify_string,
+)
+from .dialects import BASH, DIALECTS, ZSH, Dialect, detect_dialect, get_dialect
+
+try:
+    #: Single source of truth: the ``version`` field in ``pyproject.toml``.
+    __version__ = _version("beautify-bash")
+except PackageNotFoundError:  # pragma: no cover - running from an unbuilt tree
+    __version__ = "0.0.0+unknown"
+#: Historical spelling of the version constant.
+PVERSION = __version__
+
+__all__ = [
+    "BASH",
+    "DIALECTS",
+    "PVERSION",
+    "ZSH",
+    "Beautifier",
+    "BeautifyBash",
+    "Dialect",
+    "FormatError",
+    "FormatResult",
+    "__version__",
+    "beautify_string",
+    "detect_dialect",
+    "get_dialect",
+]

beautify_bash/__main__.py

@@ -0,0 +1,6 @@
+"""Allow ``python -m beautify_bash``."""
+
+from .cli import app
+
+if __name__ == "__main__":
+    app()

beautify_bash/beautifier.py

@@ -0,0 +1,305 @@
+"""The line-based shell script indenter.
+
+The algorithm walks the script one line at a time, keeps a running indentation
+level, and re-emits each line stripped and re-indented.  Regions where
+re-indenting would change the meaning of the script (here-documents and
+multi-line quotes) are passed through verbatim.
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import IO, List, Optional, Tuple, Union
+
+from .dialects import (
+    DEFAULT_DIALECT,
+    Dialect,
+    command_position_pattern,
+    detect_dialect,
+)
+
+__all__ = [
+    "Beautifier",
+    "BeautifyBash",
+    "FormatError",
+    "FormatResult",
+    "beautify_string",
+]
+
+PathLike = Union[str, "Path"]
+
+# Quoted spans are blanked out before keyword counting so that a `done` inside
+# a string cannot dedent the script.
+_SINGLE_QUOTED = re.compile(r"'.*?'")
+_DOUBLE_QUOTED = re.compile(r'".*?"')
+_BACKTICKED = re.compile(r"`.*?`")
+_ESCAPED_BACKTICK_QUOTE = re.compile(r"\\`.*?'")
+_ESCAPED_CHAR = re.compile(r"\\.")
+_COMMENT = re.compile(r"(\A|\s)(#.*)")
+_HERE_DOC_START = re.compile(r"(?<!<)<<(?!<)-?")
+# The tag may be quoted with '…', "…" or a leading backslash (`<<\EOF`), each
+# of which suppresses expansion inside the body.  The lookarounds keep the
+# here-string operator `<<<` and the arithmetic left shift `1 << 2` out.
+_HERE_DOC_TAG = re.compile(
+    r""".*(?<!<)<<(?!<)(?P<dash>-?)\s*(?:\\)?['"]?(?P<tag>[A-Za-z_][\w.-]*)['"]?.*"""
+)
+_OPEN_BRACKETS = re.compile(r"[{(\[]")
+_CLOSE_BRACKETS = re.compile(r"[})\]]")
+_CASE_KEYWORD = command_position_pattern("case")
+_ESAC_KEYWORD = command_position_pattern("esac")
+_CASE_PATTERN = re.compile(r"\A[^(]*\)")
+_CASE_BREAK = re.compile(r";;")
+_QUOTE_START = re.compile(r"""(\A|\s)('|")""")
+
+
+@dataclass(frozen=True)
+class FormatError:
+    """A syntax problem noticed while indenting."""
+
+    line: int
+    message: str
+
+    def render(self, path: str = "") -> str:
+        where = f"File {path}: " if path else ""
+        return f"{where}error: {self.message} in line {self.line}."
+
+
+@dataclass
+class FormatResult:
+    """Outcome of formatting one script."""
+
+    text: str
+    errors: List[FormatError] = field(default_factory=list)
+    dialect: Dialect = DEFAULT_DIALECT
+
+    @property
+    def ok(self) -> bool:
+        return not self.errors
+
+    def __str__(self) -> str:  # pragma: no cover - convenience only
+        return self.text
+
+
+class Beautifier:
+    """Re-indent shell scripts.
+
+    Args:
+        indent_char: the character used for one unit of indentation.
+        indent_size: how many ``indent_char`` per level.
+        dialect: the shell dialect to assume when none is detected.
+        backup: whether :meth:`beautify_file` keeps a ``file~`` copy.
+    """
+
+    def __init__(
+        self,
+        indent_char: str = " ",
+        indent_size: int = 2,
+        dialect: Dialect = DEFAULT_DIALECT,
+        backup: bool = True,
+    ) -> None:
+        if indent_size < 0:
+            raise ValueError("indent_size must not be negative")
+        if len(indent_char) != 1:
+            raise ValueError("indent_char must be exactly one character")
+        self.indent_char = indent_char
+        self.indent_size = indent_size
+        self.dialect = dialect
+        self.backup = backup
+
+    # -- backwards compatible aliases for the 1.x attribute names ----------
+    @property
+    def tab_str(self) -> str:
+        return self.indent_char
+
+    @tab_str.setter
+    def tab_str(self, value: str) -> None:
+        self.indent_char = value
+
+    @property
+    def tab_size(self) -> int:
+        return self.indent_size
+
+    @tab_size.setter
+    def tab_size(self, value: int) -> None:
+        self.indent_size = value
+
+    # -- file helpers ------------------------------------------------------
+    def read_file(self, path: PathLike) -> str:
+        return Path(path).read_text(encoding="utf-8")
+
+    def write_file(self, path: PathLike, data: str) -> None:
+        Path(path).write_text(data, encoding="utf-8")
+
+    # -- core --------------------------------------------------------------
+    def format(
+        self,
+        data: str,
+        dialect: Optional[Dialect] = None,
+    ) -> FormatResult:
+        """Indent ``data`` and report any syntax problems found on the way."""
+        active = dialect or self.dialect
+        indent_unit = self.indent_char * self.indent_size
+        level = 0
+        case_stack: List[int] = []
+        errors: List[FormatError] = []
+        output: List[str] = []
+
+        in_here_doc = False
+        here_tag = ""
+        here_doc_dash = False
+        in_ext_quote = False
+        defer_ext_quote = False
+        ext_quote_char = ""
+
+        line_no = 0
+        for line_no, raw in enumerate(data.split("\n"), start=1):
+            record = raw.rstrip()
+            stripped = record.strip()
+            test = self._strip_literals(stripped)
+
+            if in_here_doc:
+                # Here-doc bodies are data: emit them byte for byte.
+                output.append(raw)
+                # A `<<-` terminator may be indented, a plain `<<` one may not.
+                terminator = raw.strip() if here_doc_dash else raw
+                if terminator == here_tag:
+                    in_here_doc = False
+                continue
+
+            # The line that *opens* a here-doc is still ordinary code, so note
+            # the tag now and switch over once the line has been emitted.
+            opens_here_doc = False
+            if _HERE_DOC_START.search(test):
+                match = _HERE_DOC_TAG.match(stripped)
+                if match is not None and match.group("tag"):
+                    here_tag = match.group("tag")
+                    here_doc_dash = bool(match.group("dash"))
+                    opens_here_doc = True
+
+            # A quote left open on a previous line makes this line string data.
+            closes_ext_quote = False
+            if in_ext_quote:
+                if ext_quote_char in test:
+                    # Keep whatever follows the closing quote for counting.
+                    test = test.split(ext_quote_char, 1)[1]
+                    in_ext_quote = False
+                    closes_ext_quote = True
+            elif _QUOTE_START.search(test):
+                # The quote only takes effect after this line is emitted.
+                defer_ext_quote = True
+                ext_quote_char = re.sub(r""".*(['"]).*""", r"\1", test, count=1)
+                test = test.split(ext_quote_char, 1)[0]
+
+            if in_ext_quote:
+                # Wholly inside a multi-line string: emit byte for byte.
+                output.append(raw)
+            else:
+                opened = active.count_open(test) + len(_OPEN_BRACKETS.findall(test))
+                closed = active.count_close(test) + len(_CLOSE_BRACKETS.findall(test))
+
+                if _ESAC_KEYWORD.search(test):
+                    if case_stack:
+                        closed += case_stack.pop()
+                    else:
+                        errors.append(FormatError(line_no, '"esac" before "case"'))
+
+                if case_stack:
+                    # `pattern)` inside a case opens a branch; `;;` closes it.
+                    if _CASE_PATTERN.search(test):
+                        closed -= 2  # undo the `)` counted above
+                        case_stack[-1] += 1
+                    if _CASE_BREAK.search(test):
+                        closed += 1
+                        case_stack[-1] -= 1
+                    hanging = 0
+                    net = opened - closed
+                else:
+                    net = opened - closed
+                    hangs = active.is_hanging(test) or (
+                        net == 0 and active.starts_with_close(test)
+                    )
+                    hanging = -1 if hangs else 0
+
+                level += min(net, 0)
+                if closes_ext_quote:
+                    # The leading whitespace of this line is string content.
+                    output.append(record)
+                elif stripped:
+                    output.append((indent_unit * max(0, level + hanging)) + stripped)
+                else:
+                    output.append("")
+                level += max(net, 0)
+
+            if defer_ext_quote:
+                in_ext_quote = True
+                defer_ext_quote = False
+            if _CASE_KEYWORD.search(test):
+                case_stack.append(0)
+            if opens_here_doc:
+                in_here_doc = True
+
+        if level != 0:
+            errors.append(FormatError(line_no, f"indent/outdent mismatch: {level}"))
+        return FormatResult("\n".join(output), errors, active)
+
+    @staticmethod
+    def _strip_literals(stripped_record: str) -> str:
+        """Blank out quotes, escapes and comments before keyword counting."""
+        test = _SINGLE_QUOTED.sub("", stripped_record)
+        test = _DOUBLE_QUOTED.sub("", test)
+        test = _BACKTICKED.sub("", test)
+        test = _ESCAPED_BACKTICK_QUOTE.sub("", test)
+        test = _ESCAPED_CHAR.sub("", test)
+        return _COMMENT.sub("", test, count=1)
+
+    # -- 1.x compatible entry points --------------------------------------
+    def beautify_string(self, data: str, path: str = "") -> Tuple[str, bool]:
+        """Format ``data``; return ``(text, had_error)`` as version 1.x did."""
+        result = self.format(data, detect_dialect(data, path, self.dialect))
+        for error in result.errors:
+            sys.stderr.write(error.render(path) + "\n")
+        return result.text, not result.ok
+
+    def beautify_file(
+        self,
+        path: PathLike,
+        stdin: Optional[IO[str]] = None,
+        stdout: Optional[IO[str]] = None,
+    ) -> bool:
+        """Format a file in place (or stdin to stdout for ``-``).
+
+        Returns ``True`` when a syntax problem was reported.
+        """
+        if str(path) == "-":
+            data = (stdin or sys.stdin).read()
+            text, error = self.beautify_string(data, "(stdin)")
+            (stdout or sys.stdout).write(text)
+            return error
+        data = self.read_file(path)
+        text, error = self.beautify_string(data, str(path))
+        if data != text:
+            if self.backup:
+                self.write_file(f"{path}~", data)
+            self.write_file(path, text)
+        return error
+
+
+#: Historical name kept so ``from beautify_bash import BeautifyBash`` keeps working.
+BeautifyBash = Beautifier
+
+
+def beautify_string(
+    data: str,
+    dialect: Optional[Dialect] = None,
+    indent_char: str = " ",
+    indent_size: int = 2,
+) -> FormatResult:
+    """Format ``data`` in one call.
+
+    When ``dialect`` is omitted it is detected from the script's shebang.
+    """
+    beautifier = Beautifier(indent_char=indent_char, indent_size=indent_size)
+    return beautifier.format(data, dialect or detect_dialect(data))

beautify_bash/cli.py

@@ -0,0 +1,190 @@
+"""Command line interface built on Typer."""
+
+from __future__ import annotations
+
+import difflib
+import sys
+from enum import Enum
+from pathlib import Path
+from typing import List, Optional
+
+import typer
+
+from . import __version__
+from .beautifier import Beautifier
+from .dialects import DEFAULT_DIALECT, Dialect, detect_dialect, get_dialect
+
+__all__ = ["DialectChoice", "app", "main"]
+
+
+class DialectChoice(str, Enum):
+    """``--dialect`` values; ``auto`` inspects the shebang and file name."""
+
+    auto = "auto"
+    bash = "bash"
+    zsh = "zsh"
+
+
+app = typer.Typer(
+    add_completion=True,
+    context_settings={"help_option_names": ["-h", "--help"]},
+    help="Re-indent bash and zsh scripts.",
+)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"beautify-bash {__version__}")
+        raise typer.Exit
+
+
+def _resolve_dialect(choice: DialectChoice, data: str, name: str) -> Dialect:
+    if choice is DialectChoice.auto:
+        return detect_dialect(data, name, DEFAULT_DIALECT)
+    return get_dialect(choice.value)
+
+
+def _diff(before: str, after: str, name: str) -> str:
+    return "".join(
+        difflib.unified_diff(
+            before.splitlines(keepends=True),
+            after.splitlines(keepends=True),
+            fromfile=f"a/{name}",
+            tofile=f"b/{name}",
+        )
+    )
+
+
+@app.command(no_args_is_help=True)
+def main(
+    files: List[str] = typer.Argument(
+        ...,
+        metavar="FILES...",
+        help='Scripts to format; "-" reads standard input.',
+    ),
+    output: Optional[str] = typer.Option(
+        None,
+        "--output",
+        "-o",
+        metavar="PATH",
+        help='Write the result to PATH ("-" for stdout) instead of stdout.',
+    ),
+    write: bool = typer.Option(
+        False,
+        "--write",
+        "-w",
+        help="Rewrite each input file in place instead of printing.",
+    ),
+    indent_size: int = typer.Option(
+        2, "--indent", "-i", min=0, help="Indentation width per level."
+    ),
+    use_tabs: bool = typer.Option(
+        False, "--tabs/--spaces", help="Indent with tab characters."
+    ),
+    dialect: DialectChoice = typer.Option(
+        DialectChoice.auto, "--dialect", "-d", help="Shell dialect to assume."
+    ),
+    check: bool = typer.Option(
+        False, "--check", help="Write nothing; exit 1 if a file would change."
+    ),
+    show_diff: bool = typer.Option(
+        False, "--diff", help="Print a unified diff instead of the result."
+    ),
+    backup: bool = typer.Option(
+        True, "--backup/--no-backup", help='With -w, keep the original as "FILE~".'
+    ),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Suppress progress notes."),
+    version: Optional[bool] = typer.Option(
+        None,
+        "--version",
+        "-V",
+        callback=_version_callback,
+        is_eager=True,
+        help="Show the version and exit.",
+    ),
+) -> None:
+    """Print each formatted FILE to standard output.
+
+    Use ``-w`` to rewrite the files in place, or ``-o PATH`` to collect the
+    result in one file.  ``--check`` and ``--diff`` never write anything.
+    """
+    _reject_conflicting_modes(files, output, write, check, show_diff)
+
+    exit_code = 0
+    collected: List[str] = []
+
+    for name in files:
+        try:
+            data = sys.stdin.read() if name == "-" else Path(name).read_text("utf-8")
+        except OSError as exc:
+            typer.echo(f"beautify-bash: {name}: {exc.strerror}", err=True)
+            exit_code = 2
+            continue
+
+        label = "(stdin)" if name == "-" else name
+        beautifier = Beautifier(
+            indent_char="\t" if use_tabs else " ",
+            indent_size=1 if use_tabs else indent_size,
+            backup=backup,
+        )
+        result = beautifier.format(data, _resolve_dialect(dialect, data, label))
+
+        for error in result.errors:
+            typer.echo(error.render(label), err=True)
+            exit_code = max(exit_code, 1)
+
+        changed = result.text != data
+        if changed and (check or show_diff):
+            exit_code = max(exit_code, 1)
+
+        if show_diff:
+            typer.echo(_diff(data, result.text, label), nl=False)
+        elif check:
+            if changed and not quiet:
+                typer.echo(f"would reformat {label}", err=True)
+        elif write:
+            if changed:
+                if backup:
+                    Path(f"{name}~").write_text(data, encoding="utf-8")
+                Path(name).write_text(result.text, encoding="utf-8")
+                if not quiet:
+                    typer.echo(f"reformatted {name}", err=True)
+        elif output is not None and output != "-":
+            collected.append(result.text)
+        else:
+            typer.echo(result.text, nl=False)
+
+    if collected:
+        assert output is not None  # guaranteed by the branch that filled `collected`
+        try:
+            Path(output).write_text("".join(collected), encoding="utf-8")
+        except OSError as exc:
+            typer.echo(f"beautify-bash: {output}: {exc.strerror}", err=True)
+            exit_code = max(exit_code, 2)
+
+    raise typer.Exit(exit_code)
+
+
+def _reject_conflicting_modes(
+    files: List[str],
+    output: Optional[str],
+    write: bool,
+    check: bool,
+    show_diff: bool,
+) -> None:
+    """Fail early on option combinations that cannot all be honoured."""
+    if write and output is not None:
+        raise typer.BadParameter("--write cannot be combined with --output.")
+    if write and "-" in files:
+        raise typer.BadParameter("--write cannot rewrite standard input.")
+    if check and show_diff:
+        raise typer.BadParameter("--check cannot be combined with --diff.")
+    for flag, name in ((check, "--check"), (show_diff, "--diff")):
+        if flag and write:
+            raise typer.BadParameter(f"{name} cannot be combined with --write.")
+        if flag and output is not None:
+            raise typer.BadParameter(f"{name} cannot be combined with --output.")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    app()

beautify_bash/dialects.py

@@ -0,0 +1,196 @@
+"""Shell dialect definitions.
+
+A :class:`Dialect` describes the keywords that open and close an indentation
+block for a given shell.  The beautifier is otherwise dialect agnostic, so
+adding a new shell is a matter of adding a :class:`Dialect` instance here.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Dict, Optional, Pattern, Tuple
+
+__all__ = [
+    "BASH",
+    "DIALECTS",
+    "ZSH",
+    "Dialect",
+    "command_position_pattern",
+    "detect_dialect",
+    "get_dialect",
+]
+
+
+#: A shell reserved word only acts as a keyword in *command position*: at the
+#: start of the line or right after one of these separators.  Without this,
+#: ``echo done`` would dedent the script.
+_COMMAND_POSITION = r"(?:\A|[;&|(){}])\s*"
+
+
+def _keyword_pattern(keywords: Tuple[str, ...], trailer: str) -> Pattern[str]:
+    """Build a regex matching any of ``keywords`` used as a reserved word."""
+    alternation = "|".join(re.escape(word) for word in keywords)
+    return re.compile(rf"{_COMMAND_POSITION}(?:{alternation})(?:{trailer})")
+
+
+def command_position_pattern(keyword: str) -> Pattern[str]:
+    """Regex matching a single ``keyword`` used as a reserved word."""
+    return _keyword_pattern((keyword,), r";|\)|\||\Z|\s")
+
+
+@dataclass(frozen=True)
+class Dialect:
+    """Indentation rules for one shell dialect."""
+
+    name: str
+    #: Keywords that open a block (``then``, ``do``, ...).
+    open_keywords: Tuple[str, ...]
+    #: Keywords that close a block (``fi``, ``done``, ...).
+    close_keywords: Tuple[str, ...]
+    #: Keywords printed one level to the left without changing the running
+    #: level (``else``, ``elif``).
+    hanging_keywords: Tuple[str, ...] = ("else", "elif")
+    #: File extensions that imply this dialect.
+    extensions: Tuple[str, ...] = ()
+    #: Interpreter basenames that imply this dialect via the shebang line.
+    interpreters: Tuple[str, ...] = ()
+
+    open_re: Pattern[str] = field(init=False, repr=False, compare=False)
+    close_re: Pattern[str] = field(init=False, repr=False, compare=False)
+    hanging_re: Pattern[str] = field(init=False, repr=False, compare=False)
+    starts_close_re: Pattern[str] = field(init=False, repr=False, compare=False)
+
+    def __post_init__(self) -> None:
+        # ``frozen=True`` blocks normal assignment; go through object.__setattr__.
+        object.__setattr__(
+            self, "open_re", _keyword_pattern(self.open_keywords, r";|\Z|\s")
+        )
+        object.__setattr__(
+            self, "close_re", _keyword_pattern(self.close_keywords, r";|\)|\||\Z|\s")
+        )
+        alternation = "|".join(re.escape(word) for word in self.hanging_keywords)
+        object.__setattr__(self, "hanging_re", re.compile(rf"^({alternation})\b"))
+        closers = "|".join(re.escape(word) for word in self.close_keywords)
+        object.__setattr__(
+            self, "starts_close_re", re.compile(rf"^(?:[)}}\]]|(?:{closers})\b)")
+        )
+
+    def count_open(self, text: str) -> int:
+        """Number of block-opening keywords in ``text``."""
+        return len(self.open_re.findall(text))
+
+    def count_close(self, text: str) -> int:
+        """Number of block-closing keywords in ``text``."""
+        return len(self.close_re.findall(text))
+
+    def is_hanging(self, text: str) -> bool:
+        """True when ``text`` starts with a keyword such as ``else``.
+
+        Such a line is printed one level to the left without changing the
+        running indentation level.
+        """
+        return self.hanging_re.search(text) is not None
+
+    def starts_with_close(self, text: str) -> bool:
+        """True when ``text`` opens with a closing bracket or keyword.
+
+        Combined with a net indentation change of zero this identifies
+        "close then reopen" lines such as ``} else {`` or zsh's
+        ``} always {``, which belong one level to the left.
+        """
+        return self.starts_close_re.search(text) is not None
+
+
+#: POSIX-ish bash.  ``elif`` closes the previous branch and the ``then`` that
+#: follows on the same line reopens it, so it is listed as a close keyword.
+BASH = Dialect(
+    name="bash",
+    open_keywords=("case", "then", "do"),
+    close_keywords=("esac", "fi", "done", "elif"),
+    extensions=(".sh", ".bash", ".bashrc", ".ksh"),
+    interpreters=("sh", "bash", "ksh", "dash"),
+)
+
+#: zsh understands everything bash does plus the csh-flavoured ``foreach ...
+#: end`` and ``while ... end`` loop forms.
+ZSH = Dialect(
+    name="zsh",
+    open_keywords=("case", "then", "do", "foreach"),
+    close_keywords=("esac", "fi", "done", "elif", "end"),
+    extensions=(".zsh", ".zshrc", ".zshenv", ".zprofile", ".zlogin", ".zlogout"),
+    interpreters=("zsh",),
+)
+
+DIALECTS: Dict[str, Dialect] = {d.name: d for d in (BASH, ZSH)}
+
+DEFAULT_DIALECT = BASH
+
+_SHEBANG_RE = re.compile(r"^#!\s*(?P<path>\S+)(?P<rest>.*)$")
+
+
+def get_dialect(name: str) -> Dialect:
+    """Look up a dialect by name.
+
+    Raises:
+        KeyError: if ``name`` is not a known dialect.
+    """
+    try:
+        return DIALECTS[name.lower()]
+    except KeyError:
+        known = ", ".join(sorted(DIALECTS))
+        raise KeyError(f"unknown dialect {name!r}; known dialects: {known}") from None
+
+
+def detect_dialect(
+    data: str = "",
+    filename: str = "",
+    default: Dialect = DEFAULT_DIALECT,
+) -> Dialect:
+    """Guess the dialect from a shebang line, falling back to the file name.
+
+    The shebang wins over the extension because it is what actually runs the
+    script.  ``env`` wrappers (``#!/usr/bin/env zsh``) are unwrapped.
+    """
+    dialect = _from_shebang(data)
+    if dialect is not None:
+        return dialect
+    dialect = _from_filename(filename)
+    if dialect is not None:
+        return dialect
+    return default
+
+
+def _from_shebang(data: str) -> Optional[Dialect]:
+    first_line = data.split("\n", 1)[0].strip()
+    match = _SHEBANG_RE.match(first_line)
+    if match is None:
+        return None
+    words = [match.group("path"), *match.group("rest").split()]
+    # Skip `env` and any VAR=value / -flag arguments it may carry.
+    interpreter = ""
+    for word in words:
+        base = word.rsplit("/", 1)[-1]
+        if base == "env" or base.startswith("-") or "=" in base:
+            continue
+        interpreter = base
+        break
+    for dialect in DIALECTS.values():
+        if interpreter in dialect.interpreters:
+            return dialect
+    return None
+
+
+def _from_filename(filename: str) -> Optional[Dialect]:
+    if not filename:
+        return None
+    base = filename.rsplit("/", 1)[-1]
+    suffix = base[base.rindex(".") :].lower() if "." in base[1:] else ""
+    name = base.lower()
+    for dialect in DIALECTS.values():
+        if suffix and suffix in dialect.extensions:
+            return dialect
+        # Dotfiles such as `.zshrc` have no suffix in the usual sense.
+        if f".{name.lstrip('.')}" in dialect.extensions:
+            return dialect
+    return None

beautify_bash-2.0.0.dist-info/METADATA

@@ -0,0 +1,191 @@
+Metadata-Version: 2.5
+Name: beautify-bash
+Version: 2.0.0
+Summary: Code formatter / beautifier for bash and zsh shell scripts.
+Project-URL: Homepage, https://github.com/ewiger/beautify_bash
+Project-URL: Repository, https://github.com/ewiger/beautify_bash
+Project-URL: Issues, https://github.com/ewiger/beautify_bash/issues
+Project-URL: Changelog, https://github.com/ewiger/beautify_bash/blob/master/CHANGELOG.md
+Author: Paul Lutus
+Maintainer-email: Yauhen Yakimovich <yauhen.yakimovich.mail@gmail.com>
+License-Expression: GPL-2.0-or-later
+License-File: LICENSE
+Keywords: bash,beautifier,formatter,indent,shell,zsh
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Unix Shell
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+# beautify_bash
+
+[![CI](https://github.com/ewiger/beautify_bash/actions/workflows/ci.yml/badge.svg)](https://github.com/ewiger/beautify_bash/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/beautify-bash)](https://pypi.org/project/beautify-bash/)
+
+A code formatter / beautifier for **bash** and **zsh** shell scripts.
+
+Originally written in Ruby, then Python, by [Paul Lutus][arachnoid]; revived
+here with a proper package layout, a [Typer][typer] CLI, [uv][uv] tooling,
+a test suite, and support for shell dialects.
+
+[arachnoid]: http://arachnoid.com/python/beautify_bash_program.html
+[typer]: https://typer.tiangolo.com/
+[uv]: https://docs.astral.sh/uv/
+
+## Install
+
+```bash
+uv tool install beautify-bash      # as a standalone command
+uv add beautify-bash               # as a project dependency
+pipx install beautify-bash         # or with pipx
+```
+
+Run it without installing:
+
+```bash
+uvx beautify-bash script.sh
+```
+
+Requires Python 3.9 or newer (tested through 3.14).
+
+## Use
+
+Like `shfmt` and `gofmt`, it prints to standard output and changes nothing on
+disk unless you ask it to:
+
+```bash
+beautify-bash script.sh                 # print the formatted script
+beautify-bash -w script.sh              # rewrite in place, keeping script.sh~
+beautify-bash -w --no-backup script.sh  # rewrite without a backup
+beautify-bash -o tidy.sh script.sh      # write the result to another file
+beautify-bash --check src/*.sh          # exit 1 if anything would change (CI)
+beautify-bash --diff script.sh          # show a unified diff, write nothing
+beautify-bash --indent 4 script.sh      # four spaces per level
+beautify-bash --tabs script.sh          # indent with tabs
+beautify-bash -d zsh script.zsh         # force a dialect
+cat script.sh | beautify-bash -         # stdin to stdout
+beautify-bash -w src/*.sh               # format a whole directory
+python -m beautify_bash script.sh       # same thing via the module
+```
+
+Standard output carries only the formatted script; progress notes, diffs of
+the `--check` kind, and errors go to standard error, so `beautify-bash x.sh >
+y.sh` is safe.
+
+### Options
+
+| Option | Meaning |
+| --- | --- |
+| *(none)* | Print the formatted script to stdout; several inputs are concatenated. |
+| `-w`, `--write` | Rewrite each input file in place. |
+| `-o`, `--output PATH` | Write the result to `PATH` (`-` means stdout). |
+| `-i`, `--indent N` | Spaces per indentation level (default `2`). |
+| `--tabs` / `--spaces` | Indent with tab characters instead of spaces. |
+| `-d`, `--dialect` | `auto` (default), `bash`, or `zsh`. |
+| `--check` | Write nothing; exit `1` if a file would change. |
+| `--diff` | Print a unified diff instead of writing. |
+| `--backup` / `--no-backup` | With `-w`, keep the original as `FILE~` (default on). |
+| `-q`, `--quiet` | Suppress per-file progress notes. |
+| `-V`, `--version` | Print the version and exit. |
+
+`-w`, `-o`, `--check` and `--diff` are mutually exclusive, and `-w` cannot
+rewrite standard input.
+
+Exit codes: `0` clean, `1` a file changed (under `--check`/`--diff`) or a
+syntax problem was reported, `2` a file could not be read or written, or the
+options conflict.
+
+## Dialects
+
+`--dialect auto` picks the dialect from the shebang line first, then the file
+name (`.zsh`, `.zshrc`, `.zshenv`, …), and falls back to bash.
+
+| Dialect | Block keywords |
+| --- | --- |
+| `bash` | `case`/`esac`, `if`/`then`/`elif`/`else`/`fi`, `do`/`done`, `{}`, `()`, `[]` |
+| `zsh` | everything bash has, plus `foreach … end` and `} always {` |
+
+Adding a shell means adding one `Dialect` instance in
+[dialects.py](src/beautify_bash/dialects.py) — the indenter itself is dialect
+agnostic.
+
+## Library use
+
+```python
+from beautify_bash import ZSH, Beautifier, beautify_string
+
+result = beautify_string(open("script.sh").read())
+print(result.text)
+print(result.dialect.name, result.ok, result.errors)
+
+# Explicit configuration
+tidy = Beautifier(indent_char="\t", indent_size=1, dialect=ZSH)
+print(tidy.format("foreach f (a b)\nprint $f\nend").text)
+```
+
+The 1.x API (`BeautifyBash`, `beautify_string(data, path) -> (text, error)`,
+`beautify_file`, `tab_str`, `tab_size`) still works.
+
+## What is preserved verbatim
+
+Re-indenting must never change what a script does, so these regions are passed
+through byte for byte:
+
+- here-document bodies (`<<EOF`, and `<<-EOF` with its indented terminator),
+- lines inside a multi-line `'…'` or `"…"` string,
+- everything inside comments and quotes is ignored for keyword counting.
+
+Shell reserved words only count as keywords in *command position* — at the
+start of a line or after `;`, `&`, `|`, or a bracket — so `echo done` no longer
+dedents the following lines.
+
+## Pre-commit
+
+```yaml
+repos:
+  - repo: local
+    hooks:
+      - id: beautify-bash
+        name: beautify-bash
+        entry: beautify-bash -w
+        language: system
+        types: [shell]
+```
+
+## Development
+
+```bash
+uv sync                     # create .venv and install dev dependencies
+uv run pytest               # run the tests
+uv run pytest --cov         # with coverage
+uv run ruff check .         # lint
+uv run ruff format .        # format the Python sources
+uv run mypy                 # type check
+```
+
+The test suite is in [tests/](tests/):
+
+- [test_beautifier.py](tests/test_beautifier.py) — the indenting core,
+- [test_dialects.py](tests/test_dialects.py) — dialect detection and zsh syntax,
+- [test_cli.py](tests/test_cli.py) — the CLI, via Typer's `CliRunner`,
+- [test_mocks.py](tests/test_mocks.py) — worked `unittest.mock` examples
+  (patching methods, `mock_open`, fake streams, spies, stubs, autospec).
+
+## Roadmap
+
+See [TODO.md](TODO.md).
+
+## License
+
+GPL-2.0-or-later. See [LICENSE](LICENSE).

beautify_bash-2.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+beautify_bash/__init__.py,sha256=t30PhAgmaY1Uonezgl1BcHWpszsp100DGOi2tuWnYkk,1079
+beautify_bash/__main__.py,sha256=IpDBb626Lpk5U5JnwjUj78NAIdDOqeOqQZ5OfWMwT2U,101
+beautify_bash/beautifier.py,sha256=IW5JBRUPRZqxO7eCD4CBEjsbkpHc6IDgXMAtTayvh5Q,10814
+beautify_bash/cli.py,sha256=OOF5RObXqoBR7lltAK9Jko7yGaCKtJuU6RMmF6NypBo,6023
+beautify_bash/dialects.py,sha256=1CyeidZKAFsub2q7TXC-TEdJRoctDuHd1MkS-BKAxhk,6942
+beautify_bash/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+beautify_bash-2.0.0.dist-info/METADATA,sha256=_4--XuzLThedK8iIBg3tsLEp7-rA-JGORiRpbDMpR-A,7050
+beautify_bash-2.0.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+beautify_bash-2.0.0.dist-info/entry_points.txt,sha256=M2L6UHBRYQf374w5A09We6IL3986SAi-HLkT7ZTvpjc,94
+beautify_bash-2.0.0.dist-info/licenses/LICENSE,sha256=7a72Msu2Q-TnoiFxemxEGkwafJGObk1W3rw9hzmyM_Y,17984
+beautify_bash-2.0.0.dist-info/RECORD,,

beautify_bash-2.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

beautify_bash-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+beautify-bash = beautify_bash.cli:app
+beautify_bash = beautify_bash.cli:app

beautify_bash-2.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,338 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Moe Ghoul>, 1 April 1989
+  Moe Ghoul, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.