quoll-cli 0.2.0__py3-none-any.whl

quoll/languages/python/ci.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence
+
+from quoll.ci.steps import ROOT, Cache, Item, Step, on_github, step
+from quoll.languages.base import CISteps, TestReports
+from quoll.platforms.github.actions import ACTIONS
+
+if TYPE_CHECKING:
+    from quoll.ci.config import CIConfig
+    from quoll.languages.base import Detection
+
+# The TOTAL line of `coverage report` / pytest-cov.
+COVERAGE_REGEX = r"/TOTAL.*\s(\d+(?:\.\d+)?)%/"
+
+_RUN_PREFIX = {"pip": "", "uv": "uv run --no-sync ", "poetry": "poetry run "}
+_TOOL_INSTALL = {"pip": "pip install", "uv": "uv pip install", "poetry": "poetry run pip install"}
+
+# tool: (step name, package to install, command)
+_LINT = {
+    "ruff": ("Ruff", "ruff", "ruff check{github} ."),
+    "ruff-format": ("Ruff format", "ruff", "ruff format --check --diff ."),
+    "flake8": ("Flake8", "flake8", "flake8 ."),
+    "black": ("Black", "black", "black --check --diff ."),
+    "mypy": ("Mypy", "mypy", "mypy {source_dir}"),
+}
+
+
+class PythonCI(CISteps):
+    version_key = "python-version"
+    codeql_language = "python"
+
+    def setup(self, cfg: CIConfig, version: Optional[str]) -> List[Item]:
+        if cfg.package_manager == "uv":
+            with_: Dict[str, Any] = {}
+            if version:
+                with_["python-version"] = version
+            if cfg.cache:
+                with_["enable-cache"] = True
+            if cfg.directory != ".":
+                with_["working-directory"] = cfg.directory
+            return [step("Set up uv", uses=ACTIONS["setup-uv"], with_=with_ or None)]
+
+        steps = []
+        if cfg.package_manager == "poetry":
+            steps.append(step("Install Poetry", run="pipx install poetry"))
+        with_ = {"python-version": version} if version else {"python-version-file": cfg.path(cfg.version_file)}
+        if cfg.cache:
+            with_["cache"] = cfg.package_manager
+            if cfg.package_manager == "pip":
+                with_["cache-dependency-path"] = f"{cfg.path('**/requirements*.txt')}\n{cfg.path('**/pyproject.toml')}"
+            elif cfg.directory != ".":
+                with_["cache-dependency-path"] = cfg.path("poetry.lock")
+        steps.append(step("Set up Python", uses=ACTIONS["setup-python"], with_=with_))
+        return steps
+
+    def image(self, cfg: CIConfig, version: str) -> str:
+        if cfg.package_manager == "uv":
+            return f"ghcr.io/astral-sh/uv:python{version}-bookworm"
+        return f"python:{version}"
+
+    def image_setup(self, cfg: CIConfig) -> List[Step]:
+        if cfg.package_manager == "poetry":
+            return [step("Install Poetry", run="pip install poetry")]
+        return []
+
+    def cache(self, cfg: CIConfig) -> Optional[Cache]:
+        if not cfg.cache:
+            return None
+        if cfg.package_manager == "pip":
+            return Cache("pip", (".cache/pip",), env={"PIP_CACHE_DIR": f"{ROOT}/.cache/pip"})
+        # The virtualenv itself, in the project (linters and pytest skip .venv).
+        lockfile = "uv.lock" if cfg.package_manager == "uv" else "poetry.lock"
+        env = {"POETRY_VIRTUALENVS_IN_PROJECT": "true"} if cfg.package_manager == "poetry" else {}
+        return Cache("venv", (".venv",), key_files=(lockfile,), env=env)
+
+    def install(self, cfg: CIConfig, packages: Sequence[str] = ()) -> List[Item]:
+        steps = [step("Install dependencies", run=cfg.install)]
+        if packages:
+            steps.append(step("Install CI tools", run=f"{_TOOL_INSTALL[cfg.package_manager]} {' '.join(packages)}"))
+        return steps
+
+    def exec(self, cfg: CIConfig, command: str) -> str:
+        return _RUN_PREFIX[cfg.package_manager] + command
+
+    def lint(self, cfg: CIConfig, tools: List[str]) -> List[Item]:
+        specs = [_LINT[t] for t in tools]
+        steps = self.install(cfg, sorted({package for _, package, _ in specs}))
+        github = on_github(cfg, " --output-format=github")
+        for name, _, cmd in specs:
+            steps.append(step(name, run=self.exec(cfg, cmd.format(source_dir=cfg.source_dir, github=github))))
+        return steps
+
+    def test(self, cfg: CIConfig) -> List[Item]:
+        t = cfg.test
+        cmd = self.exec(cfg, "pytest")
+        if t.coverage:
+            cmd += (
+                f" --cov={cfg.source_dir} --cov-report=xml --cov-report=term-missing"
+                f" --cov-fail-under={t.coverage_threshold}"
+            )
+        if t.reports:
+            cmd += " --junitxml=junit.xml"
+        steps = self.install(cfg, ["pytest", "pytest-cov"] if t.coverage else ["pytest"])
+        steps.append(step("Tests" + (" with coverage" if t.coverage else ""), run=cmd, secrets=t.env_secrets))
+        if t.coverage:
+            steps.append(coverage_summary(cfg))
+        return steps
+
+    def coverage_file(self, cfg: CIConfig) -> str:
+        return "coverage.xml"
+
+    def reports(self, cfg: CIConfig) -> TestReports:
+        coverage = cfg.test.coverage
+        return TestReports(
+            junit="junit.xml" if cfg.test.runner == "pytest" else "",
+            cobertura="coverage.xml" if coverage else "",
+            coverage_regex=COVERAGE_REGEX if coverage else "",
+        )
+
+    def audit(self, cfg: CIConfig) -> List[Item]:
+        if cfg.package_manager == "uv":
+            # uv venvs have no pip, so audit the locked requirements instead of the environment.
+            return [
+                step(
+                    "Export locked dependencies",
+                    run="uv export --format requirements-txt --no-emit-project --output-file requirements-audit.txt",
+                ),
+                step(
+                    "Dependency vulnerability scan",
+                    run="uvx pip-audit --requirement requirements-audit.txt --require-hashes --disable-pip",
+                ),
+            ]
+        steps = self.install(cfg, ["pip-audit"])
+        steps.append(step("Dependency vulnerability scan", run=self.exec(cfg, "pip-audit --skip-editable")))
+        return steps
+
+    def build(self, cfg: CIConfig) -> List[Item]:
+        return [step("Build", run=cfg.build.command)]
+
+    def build_artifacts(self, det: Detection) -> List[str]:
+        # Wheels and source distributions (uv build, python -m build, poetry build).
+        return ["dist/"] if "build" in det.build_command else []
+
+    def dependabot_ecosystem(self, cfg: CIConfig) -> str:
+        return "uv" if cfg.package_manager == "uv" else "pip"
+
+
+def coverage_summary(cfg: CIConfig) -> Step:
+    """Coverage table in the job summary page, from the data left by pytest-cov or `coverage run`."""
+    return step(
+        "Coverage summary",
+        run=_RUN_PREFIX[cfg.package_manager] + 'coverage report --format=markdown >> "$GITHUB_STEP_SUMMARY"',
+        always=True,
+        optional=True,
+        summary=True,
+    )

