morvix 0.1.0__py3-none-any.whl

morvix/__init__.py

@@ -0,0 +1,10 @@
+# Morvix - a test-authoring, test-running, and test-sharing CLI for
+# university programming assignments.
+#
+# This package is the tool itself. The stdlib-only runner that ships inside
+# shared packages lives in morvix/runner_core/ and is deliberately kept
+# separate so it never imports anything from here.
+
+from morvix.version import __version__
+
+__all__ = ["__version__"]

morvix/__main__.py

@@ -0,0 +1,8 @@
+# Lets you run the tool with `python -m morvix`.
+
+import sys
+
+from morvix.app import main
+
+if __name__ == "__main__":
+    sys.exit(main())

morvix/adapters/__init__.py

@@ -0,0 +1,117 @@
+# Language adapters: the only language-aware part of the system (Section 8).
+#
+# An adapter knows one thing - how to turn this language's source into something
+# runnable, and how to invoke it. It knows nothing about tests, models or
+# comparison. That is the whole point: adding a language is writing one adapter
+# (Section 4.1), and nothing else in the tool changes.
+#
+# Each concrete adapter lives in its own module (c.py, cpp.py, ...) and calls
+# register() at import time. The registry below is how the rest of the tool
+# finds them.
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+
+@dataclass
+class BuildResult:
+    """The outcome of compiling/assembling a solution.
+
+    On success, artifact + the run information are filled in. On failure, ok is
+    False and diagnostics holds the toolchain's own output, shown verbatim.
+    """
+
+    ok: bool
+    artifact: Optional[str] = None        # the produced binary / class dir / script path
+    run_argv: List[str] = field(default_factory=list)   # how to invoke the artifact
+    run_env: Dict[str, str] = field(default_factory=dict)  # extra env (LD_LIBRARY_PATH, ...)
+    diagnostics: str = ""                 # compiler output, shown on failure
+    error: Optional[str] = None           # short summary of what went wrong
+    build_command: str = ""               # the command line we ran, for messages
+
+
+@dataclass
+class RunSpec:
+    """How to actually invoke a built artifact: the argv prefix and extra env.
+
+    The execution model takes this and adds the per-case bits (stdin, argv,
+    files) before handing it to the process layer.
+    """
+
+    argv: List[str]
+    env: Dict[str, str] = field(default_factory=dict)
+
+
+class Adapter(ABC):
+    """The small interface every language exposes (Section 8.3)."""
+
+    name: str = ""
+
+    @abstractmethod
+    def build(self, source: str, config: dict, workdir: str) -> BuildResult:
+        """Compile/assemble/link (or no-op for interpreted languages)."""
+
+    @abstractmethod
+    def run_spec(self, build: BuildResult, config: dict) -> RunSpec:
+        """The command + environment needed to run the built artifact."""
+
+    @abstractmethod
+    def describe(self, config: dict) -> str:
+        """One-line human summary, e.g. 'C, gcc, -std=gnu23, -O2'."""
+
+
+_REGISTRY: Dict[str, Adapter] = {}
+
+# Map common file extensions to a language name, for auto-detection on import.
+_EXTENSIONS = {
+    ".c": "c",
+    ".h": "c",
+    ".cc": "cpp", ".cpp": "cpp", ".cxx": "cpp", ".c++": "cpp", ".hpp": "cpp",
+    ".asm": "nasm", ".s": "nasm", ".nasm": "nasm",
+    ".py": "python",
+    ".java": "java",
+    ".rs": "rust",
+}
+
+
+def register(adapter: Adapter) -> None:
+    _REGISTRY[adapter.name] = adapter
+
+
+def get_adapter(language: str) -> Adapter:
+    _load_builtins()
+    if language not in _REGISTRY:
+        from morvix.errors import UserError
+
+        known = ", ".join(sorted(_REGISTRY)) or "(none)"
+        raise UserError(
+            f"No adapter for language '{language}'.",
+            hint=f"Supported: {known}. Or use a raw build/run command (config --raw-build).",
+        )
+    return _REGISTRY[language]
+
+
+def list_languages() -> List[str]:
+    _load_builtins()
+    return sorted(_REGISTRY)
+
+
+def detect_language(path: str) -> Optional[str]:
+    """Guess the language from a file's extension."""
+    import os
+
+    return _EXTENSIONS.get(os.path.splitext(path)[1].lower())
+
+
+_loaded = False
+
+
+def _load_builtins() -> None:
+    # Import the concrete adapters once, so they self-register. Listed explicitly
+    # rather than auto-discovered to keep imports predictable.
+    global _loaded
+    if _loaded:
+        return
+    _loaded = True
+    from morvix.adapters import c, cpp, nasm, python, java, rust  # noqa: F401

