molty 0.1.0__py3-none-any.whl

molty/__init__.py

@@ -0,0 +1,6 @@
+"""Molty: a strict superset of Python that turns common Python traps into errors."""
+
+from molty.runtime import checked, isolated, scope
+
+__all__ = ["checked", "isolated", "scope"]
+__version__ = "0.1.0"

molty/compiler/__init__.py

@@ -0,0 +1,75 @@
+"""The Molty compiler: ``.molty.py`` source in, plain Python out.
+
+    pre-pass (tokens) -> ast.parse -> checks (rules) -> emit
+"""
+
+from __future__ import annotations
+
+import ast
+import tokenize
+from dataclasses import dataclass, field
+
+from molty.compiler import emit, rules, tokens
+from molty.compiler.emit import Explanation
+from molty.compiler.rules import ERROR, WARNING, Diagnostic
+
+__all__ = ["CompileResult", "Diagnostic", "Explanation", "compile_source"]
+
+
+@dataclass
+class CompileResult:
+    code: str | None  # None when there are errors
+    diagnostics: list[Diagnostic] = field(default_factory=list)
+    explanations: list[Explanation] = field(default_factory=list)
+
+    @property
+    def ok(self) -> bool:
+        return self.code is not None
+
+    @property
+    def errors(self) -> list[Diagnostic]:
+        return [d for d in self.diagnostics if d.severity == ERROR]
+
+    @property
+    def warnings(self) -> list[Diagnostic]:
+        return [d for d in self.diagnostics if d.severity == WARNING]
+
+
+def compile_source(source: str, filename: str = "<molty>", *, rewrite_defaults: bool = False) -> CompileResult:
+    """Compile Molty source to Python.  With ``rewrite_defaults`` a mutable default
+    argument gets a fresh object per call instead of a MOL1004 warning."""
+    try:
+        prepared = tokens.prepare(source)
+    except (SyntaxError, tokenize.TokenError) as exc:
+        return CompileResult(None, [_untokenizable(source, filename, exc)])
+    try:
+        tree = ast.parse(prepared.source, filename)
+    except SyntaxError as exc:
+        return CompileResult(None, [_syntax_error(exc, prepared, utf8=False)])
+    try:
+        # Errors the parser lets through, such as 'await' outside an async function.
+        compile(tree, filename, "exec", dont_inherit=True)
+    except SyntaxError as exc:
+        return CompileResult(None, [_syntax_error(exc, prepared, utf8=True)])
+
+    analysis = rules.analyze(tree, prepared, rewrite_defaults)
+    if analysis.failed:
+        return CompileResult(None, analysis.diagnostics)
+    code, explanations = emit.emit(tree, prepared, analysis, filename)
+    return CompileResult(code, analysis.diagnostics, explanations)
+
+
+def _syntax_error(exc: SyntaxError, prepared: tokens.Prepared, utf8: bool) -> Diagnostic:
+    line = exc.lineno or 1
+    col = max((exc.offset or 1) - 1, 0)
+    # The parser reports character offsets; errors from compiling the tree carry utf-8 ones.
+    line, col = prepared.original_position(line, col) if utf8 else prepared.original_char_position(line, col)
+    return Diagnostic("MOL0001", ERROR, exc.msg, line, col)
+
+
+def _untokenizable(source: str, filename: str, exc: Exception) -> Diagnostic:
+    try:
+        ast.parse(source, filename)  # the parser gives the better message
+    except SyntaxError as parse_error:
+        return Diagnostic("MOL0001", ERROR, parse_error.msg, parse_error.lineno or 1, max((parse_error.offset or 1) - 1, 0))
+    return Diagnostic("MOL0001", ERROR, str(exc), 1, 0)

molty/compiler/cli.py