quoll/languages/python/detect.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+import re
+from typing import List, Tuple
+
+from quoll.languages.base import Detection
+from quoll.project import Project
+from quoll.services import detect_services
+
+# Used when the project doesn't say which version it targets.
+PYTHON_LATEST = "3.14"
+PYTHON_OLDEST = "3.9"
+
+_REQUIREMENT_FILES = (
+    "requirements.txt",
+    "requirements-dev.txt",
+    "requirements-test.txt",
+    "dev-requirements.txt",
+    "requirements/dev.txt",
+    "requirements/test.txt",
+)
+# Client libraries revealing a backing service.
+_SERVICE_PACKAGES = {
+    "postgres": ("psycopg", "psycopg2", "psycopg2-binary", "psycopg-binary", "asyncpg"),
+    "mysql": ("mysqlclient", "pymysql", "aiomysql", "mysql-connector-python"),
+    "redis": ("redis", "django-redis", "hiredis"),
+    "mongodb": ("pymongo", "motor", "mongoengine", "beanie"),
+}
+# Top-level packages that are never the code under test.
+_NOT_SOURCE = ("tests", "test", "docs", "scripts")
+
+
+def detect(project: Project) -> Detection:
+    det = Detection()
+    pyproject = project.read_toml("pyproject.toml")
+    tool = pyproject.get("tool", {})
+    poetry = tool.get("poetry", {})
+    meta = pyproject.get("project", {})
+
+    _package_manager(project, tool, det)
+    det.install = _install_command(project, pyproject, det)
+
+    requires = meta.get("requires-python") or poetry.get("dependencies", {}).get("python", "")
+    low, high = _python_bounds(requires if isinstance(requires, str) else "")
+    det.matrix_versions = [f"3.{m}" for m in range(low, high + 1)]
+    if project.exists(".python-version"):
+        det.version_file = ".python-version"
+        pinned = project.read_text(".python-version").split()
+        det.version = _major_minor(pinned[0]) if pinned else det.matrix_versions[-1]
+    else:
+        det.version = det.matrix_versions[-1]
+
+    det.source_dir = _source_dir(project, meta.get("name") or poetry.get("name", ""))
+    det.lint_tools = _lint_tools(project, tool)
+
+    has_tests = (
+        project.is_dir("tests")
+        or project.is_dir("test")
+        or project.exists("conftest.py")
+        or "pytest" in tool
+        or has_dependency(project, "pytest")
+    )
+    if has_tests:
+        det.test_runner = "pytest"
+    else:
+        det.warnings.append("No tests found (tests/ directory or pytest dependency) — the test job is disabled.")
+
+    packages = [p for names in _SERVICE_PACKAGES.values() for p in names if has_dependency(project, p)]
+    det.services = detect_services(packages, _SERVICE_PACKAGES)
+
+    if "build-system" in pyproject:
+        det.build_command = {
+            "uv": "uv build",
+            "poetry": "poetry build",
+            "pip": "pip install build\npython -m build",
+        }[det.package_manager]
+    return det
+
+
+def _package_manager(project: Project, tool: dict, det: Detection) -> None:
+    if project.exists("uv.lock") or "uv" in tool:
+        det.package_manager = "uv"
+        det.lockfile = "uv.lock" if project.exists("uv.lock") else ""
+    elif project.exists("poetry.lock") or "poetry" in tool:
+        det.package_manager = "poetry"
+        det.lockfile = "poetry.lock" if project.exists("poetry.lock") else ""
+    else:
+        det.package_manager = "pip"
+
+
+def _install_command(project: Project, pyproject: dict, det: Detection) -> str:
+    if det.package_manager == "uv":
+        if det.lockfile:
+            return "uv sync --locked --all-extras"
+        det.warnings.append("No uv.lock found — run `uv lock` and commit it for reproducible builds.")
+        return "uv sync --all-extras"
+    if det.package_manager == "poetry":
+        if not det.lockfile:
+            det.warnings.append("No poetry.lock found — run `poetry lock` and commit it for reproducible builds.")
+        return "poetry install --no-interaction --all-extras"
+
+    if not project.exists("requirements.txt", "pyproject.toml", "setup.py"):
+        det.warnings.append("No requirements.txt or installable pyproject.toml found — check `install` in quoll.toml.")
+    lines = ["python -m pip install --upgrade pip"]
+    req_files = [f for f in _REQUIREMENT_FILES if project.exists(f)]
+    if req_files:
+        lines.append("pip install " + " ".join(f"-r {f}" for f in req_files))
+    if "build-system" in pyproject or project.exists("setup.py"):
+        optional = pyproject.get("project", {}).get("optional-dependencies", {})
+        extras = [e for e in ("dev", "test", "tests") if e in optional]
+        target = f'".[{",".join(extras)}]"' if extras else "."
+        lines.append(f"pip install -e {target}")
+    groups = [g for g in ("dev", "test") if g in pyproject.get("dependency-groups", {})]
+    if groups:
+        lines.append("pip install " + " ".join(f"--group {g}" for g in groups))
+    return "\n".join(lines)
+
+
+def _lint_tools(project: Project, tool: dict) -> List[str]:
+    precommit = project.read_text(".pre-commit-config.yaml")
+    setup_cfg = project.read_text("setup.cfg")
+    tox_ini = project.read_text("tox.ini")
+    tools: List[str] = []
+    if "ruff" in tool or project.exists("ruff.toml", ".ruff.toml") or has_dependency(project, "ruff"):
+        tools.append("ruff")
+        if "format" in tool.get("ruff", {}) or "ruff-format" in precommit:
+            tools.append("ruff-format")
+    if project.exists(".flake8") or "[flake8]" in setup_cfg or "[flake8]" in tox_ini:
+        tools.append("flake8")
+    if "black" in tool or re.search(r"\bblack\b", precommit):
+        tools.append("black")
+    if "mypy" in tool or project.exists("mypy.ini", ".mypy.ini") or "[mypy]" in setup_cfg:
+        tools.append("mypy")
+    return tools or ["ruff"]
+
+
+def _python_bounds(spec: str) -> Tuple[int, int]:
+    oldest = int(PYTHON_OLDEST.split(".")[1])
+    latest = int(PYTHON_LATEST.split(".")[1])
+    low, high = latest, latest
+    m = re.search(r"(?:>=|\^|~=?|==)\s*3\.(\d+)", spec)
+    if m:
+        low = max(int(m.group(1)), oldest)
+    m = re.search(r"<\s*3\.(\d+)", spec)
+    if m:
+        high = min(int(m.group(1)) - 1, latest)
+    m = re.search(r"<=\s*3\.(\d+)", spec)
+    if m:
+        high = min(int(m.group(1)), latest)
+    return min(low, high), high
+
+
+def _source_dir(project: Project, project_name: str) -> str:
+    if project.is_dir("src"):
+        return "src"
+    for name in (project_name.replace("-", "_").lower(), project.name.replace("-", "_").lower()):
+        if name and project.exists(f"{name}/__init__.py"):
+            return name
+    packages = [p.parent.name for p in project.glob("*/__init__.py") if p.parent.name not in _NOT_SOURCE]
+    return packages[0] if len(packages) == 1 else "."
+
+
+def has_dependency(project: Project, name: str) -> bool:
+    """True when `name` (exactly, not `name-extra`) appears in pyproject.toml or a requirements file."""
+    return bool(re.search(rf"(?<![\w-]){re.escape(name)}(?![\w-])", deps_text(project)))
+
+
+def deps_text(project: Project) -> str:
+    files = [project.read_text("pyproject.toml")]
+    files += [p.read_text() for p in project.glob("requirements*.txt", "requirements/*.txt")]
+    return "\n".join(files).lower()
+
+
+def _major_minor(version: str) -> str:
+    return ".".join(version.strip().split(".")[:2])