morvix/adapters/c.py

@@ -0,0 +1,85 @@
+# C language adapter.
+#
+# Compiles a single .c file with gcc (or a configured compiler) and produces
+# a native binary. Config keys are all optional - sensible defaults apply so
+# a plain {"language": "c"} config works out of the box.
+
+import os
+
+from morvix import process
+from morvix.adapters import Adapter, BuildResult, RunSpec, register
+
+
+class CAdapter(Adapter):
+    name = "c"
+
+    def build(self, source: str, config: dict, workdir: str) -> BuildResult:
+        compiler = config.get("compiler", "gcc")
+        process.require_tool(
+            compiler,
+            install_hint=f"Install gcc (e.g. 'sudo apt install gcc' or 'brew install gcc') "
+                         f"and make sure '{compiler}' is on your PATH.",
+        )
+
+        artifact = os.path.join(workdir, "a.out")
+
+        # Build up the compile command:
+        # - compiler, output flag, source
+        # - optional -std=, -O, extra flags, -I, -L, -l entries
+        cmd = [compiler, "-o", artifact, source]
+
+        std = config.get("std")
+        if std:
+            cmd.append(f"-std={std}")
+
+        opt = config.get("opt")
+        if opt:
+            cmd.append(f"-{opt}")
+
+        for flag in config.get("flags", []):
+            cmd.append(flag)
+
+        for inc in config.get("include", []):
+            cmd.extend(["-I", inc])
+
+        for libdir in config.get("libdirs", []):
+            cmd.extend(["-L", libdir])
+
+        for lib in config.get("lib", []):
+            cmd.append(f"-l{lib}")
+
+        res = process.run(cmd, wall_limit=180)
+        build_command = " ".join(cmd)
+
+        if not res.ok:
+            return BuildResult(
+                ok=False,
+                diagnostics=(res.stdout + res.stderr).decode("utf-8", "replace"),
+                error="compilation failed",
+                build_command=build_command,
+            )
+
+        return BuildResult(
+            ok=True,
+            artifact=artifact,
+            run_argv=[artifact],
+            run_env={},
+            build_command=build_command,
+        )
+
+    def run_spec(self, build: BuildResult, config: dict) -> RunSpec:
+        return RunSpec(argv=build.run_argv, env=build.run_env)
+
+    def describe(self, config: dict) -> str:
+        compiler = config.get("compiler", "gcc")
+        parts = ["C", compiler]
+        if "std" in config:
+            parts.append(f"-std={config['std']}")
+        if "opt" in config:
+            parts.append(f"-{config['opt']}")
+        for flag in config.get("flags", []):
+            parts.append(flag)
+        return ", ".join(parts)
+
+
+register(CAdapter())

morvix/adapters/cpp.py