@@ -0,0 +1,189 @@
+"""moltyc: compile ``.molty.py`` files to plain ``.py`` files."""
+
+from __future__ import annotations
+
+import argparse
+import io
+import os
+import sys
+import tokenize
+import unicodedata
+from pathlib import Path
+from typing import Any, TextIO
+
+import molty
+from molty.compiler import CompileResult, compile_source
+
+SUFFIX = ".molty.py"
+
+# Shown by ``moltyc --version`` on a terminal.
+LOGO = r"""
+ __  __  ___  _   _______   __
+|  \/  |/ _ \| | |_   _\ \ / /
+| |\/| | | | | |   | |  \ V /
+| |  | | |_| | |___| |   | |
+|_|  |_|\___/|_____|_|   |_|
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~:>   Molty {version}
+""".strip("\n")
+SNAKE = "~~~~:>"  # starts the line for each file that compiled
+
+
+class _Version(argparse.Action):
+    """The logo on a terminal; a plain ``moltyc X.Y.Z`` line for scripts."""
+
+    def __init__(
+        self, option_strings: list[str], dest: str = argparse.SUPPRESS, default: Any = argparse.SUPPRESS,
+        help: str | None = None,
+    ) -> None:
+        super().__init__(option_strings, dest=dest, default=default, nargs=0, help=help)
+
+    def __call__(
+        self, parser: argparse.ArgumentParser, namespace: argparse.Namespace, values: Any, option_string: str | None = None
+    ) -> None:
+        if sys.stdout.isatty():
+            print(LOGO.format(version=molty.__version__))
+        else:
+            print(f"moltyc {molty.__version__}")
+        parser.exit()
+
+
+def _sources(names: list[str], parser: argparse.ArgumentParser) -> list[Path]:
+    found = []
+    for name in names:
+        path = Path(name)
+        if path.is_dir():
+            found += _walk(path)
+        elif path.name.endswith(SUFFIX) and path.is_file():
+            found.append(path)
+        elif not path.exists():
+            parser.error(f"{name}: no such file or directory")
+        else:
+            parser.error(f"{name}: expected a {SUFFIX} file")
+    return found
+
+
+def _walk(directory: Path) -> list[Path]:
+    """The .molty.py files under ``directory``, without following symbolic links.
+
+    A link can lead outside the tree being compiled; a file named on the
+    command line is still read even if it is a link.
+    """
+    found = []
+    for root, dirs, files in os.walk(directory):  # does not descend into linked directories
+        found += [Path(root, name) for name in files if name.endswith(SUFFIX) and not Path(root, name).is_symlink()]
+    return sorted(found)
+
+
+def _written_by_moltyc(path: Path) -> bool:
+    try:
+        with path.open("rb") as f:
+            head = [f.readline().lstrip(b"\xef\xbb\xbf") for _ in range(3)]  # header follows a shebang or coding line
+    except OSError:
+        return False
+    return any(line.startswith(b"# Generated by moltyc") for line in head)
+
+
+def _refusal(target: Path, sources: list[Path], force: bool) -> str | None:
+    """Why moltyc must not write ``target``, if it must not."""
+    if target.is_symlink():
+        return f"{target} is a symbolic link; moltyc does not write through links"
+    if target.exists():
+        if any(os.path.samefile(target, source) for source in sources if source.exists()):
+            return f"{target} is a source file; writing it would destroy the source"
+        # Only a regular file can hold someone's code; /dev/null and the like are fine.
+        if not force and target.is_file() and not _written_by_moltyc(target):
+            return f"{target} exists and was not generated by moltyc; use --force to overwrite it"
+    return None
+
+
+def _write(target: Path, text: str, encoding: str) -> None:
+    # O_NOFOLLOW makes the open itself refuse a symbolic link, so a link put
+    # in place after the checks above still cannot redirect the write.
+    flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC | getattr(os, "O_NOFOLLOW", 0)
+    with open(os.open(target, flags, 0o666), "w", encoding=encoding, newline="") as f:
+        f.write(text)
+
+
+def _caret(text: str, col: int) -> str:
+    # Wide (e.g. CJK) characters take two terminal columns; tabs are kept as tabs.
+    pad = ("\t" if c == "\t" else "  " if unicodedata.east_asian_width(c) in "WF" else " " for c in text[:col])
+    return "".join(pad) + "^"
+
+
+def _report(result: CompileResult, path: Path, source: str, explain: bool, out: TextIO) -> None:
+    lines = source.splitlines()
+    for diagnostic in result.diagnostics:
+        print(diagnostic.format(str(path)), file=sys.stderr)
+        if 0 < diagnostic.line <= len(lines):
+            text = lines[diagnostic.line - 1]
+            print(f"    {text}", file=sys.stderr)
+            print(f"    {_caret(text, diagnostic.col)}", file=sys.stderr)
+    if explain:
+        for explanation in result.explanations:
+            print(explanation.format(str(path)), file=out)
+
+
+def _success(path: Path, target: str, result: CompileResult) -> str:
+    count = len(result.warnings)
+    note = f" ({count} warning{'s' if count != 1 else ''})" if count else ""
+    return f"{SNAKE}  {path} -> {target}  ok{note}"
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="moltyc", description="Compile Molty (.molty.py) files to plain Python.")
+    parser.add_argument("sources", nargs="+", metavar="SOURCE", help=f"{SUFFIX} files or directories containing them")
+    parser.add_argument("-o", "--output", help="output file for a single source; '-' writes to stdout")
+    parser.add_argument("--explain", action="store_true", help="list every rewrite moltyc made")
+    parser.add_argument(
+        "--rewrite-defaults",
+        action="store_true",
+        help="give mutable default arguments a fresh object per call instead of warning (MOL1004)",
+    )
+    parser.add_argument("-q", "--quiet", action="store_true", help="do not print a line for each compiled file")
+    parser.add_argument("--force", action="store_true", help="overwrite a .py file that moltyc did not generate")
+    parser.add_argument("--version", action=_Version, help="show the version and exit")
+    args = parser.parse_args(argv)
+
+    paths = _sources(args.sources, parser)
+    if args.output and len(paths) != 1:
+        parser.error("-o/--output needs exactly one source file")
+
+    # The success line goes to stderr, and only to a person at a terminal.
+    announce = not args.quiet and sys.stderr.isatty()
+    failed = False
+    for path in paths:
+        raw = path.read_bytes()
+        encoding, _ = tokenize.detect_encoding(io.BytesIO(raw).readline)
+        source = raw.decode(encoding)
+        result = compile_source(source, str(path), rewrite_defaults=args.rewrite_defaults)
+        to_stdout = args.output == "-"
+        _report(result, path, source, args.explain, sys.stderr if to_stdout else sys.stdout)
+        code = result.code
+        if code is None:
+            failed = True
+            continue
+        if to_stdout:
+            sys.stdout.write(code)
+            sys.stdout.flush()
+            written = "(stdout)"
+        else:
+            target = Path(args.output) if args.output else path.with_name(path.name[: -len(SUFFIX)] + ".py")
+            refusal = _refusal(target, paths, args.force)
+            if refusal:
+                print(f"moltyc: error: {refusal}", file=sys.stderr)
+                failed = True
+                continue
+            try:
+                _write(target, code, encoding)
+            except OSError as exc:
+                print(f"moltyc: error: cannot write {target}: {exc.strerror}", file=sys.stderr)
+                failed = True
+                continue
+            written = str(target)
+        if announce:
+            print(_success(path, written, result), file=sys.stderr)
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())