quoll/languages/python/docker.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+
+from quoll.languages.base import Detection, DockerDefaults, DockerImage
+from quoll.project import Project
+
+if TYPE_CHECKING:
+    from quoll.docker.config import DockerConfig
+
+UV_IMAGE = "ghcr.io/astral-sh/uv:0.13"
+
+_LOCKFILES = {"uv": "uv.lock", "poetry": "poetry.lock"}
+# Where an application module may live, shallowest first.
+_MODULE_GLOBS = ("*.py", "*/*.py", "src/*/*.py", "*/*/*.py", "src/*/*/*.py")
+_NOT_APP_DIRS = {"tests", "test", ".venv", "venv", "node_modules", "migrations", "docs"}
+
+
+class PythonImage(DockerImage):
+    def defaults(self, project: Project, det: Detection) -> DockerDefaults:
+        command = _default_command(project)
+        warnings = [] if command else ["Couldn't infer how to start the app — set docker.command in quoll.toml."]
+        return DockerDefaults(port=8000, command=command, warnings=warnings)
+
+    def context(self, project: Project, cfg: DockerConfig) -> Dict[str, Any]:
+        lockfile = _LOCKFILES.get(cfg.package_manager, "")
+        return {
+            "uv_image": UV_IMAGE,
+            "lockfile": bool(lockfile) and project.exists(lockfile),
+            "requirements": project.exists("requirements.txt"),
+            "installable": "build-system" in project.read_toml("pyproject.toml") or project.exists("setup.py"),
+            "src_layout": project.is_dir("src"),
+        }
+
+    def dockerignore(self, cfg: DockerConfig) -> List[str]:
+        return [
+            ".venv",
+            "**/__pycache__",
+            "**/*.py[co]",
+            ".pytest_cache",
+            ".mypy_cache",
+            ".ruff_cache",
+            ".coverage",
+            "htmlcov",
+            "dist",
+            "*.egg-info",
+            ".env",
+            ".env.*",
+            "!.env.example",
+        ]
+
+
+def find_app(project: Project, pattern: str) -> Optional[Tuple[str, str]]:
+    """(module, name) of the first `<name> = <pattern>` assignment, e.g. ("app.main", "app") for FastAPI()."""
+    regex = re.compile(rf"^(\w+)\s*(?::\s*\w+\s*)?=\s*{pattern}", re.M)
+    for path in project.glob(*_MODULE_GLOBS):
+        rel = path.relative_to(project.root)
+        if _NOT_APP_DIRS & set(rel.parts):
+            continue
+        m = regex.search(path.read_text(errors="ignore"))
+        if m:
+            parts = list(rel.with_suffix("").parts)
+            if parts[0] == "src":  # importable through PYTHONPATH=/app/src
+                parts = parts[1:]
+            return ".".join(parts), m.group(1)
+    return None
+
+
+def _default_command(project: Project) -> str:
+    scripts = project.read_toml("pyproject.toml").get("project", {}).get("scripts", {})
+    if scripts:
+        return next(iter(scripts))
+    for main in project.glob("*/__main__.py", "src/*/__main__.py"):
+        if main.parent.name not in _NOT_APP_DIRS:
+            return f"python -m {main.parent.name}"
+    for name in ("main.py", "app.py", "src/main.py", "src/app.py"):
+        if project.exists(name):
+            return f"python {name}"
+    return ""