@@ -0,0 +1,83 @@
+# C++ language adapter.
+#
+# Compiles a single .cpp file with g++ (or a configured compiler) and produces
+# a native binary. Config keys are all optional - sensible defaults apply so
+# a plain {"language": "cpp"} config works out of the box.
+
+import os
+
+from morvix import process
+from morvix.adapters import Adapter, BuildResult, RunSpec, register
+
+
+class CppAdapter(Adapter):
+    name = "cpp"
+
+    def build(self, source: str, config: dict, workdir: str) -> BuildResult:
+        compiler = config.get("compiler", "g++")
+        process.require_tool(
+            compiler,
+            install_hint=f"Install g++ (e.g. 'sudo apt install g++' or 'brew install gcc') "
+                         f"and make sure '{compiler}' is on your PATH.",
+        )
+
+        artifact = os.path.join(workdir, "a.out")
+
+        # Build up the compile command:
+        # - compiler, output flag, source
+        # - -std= (defaults to c++20), optional -O, extra flags, -I, -L, -l entries
+        cmd = [compiler, "-o", artifact, source]
+
+        std = config.get("std", "c++20")
+        cmd.append(f"-std={std}")
+
+        opt = config.get("opt")
+        if opt:
+            cmd.append(f"-{opt}")
+
+        for flag in config.get("flags", []):
+            cmd.append(flag)
+
+        for inc in config.get("include", []):
+            cmd.extend(["-I", inc])
+
+        for libdir in config.get("libdirs", []):
+            cmd.extend(["-L", libdir])
+
+        for lib in config.get("lib", []):
+            cmd.append(f"-l{lib}")
+
+        res = process.run(cmd, wall_limit=180)
+        build_command = " ".join(cmd)
+
+        if not res.ok:
+            return BuildResult(
+                ok=False,
+                diagnostics=(res.stdout + res.stderr).decode("utf-8", "replace"),
+                error="compilation failed",
+                build_command=build_command,
+            )
+
+        return BuildResult(
+            ok=True,
+            artifact=artifact,
+            run_argv=[artifact],
+            run_env={},
+            build_command=build_command,
+        )
+
+    def run_spec(self, build: BuildResult, config: dict) -> RunSpec:
+        return RunSpec(argv=build.run_argv, env=build.run_env)
+
+    def describe(self, config: dict) -> str:
+        compiler = config.get("compiler", "g++")
+        std = config.get("std", "c++20")
+        parts = ["C++", compiler, f"-std={std}"]
+        if "opt" in config:
+            parts.append(f"-{config['opt']}")
+        for flag in config.get("flags", []):
+            parts.append(flag)
+        return ", ".join(parts)
+
+
+register(CppAdapter())

morvix/adapters/java.py

@@ -0,0 +1,108 @@
+# Java language adapter.
+#
+# Compiles a .java file with javac and runs the resulting class with java.
+# The main class is inferred from the source file name and an optional package
+# declaration. Config keys are all optional - a plain {"language": "java"}
+# config works out of the box.
+
+import os
+import re
+
+from morvix import process
+from morvix.adapters import Adapter, BuildResult, RunSpec, register
+
+
+# Matches: package some.pkg.name;
+_PACKAGE_RE = re.compile(r"^\s*package\s+([\w.]+)\s*;", re.MULTILINE)
+
+
+def _detect_main_class(source: str) -> str:
+    """Return the fully-qualified main class name.
+
+    - The class name is always the file stem (filename without .java).
+    - Read the source text to look for a package declaration; if found,
+      prepend it with a dot separator.
+    """
+    stem = os.path.splitext(os.path.basename(source))[0]
+    try:
+        text = open(source, encoding="utf-8", errors="replace").read()
+    except OSError:
+        return stem
+    m = _PACKAGE_RE.search(text)
+    if m:
+        return m.group(1) + "." + stem
+    return stem
+
+
+class JavaAdapter(Adapter):
+    name = "java"
+
+    def build(self, source: str, config: dict, workdir: str) -> BuildResult:
+        javac = config.get("javac", "javac")
+        java = config.get("java", "java")
+        classpath = config.get("classpath", "")
+        release = config.get("release")
+
+        # Raise a clear error if the JDK is not installed.
+        process.require_tool(
+            javac,
+            install_hint="Install a JDK (e.g. 'sudo apt install default-jdk' or "
+                         "'brew install openjdk') and make sure 'javac' is on your PATH.",
+        )
+        process.require_tool(
+            java,
+            install_hint="Install a JRE/JDK and make sure 'java' is on your PATH.",
+        )
+
+        # Build the javac command:
+        # - "-d workdir" places .class files under workdir
+        # - "--release N" pins the language level if configured
+        # - "-cp classpath" adds the extra classpath for compilation
+        # - "-sourcepath" lets javac pull in other .java files the source needs
+        source_dir = os.path.dirname(source) or "."
+        cmd = [javac, "-d", workdir]
+        if release:
+            cmd += ["--release", str(release)]
+        if classpath:
+            cmd += ["-cp", classpath]
+        cmd += ["-sourcepath", source_dir, source]
+
+        res = process.run(cmd, wall_limit=180)
+        build_command = " ".join(cmd)
+
+        if not res.ok:
+            return BuildResult(
+                ok=False,
+                diagnostics=(res.stdout + res.stderr).decode("utf-8", "replace"),
+                error="javac reported errors",
+                build_command=build_command,
+            )
+
+        main_class = _detect_main_class(source)
+
+        # Runtime classpath = workdir (where .class files live) + extra classpath.
+        rt_cp = workdir + (os.pathsep + classpath if classpath else "")
+        run_argv = [java, "-cp", rt_cp, main_class]
+
+        return BuildResult(
+            ok=True,
+            artifact=workdir,
+            run_argv=run_argv,
+            run_env={},
+            build_command=build_command,
+        )
+
+    def run_spec(self, build: BuildResult, config: dict) -> RunSpec:
+        return RunSpec(argv=build.run_argv, env=build.run_env)
+
+    def describe(self, config: dict) -> str:
+        javac = config.get("javac", "javac")
+        java = config.get("java", "java")
+        parts = ["Java", javac, java]
+        release = config.get("release")
+        if release:
+            parts.append(f"--release {release}")
+        return ", ".join(parts)
+
+
+register(JavaAdapter())