quoll/languages/python/frameworks/__init__.py

@@ -0,0 +1 @@
+"""Python frameworks."""

quoll/languages/python/frameworks/django/__init__.py

@@ -0,0 +1,16 @@
+"""Django: system checks and missing migrations fail the lint job; tests run through manage.py or pytest-django."""
+
+from quoll.languages.base import Framework
+from quoll.languages.python.frameworks.django.ci import DjangoCI
+from quoll.languages.python.frameworks.django.detect import detect
+from quoll.languages.python.frameworks.django.docker import DjangoImage
+
+framework = Framework(
+    name="django",
+    language="python",
+    detect=detect,
+    ci=DjangoCI(),
+    lint_tools=("django-check", "django-migrations"),
+    test_runners=("django",),
+    docker=DjangoImage(),
+)

quoll/languages/python/frameworks/django/ci.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List
+
+from quoll.ci.steps import Item, step
+from quoll.languages.base import FrameworkCI
+from quoll.languages.python.ci import coverage_summary
+
+if TYPE_CHECKING:
+    from quoll.ci.config import CIConfig
+
+# tool: (step name, command)
+_LINT = {
+    "django-check": ("Django system checks", "python manage.py check"),
+    "django-migrations": ("Missing migrations", "python manage.py makemigrations --check --dry-run"),
+}
+
+
+class DjangoCI(FrameworkCI):
+    def lint(self, cfg: CIConfig, tool: str) -> List[Item]:
+        name, cmd = _LINT[tool]
+        return [step(name, run=cfg.language.ci.exec(cfg, cmd))]
+
+    def test(self, cfg: CIConfig) -> List[Item]:
+        t = cfg.test
+        ci = cfg.language.ci
+        if not t.coverage:
+            return [*ci.install(cfg), step("Tests", run=ci.exec(cfg, "python manage.py test"), secrets=t.env_secrets)]
+        return [
+            *ci.install(cfg, ["coverage"]),
+            step(
+                "Tests with coverage",
+                run=ci.exec(cfg, f"coverage run --source={cfg.source_dir} manage.py test"),
+                secrets=t.env_secrets,
+            ),
+            step(
+                "Coverage threshold",
+                run="\n".join(
+                    [ci.exec(cfg, "coverage xml"), ci.exec(cfg, f"coverage report --fail-under={t.coverage_threshold}")]
+                ),
+            ),
+            coverage_summary(cfg),
+        ]

quoll/languages/python/frameworks/django/detect.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from quoll.languages.base import Detection
+from quoll.languages.python.detect import has_dependency
+from quoll.project import Project
+
+
+def detect(project: Project, det: Detection) -> bool:
+    if not has_dependency(project, "django") or not project.exists("manage.py"):
+        return False
+    det.lint_tools += ["django-check", "django-migrations"]
+    # Apps sit next to the settings package, so measure the whole project.
+    det.source_dir = "."
+    # pytest-django brings pytest; otherwise manage.py finds the tests.py of each app.
+    det.test_runner = "pytest" if has_dependency(project, "pytest-django") else "django"
+    det.warnings = [w for w in det.warnings if not w.startswith("No tests found")]
+    return True

quoll/languages/python/frameworks/django/docker.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import re
+
+from quoll.languages.base import Detection, DockerDefaults
+from quoll.languages.python.detect import has_dependency
+from quoll.languages.python.docker import PythonImage
+from quoll.project import Project
+
+
+class DjangoImage(PythonImage):
+    def defaults(self, project: Project, det: Detection) -> DockerDefaults:
+        m = re.search(r"DJANGO_SETTINGS_MODULE[\"']\s*,\s*[\"']([\w.]+)\.settings", project.read_text("manage.py"))
+        module = m.group(1) if m else project.name.replace("-", "_")
+        warnings = []
+        if not has_dependency(project, "gunicorn"):
+            warnings.append("Add gunicorn to your dependencies: the image serves the app with it.")
+        if not has_dependency(project, "whitenoise"):
+            warnings.append("Django doesn't serve static files in production — add WhiteNoise or serve them elsewhere.")
+        return DockerDefaults(port=8000, command=f"gunicorn {module}.wsgi --bind 0.0.0.0:8000", warnings=warnings)