morvix/adapters/nasm.py

@@ -0,0 +1,94 @@
+# NASM assembler adapter.
+#
+# Two-step build: assemble with nasm, then link with gcc (or ld).
+# macOS (macho64 + ld for pure-syscall programs) is best-effort; the ABI
+# and system call conventions differ from Linux elf64 in ways morvix does
+# not abstract.
+
+import os
+import sys
+
+from morvix.adapters import Adapter, BuildResult, RunSpec, register
+from morvix import process
+
+
+def _default_format():
+    return "macho64" if sys.platform == "darwin" else "elf64"
+
+
+class NasmAdapter(Adapter):
+    name = "nasm"
+
+    def build(self, source: str, config: dict, workdir: str) -> BuildResult:
+        assembler = config.get("assembler", "nasm")
+        fmt = config.get("format", _default_format())
+        linker = config.get("link", "gcc")
+        extra_flags = config.get("flags", [])
+        link_flags = config.get("linkflags", [])
+
+        # Locate required tools before we attempt anything.
+        asm_path = process.require_tool(
+            assembler,
+            f"Install nasm (e.g. 'brew install nasm' or 'apt install nasm').",
+        )
+
+        # Step 1: assemble source -> object file.
+        obj = os.path.join(workdir, "obj.o")
+        asm_cmd = [asm_path, "-f", fmt, *extra_flags, source, "-o", obj]
+        res = process.run(asm_cmd, wall_limit=180)
+        if not res.ok:
+            diag = (res.stdout + res.stderr).decode("utf-8", "replace")
+            return BuildResult(
+                ok=False,
+                diagnostics=diag,
+                error="assembly failed",
+                build_command=" ".join(asm_cmd),
+            )
+
+        # Step 2: link object -> executable.
+        out = os.path.join(workdir, "a.out")
+        if linker == "ld":
+            ld_path = process.require_tool(
+                "ld",
+                "Install ld (usually part of binutils or the system toolchain).",
+            )
+            link_cmd = [ld_path, obj, "-o", out, *link_flags]
+        else:
+            # Prefer gcc; fall back to cc.
+            cc = process.find_tool("gcc") or process.find_tool("cc")
+            if cc is None:
+                process.require_tool(
+                    "gcc",
+                    "Install gcc or cc (e.g. 'apt install gcc' or Xcode command-line tools).",
+                )
+            link_cmd = [cc, obj, "-o", out, *link_flags]
+
+        res2 = process.run(link_cmd, wall_limit=180)
+        if not res2.ok:
+            diag = (res2.stdout + res2.stderr).decode("utf-8", "replace")
+            return BuildResult(
+                ok=False,
+                diagnostics=diag,
+                error="link failed",
+                build_command=" ".join(link_cmd),
+            )
+
+        return BuildResult(
+            ok=True,
+            artifact=out,
+            run_argv=[out],
+            run_env={},
+            build_command=" ".join(asm_cmd) + " && " + " ".join(link_cmd),
+        )
+
+    def run_spec(self, build: BuildResult, config: dict) -> RunSpec:
+        return RunSpec(argv=build.run_argv, env=build.run_env)
+
+    def describe(self, config: dict) -> str:
+        assembler = config.get("assembler", "nasm")
+        fmt = config.get("format", _default_format())
+        linker = config.get("link", "gcc")
+        return f"NASM, {assembler}, {fmt}, link={linker}"
+
+
+register(NasmAdapter())