quoll/languages/python/frameworks/fastapi/__init__.py

@@ -0,0 +1,7 @@
+"""FastAPI: CI is plain Python; the framework matters for how the app is served."""
+
+from quoll.languages.base import Framework
+from quoll.languages.python.frameworks.fastapi.detect import detect
+from quoll.languages.python.frameworks.fastapi.docker import FastapiImage
+
+framework = Framework(name="fastapi", language="python", detect=detect, docker=FastapiImage())

quoll/languages/python/frameworks/fastapi/detect.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from quoll.languages.base import Detection
+from quoll.languages.python.detect import has_dependency
+from quoll.project import Project
+
+
+def detect(project: Project, det: Detection) -> bool:
+    return has_dependency(project, "fastapi")

quoll/languages/python/frameworks/fastapi/docker.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from quoll.languages.base import Detection, DockerDefaults
+from quoll.languages.python.detect import deps_text, has_dependency
+from quoll.languages.python.docker import PythonImage, find_app
+from quoll.project import Project
+
+
+class FastapiImage(PythonImage):
+    def defaults(self, project: Project, det: Detection) -> DockerDefaults:
+        warnings = []
+        app = find_app(project, r"FastAPI\(")
+        if app is None:
+            app = ("main", "app")
+            warnings.append("No `app = FastAPI()` found — check docker.command in quoll.toml.")
+        if not has_dependency(project, "uvicorn") and "fastapi[standard" not in deps_text(project):
+            warnings.append("Add uvicorn (or fastapi[standard]) to your dependencies: the image runs the app with it.")
+        module, name = app
+        return DockerDefaults(
+            port=8000, command=f"uvicorn {module}:{name} --host 0.0.0.0 --port 8000", warnings=warnings
+        )

quoll/languages/python/frameworks/flask/__init__.py

@@ -0,0 +1,7 @@
+"""Flask: CI is plain Python; the framework matters for how the app is served."""
+
+from quoll.languages.base import Framework
+from quoll.languages.python.frameworks.flask.detect import detect
+from quoll.languages.python.frameworks.flask.docker import FlaskImage
+
+framework = Framework(name="flask", language="python", detect=detect, docker=FlaskImage())

quoll/languages/python/frameworks/flask/detect.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from quoll.languages.base import Detection
+from quoll.languages.python.detect import has_dependency
+from quoll.project import Project
+
+
+def detect(project: Project, det: Detection) -> bool:
+    return has_dependency(project, "flask")

quoll/languages/python/frameworks/flask/docker.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from quoll.languages.base import Detection, DockerDefaults
+from quoll.languages.python.detect import has_dependency
+from quoll.languages.python.docker import PythonImage, find_app
+from quoll.project import Project
+
+
+class FlaskImage(PythonImage):
+    def defaults(self, project: Project, det: Detection) -> DockerDefaults:
+        warnings = []
+        app = find_app(project, r"Flask\(")
+        if app:
+            target = f"{app[0]}:{app[1]}"
+        else:
+            factory = find_app(project, r"create_app\(")  # e.g. `app = create_app()` in wsgi.py
+            target = f"{factory[0]}:{factory[1]}" if factory else "app:app"
+            if not factory:
+                warnings.append("No `app = Flask(...)` found — check docker.command in quoll.toml.")
+        if not has_dependency(project, "gunicorn"):
+            warnings.append("Add gunicorn to your dependencies: the image serves the app with it.")
+        return DockerDefaults(port=8000, command=f"gunicorn {target} --bind 0.0.0.0:8000", warnings=warnings)

quoll/languages/ruby/Dockerfile.j2

@@ -0,0 +1,45 @@
+{% block base %}
+FROM ruby:{{ cfg.version }}-slim AS base
+{{ os_updates }}
+WORKDIR {{ workdir }}
+{% if runtime_packages %}
+RUN apt-get update -qq \
+    && apt-get install --no-install-recommends -y {{ runtime_packages | join(" ") }} \
+    && rm -rf /var/lib/apt/lists/*
+{% endif %}
+ENV {% for key, value in env.items() %}{{ key }}={{ value }}{{ " \\\n    " if not loop.last }}{% endfor %}
+
+{% endblock %}
+
+{% block build %}
+FROM base AS build
+RUN apt-get update -qq \
+    && apt-get install --no-install-recommends -y {{ (["build-essential", "git", "pkg-config", "libyaml-dev"] + build_packages) | join(" ") }} \
+    && rm -rf /var/lib/apt/lists/*
+{% if gemspec %}
+# The Gemfile reads the gemspec, which needs the sources.
+COPY . .
+RUN {{ bundle_install | join(" \\\n    && ") }}
+{% else %}
+# Dependencies first: code changes don't reinstall them.
+COPY Gemfile {{ "Gemfile.lock " if lockfile }}{{ ".ruby-version " if ruby_version_file }}./
+RUN {{ bundle_install | join(" \\\n    && ") }}
+COPY . .
+{% endif %}
+{% for command in after_copy %}
+RUN {{ command }}
+{% endfor %}
+{% endblock %}
+
+{% block runtime %}
+FROM base
+{% block user %}
+# A numeric user: Kubernetes can then check it isn't root (runAsNonRoot).
+RUN groupadd --system --gid 10001 app && useradd --system --uid 10001 --gid app --no-create-home app
+COPY --from=build /usr/local/bundle /usr/local/bundle
+COPY --from=build --chown=app:app {{ workdir }} {{ workdir }}
+USER 10001:10001
+{% endblock %}
+EXPOSE {{ cfg.port }}
+CMD {{ cfg.command | exec_form }}
+{% endblock %}

quoll/languages/ruby/__init__.py

@@ -0,0 +1,19 @@
+"""Ruby: Bundler projects and gems."""
+
+from quoll.languages.base import Language
+from quoll.languages.ruby.ci import RubyCI
+from quoll.languages.ruby.detect import detect
+from quoll.languages.ruby.docker import RubyImage
+from quoll.languages.ruby.frameworks import rails
+
+language = Language(
+    name="ruby",
+    markers=("Gemfile",),
+    package_managers=("bundler",),
+    lint_tools=("rubocop", "standard"),
+    test_runners=("rspec", "minitest"),
+    detect=detect,
+    ci=RubyCI(),
+    frameworks=(rails.framework,),
+    docker=RubyImage(),
+)