morvix/adapters/python.py

@@ -0,0 +1,53 @@
+# Python language adapter.
+#
+# Python scripts need no compilation step, so build() is a lightweight
+# syntax check via "python3 -m py_compile". If the check passes the script
+# itself is the artifact and run_argv points straight at the interpreter.
+
+from morvix import process
+from morvix.adapters import Adapter, BuildResult, RunSpec, register
+
+
+class PythonAdapter(Adapter):
+    name = "python"
+
+    def build(self, source: str, config: dict, workdir: str) -> BuildResult:
+        interpreter = config.get("interpreter") or "python3"
+
+        # Ensure the interpreter exists before doing anything else.
+        process.require_tool(
+            interpreter,
+            install_hint=f"Install Python and make sure '{interpreter}' is on your PATH.",
+        )
+
+        # Run an optional syntax check; a real compile error should surface
+        # here rather than at run time so the user gets a clear message.
+        cmd = [interpreter, "-m", "py_compile", source]
+        res = process.run(cmd, wall_limit=30)
+        if not res.ok:
+            diagnostics = (res.stdout + res.stderr).decode("utf-8", "replace")
+            return BuildResult(
+                ok=False,
+                diagnostics=diagnostics,
+                error="syntax error",
+                build_command=" ".join(cmd),
+            )
+
+        # No binary to produce - the script is the artifact.
+        return BuildResult(
+            ok=True,
+            artifact=source,
+            run_argv=[interpreter, source],
+            run_env={},
+            build_command=" ".join(cmd),
+        )
+
+    def run_spec(self, build: BuildResult, config: dict) -> RunSpec:
+        return RunSpec(argv=build.run_argv, env=build.run_env)
+
+    def describe(self, config: dict) -> str:
+        interpreter = config.get("interpreter") or "python3"
+        return f"Python, {interpreter}"
+
+
+register(PythonAdapter())

morvix/adapters/rust.py

@@ -0,0 +1,70 @@
+# Rust language adapter.
+#
+# Compiles a single .rs file with rustc and produces a native binary.
+# Cargo-project builds are a future extension; single-file rustc is supported now.
+# Config keys are all optional - sensible defaults apply.
+
+import os
+
+from morvix import process
+from morvix.adapters import Adapter, BuildResult, RunSpec, register
+
+
+class RustAdapter(Adapter):
+    name = "rust"
+
+    def build(self, source: str, config: dict, workdir: str) -> BuildResult:
+        rustc = config.get("rustc", "rustc")
+        process.require_tool(
+            rustc,
+            "Install Rust via rustup for the rust adapter.",
+        )
+
+        artifact = os.path.join(workdir, "a.out")
+
+        # Build up the compile command:
+        # - rustc, optional --edition, optional -O, source, -o output
+        cmd = [rustc]
+
+        edition = config.get("edition")
+        if edition:
+            cmd.extend(["--edition", str(edition)])
+
+        if config.get("release"):
+            cmd.append("-O")
+
+        cmd.extend([source, "-o", artifact])
+
+        res = process.run(cmd, wall_limit=180)
+        build_command = " ".join(cmd)
+
+        if not res.ok:
+            return BuildResult(
+                ok=False,
+                diagnostics=(res.stdout + res.stderr).decode("utf-8", "replace"),
+                error="compilation failed",
+                build_command=build_command,
+            )
+
+        return BuildResult(
+            ok=True,
+            artifact=artifact,
+            run_argv=[artifact],
+            run_env={},
+            build_command=build_command,
+        )
+
+    def run_spec(self, build: BuildResult, config: dict) -> RunSpec:
+        return RunSpec(argv=build.run_argv, env=build.run_env)
+
+    def describe(self, config: dict) -> str:
+        rustc = config.get("rustc", "rustc")
+        parts = ["Rust", rustc]
+        if "edition" in config:
+            parts.append(f"--edition {config['edition']}")
+        if config.get("release"):
+            parts.append("-O")
+        return ", ".join(parts)
+
+
+register(RustAdapter())