Author SHA1 Message Date
clawbot f4b9dda15f REPO_POLICIES: Other conventions (closes #158)
check / check (push) Successful in 12s
Only a heading: the reorder gathered these five rules, and none
repeats another, so no text is cut.

Model: opus-5-5
2026-11-16 23:53:42 +00:00
clawbot 24a17ce434 REPO_POLICIES: Repository layout
check / check (push) Canceled after 0s
Joins the first-commit rule to the paragraph on setting up a new repo
from the prompts repo's files; no rule is cut.

Model: opus-5-5
2026-11-16 23:53:12 +00:00
clawbot 9c6f4eb2de REPO_POLICIES: README
check / check (push) Canceled after 0s
Cuts "and a License section in the README" from the License item,
which is itself that required section; every required section stays.

Model: opus-5-5
2026-11-16 23:52:42 +00:00
clawbot 9e33c06c65 REPO_POLICIES: Database migrations
check / check (push) Canceled after 0s
Only a heading: the migration rules repeat nothing, so no text is cut.

Model: opus-5-5
2026-11-16 23:52:14 +00:00
clawbot a268799e97 REPO_POLICIES: Web services
check / check (push) Canceled after 0s
Merges the WriteTimeout and IdleTimeout items, folds "Never trust
X-Forwarded-For unconditionally" into the sentence on trusted proxies,
and cuts "This list is non-exhaustive", which "without limitation" in
the rule already says; every hardening measure stays.

Model: opus-5-5
2026-11-16 23:51:53 +00:00
clawbot ca24c6b7ff REPO_POLICIES: Formatting
check / check (push) Canceled after 0s
Only a heading: the reorder put the formatter and .editorconfig rules
together, and neither repeats another rule, so no text is cut.

Model: opus-5-5
2026-11-16 23:51:06 +00:00
clawbot a13d1726b6 REPO_POLICIES: .golangci.yml
check / check (push) Canceled after 0s
Only a heading: the paragraph repeats nothing stated elsewhere, so its
words stay as on next.

Model: opus-5-5
2026-11-16 23:50:43 +00:00
clawbot 2bc68d1f1e REPO_POLICIES: .gitignore and .dockerignore
check / check (push) Canceled after 0s
Moves the warning not to copy .gitignore patterns into .dockerignore
next to the .dockerignore rule, splits the two long paragraphs into
lists, and cuts the history "since consuming repos receive the file
and not the tracker"; every pattern rule stays.

Model: opus-5-5
2026-11-16 23:50:06 +00:00
clawbot 64b8139d44 REPO_POLICIES: CI
check / check (push) Canceled after 0s
Splits the one long paragraph into the four workflow settings, what
script/cibuild does, and the separate-workflow rule; merges the two
descriptions of script/cibuild and drops the sentence that names it,
which Entrypoints states; every setting and its reason stays.

Model: opus-5-5
2026-11-16 23:49:10 +00:00
clawbot e80de25c48 REPO_POLICIES: Version
check / check (push) Canceled after 0s
Cuts the fetch-depth sentence, which the CI section states, and moves
the reason ARG VERSION sits in the stage that compiles next to the
sentence saying it has no default; every rule stays.

Model: opus-5-5
2026-11-16 23:48:15 +00:00
clawbot 57d993ca21 REPO_POLICIES: Python test phase
check / check (push) Canceled after 0s
Cuts the Python make test recipe, which repeats the command in
examples/python-test-phase.Dockerfile, and lists how such a target
behaves on a host; drops the no-node sentence, stated under node and
yarn, and the shared-timeout sentence, which the example's comment
states; trims two sentences; every rule stays.

Model: opus-5-5
2026-11-16 23:45:32 +00:00
clawbot e3f3160fad REPO_POLICIES: Canonical Go Dockerfile
check / check (push) Canceled after 0s
Cuts the Go make test recipe, which repeats the command in
examples/go.Dockerfile, and turns its notes into three key points;
drops key points stated elsewhere (the no-op copies and the last
stage under Dockerfile, when Docker installs again under Docker's
cache, the Python layer under the Python section) and "BuildKit runs
stages in parallel"; every rule stays.

Model: opus-5-5
2026-11-16 23:43:40 +00:00
clawbot c166d20195 REPO_POLICIES: Docker's cache
check / check (push) Canceled after 0s
Only a heading: the cache rule from next stays word for word, and
nothing here repeats another section.

Model: opus-5-5
2026-11-16 23:42:06 +00:00
clawbot 99c8e425da REPO_POLICIES: Dockerfile
check / check (push) Canceled after 0s
Cuts history ("Both have produced wrong verdicts"), an example given
for a stated reason (the Go image's toolchain), the tag sentence that
the version snippet's comment states, and the short cache list that
the Go section gives in full; takes in the rule to keep the stage that
ships last, which the Go section's commit removes; every rule stays.

Model: opus-5-5
2026-11-16 23:41:36 +00:00
clawbot e13195dd84 REPO_POLICIES: Pinned tools
check / check (push) Canceled after 0s
The POSIX sh rule joins the list of what the canonical form does, and
two sentences lose filler ("installing into a clean image", "which
then succeeds while no caller sees any change"); each step of the
canonical form and the go install rule stay.

Model: opus-5-5
2026-11-16 23:40:00 +00:00
clawbot 410b9b1621 REPO_POLICIES: node and yarn
check / check (push) Canceled after 0s
States once that a stage with no yarn.lock gets no node and no yarn,
which two paragraphs here said; puts the short lists of yarn settings
and of the files a yarn stage copies inline; joins the two sentences
on Alpine's and Debian's yarn; every setting, file and condition
stays.

Model: opus-5-5
2026-11-16 23:39:10 +00:00
clawbot 81cfb9be83 REPO_POLICIES: script/bootstrap
check / check (push) Canceled after 0s
Merges the two statements that a distribution tool is installed only
when missing into one bullet that also says where such tools come
from; the exact-version rule for other tools is the second bullet;
nothing else was there.

Model: opus-5-5
2026-11-16 23:37:51 +00:00
clawbot 2f9f3dd622 REPO_POLICIES: Tests and checks
check / check (push) Canceled after 0s
States once, under the rerun pattern, that a timed-out first run gets
no rerun and a hung package uses the backstop once, which three rules
each said; splits the timeout rule from the 60-second rule and trims
wording; names the examples that carry the command, and that a
Makefile writes each $ as $$, since the Go and Python recipes go in
their sections' commits; every limit stays.

Model: opus-5-5
2026-11-16 23:37:18 +00:00
clawbot 93de4f1758 REPO_POLICIES: Entrypoints
check / check (push) Canceled after 0s
One list now pairs each required target with its script, and one
lists the three scripts with no required target, absorbing the list
of extensions and the pre-commit hook rule; the README sentence goes,
since the README section requires the same; every target, script and
condition stays.

Model: opus-5-5
2026-11-16 23:36:08 +00:00
clawbot 45c0f997b7 REPO_POLICIES: Git and secrets
check / check (push) Canceled after 0s
Only a heading and a comma before "because" in the build-artifact
exception: the reorder already put these five rules together, and
none is cut.

Model: opus-5-5
2026-11-16 23:34:37 +00:00
clawbot 287ffdf43e REPO_POLICIES: Pin external references by hash
check / check (push) Canceled after 0s
Merges the list of what is pinned with each one's hash, the two
warnings with the untrusted sources, the version comment and the
double-check, and the distribution's tools with what is ruled out;
every item is kept.

Model: opus-5-5
2026-11-16 23:33:53 +00:00
clawbot 4cce747e00 REPO_POLICIES: order the rules by section, moving text only
check / check (push) Canceled after 0s
Moves whole bullets, and whole paragraphs inside them, into the order
of the sections that the next commits add. No line changes:
git show --color-moved shows every changed line as moved, and the
sorted lines of the file are identical before and after.

Paragraphs that later join another section sit under the nearest
bullet until that section's commit.

Model: opus-5-5
2026-11-16 23:31:48 +00:00
clawbot 48c7faf557 REPO_POLICIES: move the example Dockerfiles into examples/
check / check (push) Canceled after 0s
Each fenced dockerfile block moves byte for byte into its own file
under examples/, and one sentence links the file where the block
stood, as sneak ruled at
#159 (comment).
Phrases that pointed at a block by position now name the file, here
and in both checklists. README.md names the folder. No rule changes.

Model: opus-5-5
2026-11-16 23:24:36 +00:00
clawbot 964d973e3c Check builds use Docker's normal cache (closes #177)
check / check (push) Successful in 12s
Drop the CACHEBUST build argument from script/lint, script/test,
script/docker, script/cibuild and every Dockerfile stage. REPO_POLICIES
now says check builds use Docker's normal cache: an unchanged tree reuses
each step's stored result, which Docker keeps only for steps that
succeeded. The rules on placing ARG CACHEBUST and re-vendoring it in one
commit are gone; the rule that a planted defect proves a new or changed
check stays. The README, the Go style guide and both checklists restated
the cache-busting rules and are updated to match. The existing-repo
checklist asks that no script pass --no-cache or CACHEBUST.

Model: opus-5-5
2026-11-16 23:09:07 +01:00
clawbot 1ad7ae14be CODE_STYLEGUIDE_GO: propose naming rules for packages and exported names (closes #174) (#175)
check / check (push) Successful in 1m46s
Proposal for the naming-rules issue, #174: a Naming section in `prompts/CODE_STYLEGUIDE_GO.md`, twenty-seven rules, each with its reason. Nothing is renamed in any repo until sneak approves or amends them.

Where each rule comes from:

- Package names
    - Named for what the package provides; lowercase with words run together; only familiar abbreviations: Effective Go and the Go blog post "Package names".
    - No `model`, `util`, `common`, `types`, `helpers`, `api` and the like, and splitting such packages: sneak on `model`; "Package names"; Go Code Review Comments; the Go Style Guide, which also lists `model`.
    - No name a caller wants for a variable or a standard package has: "Package names"; the Go Style Guide.
    - Directory named as the package: Effective Go.
    - Test-support packages named like `storetest`; import names: the Go Style Guide.
- Exported names
    - No package name repeated; the same plain name in two packages: Effective Go; "Package names"; Code Review Comments.
    - Types in a name; noun or verb; `Fetch` for a getter that reads from a database or the network: the Go Style Guide.
    - No `Get`; `er` interfaces; well-known method names: Effective Go.
    - Initialisms; MixedCaps constants: Code Review Comments; the Go Style Guide.
    - `ErrNotFound` and `NotFoundError`: the Go wiki page "Errors", which is not one of the four sources.
- Local names (length by scope; receivers): Code Review Comments; the Go Style Guide.

The first comment lists the renames and the judgement calls.

Model: fable-5-2 (proposal); opus-5-5 (rework)
Reviewed-on: #175
Co-authored-by: clawbot <35+clawbot@noreply.example.org>
2026-11-16 22:02:05 +01:00
clawbot 69d38ba6de README: remove the Template Repos section (closes #153)
check / check (push) Successful in 1m47s
Every repository the section linked returned 404 to a signed-out
reader: `template-app-js` and `template-app-python` do not exist, and
`template-app-go` is private. The section is gone, intro included.

Model: opus-5-5
2026-11-15 17:39:12 +01:00
clawbot 198b896a53 Correct the phase-build comments in script/lint and script/test (closes #141)
check / check (push) Successful in 35s
The comments said a phase that is not the last stage is built only when
--target names it. The canonical Dockerfile's last stage copies from both
phases, so a plain build builds them too. The comments now say what
--target does in every repository: it builds that phase and the stages
it depends on, nothing else. The headers no longer say each script
builds its phase alone, which is false wherever the phase depends on
another stage.

Model: opus-5-5
2026-11-15 17:09:08 +01:00
clawbot 11245b85ca script/install-precommit: write the hook through $hook (closes #139)
check / check (push) Successful in 1m41s
The script set hook and then repeated the path literally, so shellcheck
reported the variable as unused (SC2034).

Model: opus-5-5
2026-11-15 14:23:52 +01:00
clawbot 02632a5682 Drop the TODO.md union-merge rule (closes #169)
check / check (push) Successful in 1m46s
The rule and its comment existed only so concurrent PRs could each add a
Completed Steps entry to `TODO.md`. That work log is gone; `TODO.md` now
holds only open work, so it merges normally again.

Model: opus-5-5
2026-11-15 07:38:36 +01:00
clawbot fdf517a1f7 TODO.md: remove the work log, keep only open work (closes #167)
check / check (push) Successful in 1m44s
Drop the Completed Steps log and the finished "commit this TODO.md"
item. Git keeps the history. The Workflow section now says to delete
the finished Next Step, as the standard Workflow block does.

Model: opus-5-5
2026-11-15 07:08:44 +01:00
15 changed files with 872 additions and 1002 deletions

No files matched your search

-5
View File
@@ -1,7 +1,2 @@
# Every PR adds an entry at the top of TODO.md's Completed Steps; union keeps
# both sides instead of conflicting. Git never reports a conflict here: read
# the merged entries after every merge or rebase.
TODO.md merge=union
# yarn's release file is one opaque file in diffs and merges. # yarn's release file is one opaque file in diffs and merges.
.yarn/releases/** binary .yarn/releases/** binary
+4 -10
View File
@@ -2,18 +2,14 @@
# lint` or `script/lint`, which are themselves a docker build and would # lint` or `script/lint`, which are themselves a docker build and would
# recurse into a daemon that does not exist in a build step. # recurse into a daemon that does not exist in a build step.
# #
# In every stage, ARG CACHEBUST comes right after the step that installs # node and yarn come from the distribution, which is trusted, so they
# system packages. script/ passes a new value on every build. That value # need no version and no hash. That yarn only starts the release file in
# reruns every RUN step below the ARG line, and the install step keeps # .yarn/releases/, so every stage copies that file and .yarnrc.yml
# its layer. node and yarn come from the distribution, which is trusted, # before it runs script/bootstrap.
# so they need no version and no hash. That yarn only starts the release
# file in .yarn/releases/, so every stage copies that file and
# .yarnrc.yml before it runs script/bootstrap.
# #
# alpine 3.24.3, 2026-11-04 # alpine 3.24.3, 2026-11-04
FROM alpine@sha256:be2656061b536c1883c4034790e21d0a09c5aaaf51968b89368a3c0371ea2c9a AS lint FROM alpine@sha256:be2656061b536c1883c4034790e21d0a09c5aaaf51968b89368a3c0371ea2c9a AS lint
RUN apk add --no-cache git make nodejs-current yarn RUN apk add --no-cache git make nodejs-current yarn
ARG CACHEBUST
WORKDIR /app WORKDIR /app
@@ -31,7 +27,6 @@ RUN yarn run prettier --check '**/*.md' --tab-width 4 --prose-wrap always
# alpine 3.24.3, 2026-11-04 # alpine 3.24.3, 2026-11-04
FROM alpine@sha256:be2656061b536c1883c4034790e21d0a09c5aaaf51968b89368a3c0371ea2c9a AS test FROM alpine@sha256:be2656061b536c1883c4034790e21d0a09c5aaaf51968b89368a3c0371ea2c9a AS test
RUN apk add --no-cache git make nodejs-current yarn RUN apk add --no-cache git make nodejs-current yarn
ARG CACHEBUST
WORKDIR /app WORKDIR /app
@@ -53,7 +48,6 @@ RUN timeout 90 test/update-policy.sh
# alpine 3.24.3, 2026-11-04 # alpine 3.24.3, 2026-11-04
FROM alpine@sha256:be2656061b536c1883c4034790e21d0a09c5aaaf51968b89368a3c0371ea2c9a FROM alpine@sha256:be2656061b536c1883c4034790e21d0a09c5aaaf51968b89368a3c0371ea2c9a
RUN apk add --no-cache git make nodejs-current yarn RUN apk add --no-cache git make nodejs-current yarn
ARG CACHEBUST
WORKDIR /app WORKDIR /app
+11 -42
View File
@@ -116,12 +116,10 @@ alpine. We provide:
`script/bootstrap`, then `script/install-precommit` `script/bootstrap`, then `script/install-precommit`
- `script/projectname` — output the project name (our own extension); used by - `script/projectname` — output the project name (our own extension); used by
`script/docker` for the image tag `script/docker` for the image tag
- `script/test` — - `script/test` — `docker build --target test --output type=cacheonly .`,
`docker build --build-arg CACHEBUST="$(date +%s)-$$" --target test --output type=cacheonly .`,
building the `test` phase of the `Dockerfile`, which runs building the `test` phase of the `Dockerfile`, which runs
`test/update-policy.sh`, without writing an image `test/update-policy.sh`, without writing an image
- `script/lint` — - `script/lint` — `docker build --target lint --output type=cacheonly .`,
`docker build --build-arg CACHEBUST="$(date +%s)-$$" --target lint --output type=cacheonly .`,
building the `lint` phase, which runs prettier over the markdown files, building the `lint` phase, which runs prettier over the markdown files,
without writing an image without writing an image
- `script/fmt` — format all markdown files with prettier (writes; native, not in - `script/fmt` — format all markdown files with prettier (writes; native, not in
@@ -129,14 +127,13 @@ alpine. We provide:
- `script/fmt-check` — check formatting (read-only; native) - `script/fmt-check` — check formatting (read-only; native)
- `script/check` — run all checks: `test`, `lint`, `fmt-check` (our own - `script/check` — run all checks: `test`, `lint`, `fmt-check` (our own
extension); builds no image of its own extension); builds no image of its own
- `script/docker` — - `script/docker` — `docker build --build-arg VERSION="$version" -t prompts .`,
`docker build --build-arg CACHEBUST="$(date +%s)-$$" --build-arg VERSION="$version" -t prompts .`,
the tag coming from `script/projectname` (byte-identical across repos) the tag coming from `script/projectname` (byte-identical across repos)
- `script/cibuild` — cd to the repo root, run `script/bootstrap`, run - `script/cibuild` — cd to the repo root, run `script/bootstrap`, run
`script/check`, compute `version` from `git describe`, then `script/check`, compute `version` from `git describe`, then
`docker build --build-arg CACHEBUST="$(date +%s)-$$" --build-arg VERSION="$version" -t prompts .` `docker build --build-arg VERSION="$version" -t prompts .` (what CI runs; it
(what CI runs; it bootstraps because CI checks out and runs this alone while bootstraps because CI checks out and runs this alone while `script/fmt-check`
`script/fmt-check` is native) is native)
- `script/precommit` — run by the git pre-commit hook (our own extension); calls - `script/precommit` — run by the git pre-commit hook (our own extension); calls
`script/check` `script/check`
- `script/install-precommit` — installs the git pre-commit hook (our own - `script/install-precommit` — installs the git pre-commit hook (our own
@@ -147,22 +144,9 @@ alpine. We provide:
`make hooks` installs the pre-commit hook that runs `script/precommit`. `make hooks` installs the pre-commit hook that runs `script/precommit`.
In every stage of a `Dockerfile`, every step that lints, tests or compiles comes The builds use Docker's normal cache: a step runs again only when its inputs
after `ARG CACHEBUST`. `ARG CACHEBUST` comes right after these steps: change. This repo's own `Dockerfile` installs git, make, node and yarn right
after `FROM` in every stage, so a change to `script/` keeps that layer.
- the steps that install system packages
- the steps that download Go's modules
- the step that runs `script/bootstrap` to install a Python `test` phase's
packages from `Pipfile.lock`
A stage with none of these steps declares `ARG CACHEBUST` right after `FROM`.
The `script/` builds pass a new `CACHEBUST` value on every build, which reruns
every `RUN` step after that line and leaves the layers above it and the cache
mounts in place; `--no-cache` would build those layers again and empty the
mounts. This repo's own `Dockerfile` installs git, make, node and yarn right
after `FROM` in every stage, above `ARG CACHEBUST`. `script/bootstrap` installs
the node packages below that line, because check builds keep system packages but
not node packages.
## Rationale ## Rationale
@@ -175,23 +159,8 @@ share, and evolve prompts across projects.
The repository is a collection of Markdown files organized in the `prompts/` The repository is a collection of Markdown files organized in the `prompts/`
subdirectory. Each file contains one or more related prompts or policy subdirectory. Each file contains one or more related prompts or policy
documents. There is no build step or runtime component; the prompts are consumed documents. There is no build step or runtime component; the prompts are consumed
by copying them into other projects or referencing them directly. by copying them into other projects or referencing them directly. `examples/`
holds the example `Dockerfile` files that `prompts/REPO_POLICIES.md` links to.
## Template Repos
These template repositories implement the policies defined in this repo and
serve as starting points for new projects. They must be kept in sync when
policies change.
- **[template-app-go](https://git.eeqj.de/sneak/template-app-go)** — Go HTTP
server template (Uber fx, chi, SQLite, session auth, Prometheus metrics)
- **[template-app-js](https://git.eeqj.de/sneak/template-app-js)** — JavaScript
SPA template (Vite, Tailwind CSS v4, nginx Docker deployment)
- **[template-app-python](https://git.eeqj.de/sneak/template-app-python)** —
Python web application template (FastAPI, uvicorn, pytest, black, ruff)
When updating policies in this repo, also update the template repos to match
(Makefile targets, Dockerfile conventions, CI workflows, required files, etc.).
## See Also ## See Also
@@ -0,0 +1,7 @@
FROM golangci/golangci-lint@sha256:... AS lint
RUN apt-get update \
&& apt-get install -y --no-install-recommends libvips-dev \
&& rm -rf /var/lib/apt/lists/*
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
+77
View File
@@ -0,0 +1,77 @@
# The steps that install system packages and download Go's modules
# come before COPY . ., so a change to the code keeps their layers.
# The steps that compile mount Go's build cache, and golangci-lint run
# also mounts golangci-lint's; both survive from build to build.
# Lint phase
# golangci/golangci-lint:v2.x.x, YYYY-MM-DD
FROM golangci/golangci-lint@sha256:... AS lint
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN --mount=type=cache,target=/root/.cache/go-build \
--mount=type=cache,target=/root/.cache/golangci-lint \
golangci-lint run --config .golangci.yml ./...
# Test phase. -race needs cgo and so a C compiler, which the Debian Go
# image ships and the alpine one does not. -count=1 because the mounted
# cache also holds test results, which go test would otherwise replay.
# A first run that timed out gets no rerun, because a rerun would only
# wait for the same hang.
# golang:1.x, YYYY-MM-DD
FROM golang@sha256:... AS test
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN --mount=type=cache,target=/root/.cache/go-build \
status=0; \
output=$(go test -count=1 -timeout 90s -race -cover ./... 2>&1) || status=$?; \
printf '%s\n' "$output"; \
test "$status" -eq 0 && exit 0; \
case "$output" in \
*"panic: test timed out"*|*"*** Test killed"*) exit 1 ;; \
esac; \
echo "--- Rerunning with -v for details ---"; \
go test -count=1 -timeout 90s -race -v ./...; \
exit 1
# Build stage. Nothing is wanted from either phase above; the copies
# are what make BuildKit build them first, so nothing after them can
# run unless lint and test passed.
# golang:1.x-alpine, YYYY-MM-DD
FROM golang@sha256:... AS builder
# git comes from the base image's own distribution package index, which
# is trusted, so it needs no version and no hash.
RUN apk add --no-cache git
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY --from=lint /src/go.sum /dev/null
COPY --from=test /src/go.sum /dev/null
# A tar-stream context keeps the sender's file owners, which git refuses.
RUN git config --system --add safe.directory /src
COPY . .
# The VERSION build arg when one is given, otherwise
# `git describe --tags --always` on the .git in the build context. With
# .git present, a version that is still empty, dev or unknown fails the
# build: git is missing or could not read the checkout.
ARG VERSION
RUN --mount=type=cache,target=/root/.cache/go-build \
VERSION="${VERSION:-$(git describe --tags --always)}"; \
if [ -e .git ]; then \
case "$VERSION" in ""|dev|unknown) \
echo "version is '$VERSION' although .git is present" >&2; \
exit 1 ;; \
esac; \
fi; \
CGO_ENABLED=0 go build -trimpath \
-ldflags="-s -w -X main.Version=${VERSION}" \
-o /app ./cmd/app/
# Runtime stage, and the last one
FROM alpine@sha256:...
COPY --from=builder /app /usr/local/bin/app
ENTRYPOINT ["app"]
+23
View File
@@ -0,0 +1,23 @@
# Test phase. Both pytest runs share one 90-second timeout, so a hang
# uses it once and gets no rerun.
# debian:trixie-slim, YYYY-MM-DD
FROM debian@sha256:... AS test
# Python, pip and venv come from the distribution, which is trusted, so
# they need no version and no hash. make and git are base tools that
# script/bootstrap installs when they are missing. Installed here, they
# stay in their own layer when script/ changes.
RUN apt-get update \
&& apt-get install -y --no-install-recommends ca-certificates make git \
python3 python3-venv \
&& rm -rf /var/lib/apt/lists/*
# script/bootstrap installs pipenv in a virtual environment at
# $HOME/.pipenv, and the tests below run that pipenv.
ENV PATH=/root/.pipenv/bin:$PATH
WORKDIR /app
COPY script/ script/
COPY Pipfile Pipfile.lock ./
RUN script/bootstrap
COPY . .
RUN timeout 90 sh -c 'pipenv run pytest || { \
echo "--- Rerunning with -v for details ---"; \
pipenv run pytest -v; exit 1; }'
+120 -10
View File
@@ -1,6 +1,6 @@
--- ---
title: Code Styleguide — Go title: Code Styleguide — Go
last_modified: 2026-11-07 last_modified: 2026-11-16
--- ---
1. Format Go code with `gofmt` and then `golines -m 77`, through `make fmt`. 1. Format Go code with `gofmt` and then `golines -m 77`, through `make fmt`.
@@ -113,13 +113,7 @@ last_modified: 2026-11-07
1. Write a `Dockerfile` for every repo, even if it only runs the tests and 1. Write a `Dockerfile` for every repo, even if it only runs the tests and
linting. It carries the lint and test phases, and the final stage depends on linting. It carries the lint and test phases, and the final stage depends on
both, so a build makes sure the code is in an able-to-be-compiled state, both, so a build makes sure the code is in an able-to-be-compiled state,
linted, and its tests run. Go through `script/cibuild` or `script/docker` linted, and its tests run.
rather than a bare `docker build .`: they pass a new `CACHEBUST` value on
every build, which reruns every step that lints, tests or compiles and keeps
the system packages, Go's modules and build cache, and golangci-lint's
cache; `--no-cache` would throw all of them away. Without a new value an
unchanged tree serves the gate layers from cache and the build reports a
green it never ran.
1. Every repo must have a `Makefile`. See 1. Every repo must have a `Makefile`. See
[Repository Policies](https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/REPO_POLICIES.md) [Repository Policies](https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/REPO_POLICIES.md)
@@ -176,7 +170,7 @@ last_modified: 2026-11-07
them a bit long. them a bit long.
1. Use descriptive names for modules and filenames. Avoid generic names like 1. Use descriptive names for modules and filenames. Avoid generic names like
`server`. `util` is banned. `server`. The rules for package names are under Naming, below.
1. Constructors **must** take a `Params` struct (or `ThingParams` when 1. Constructors **must** take a `Params` struct (or `ThingParams` when
`NewThing()` is used), even for a single argument. Named fields in a Params `NewThing()` is used), even for a single argument. Named fields in a Params
@@ -221,7 +215,7 @@ last_modified: 2026-11-07
... ...
if err != nil { if err != nil {
SendErrorResponse(w, MSGenericError) SendErrorResponse(w, ErrBadRequest)
return return
} }
@@ -487,6 +481,122 @@ last_modified: 2026-11-07
releasable". "Releasable" in this context means that it builds and functions releasable". "Releasable" in this context means that it builds and functions
as expected, and that all tests and linting passes. as expected, and that all tests and linting passes.
# Naming
Judge a name where it is read. A caller writes the package name, a dot and the
exported name, and reads them as one name: `http.Server`, `list.New`.
## Package names
1. Name a package for what it provides (`time`, `list`, `http`), because the
caller writes that name in front of everything the package exports.
1. Write a package name in lowercase letters and digits only, with its words
run together (`tabwriter`, never `tab_writer` or `tabWriter`), because that
is how the standard library spells every package name.
1. Never use a package name from the list below, or anything else that says
nothing about what is in it, because every program has a data model, helpers
and types.
- `model` and `models`
- `util` and `utils`
- `common`
- `misc`
- `helper` and `helpers`
- `types`
- `interfaces`
- `api`
1. Split a package whose code is about several things, so that each part can be
named for what it provides (`stringset`, not `util`).
1. Spell a word out unless its short form is the one everybody already uses
(`fmt`, `strconv`), because any other abbreviation has to be decoded.
1. Lengthen a package name that callers want for a variable or that a widely
used standard package has (`bufio`, not `buf`; `auditlog`, not `log`),
because importers must otherwise rename one of the two.
1. Give a package's directory the package's name, package `main` excepted, so
that the import path ends in the name the code uses.
1. Name a package that supports the tests of one package after that package
plus `test` (`storetest`, never `testutil` or `testhelper`), because the
name then says whose tests it is for.
1. Import a package under its own name unless two imports share a name or its
own name breaks these rules, so that a reader knows it without checking the
imports.
1. Give a renamed import the same local name in every file, so that one name
always means one package.
## Exported names
1. Never repeat the package name inside a longer exported name (`http.Server`,
not `http.HTTPServer`; `yamlconfig.Parse`, not
`yamlconfig.ParseYAMLConfig`), because the caller has already written it.
1. Use the same plain name in two packages when it fits both (`bufio.Reader`,
`csv.Reader`), because the package name already tells them apart.
1. Leave the receiver's type out of a method name, and the parameter and result
types out of a function name (`(c *Config) WriteTo(w)`, not
`WriteConfigTo`), because the signature already states them.
1. Put a type at the end of a function's name when the type is the only
difference between two functions (`ParseInt`, `ParseInt64`), because Go
needs a different name for each.
1. Use a noun for a function that only reports a value (`Owner()`,
`JobName(key)`), so that a call reads as the value it gives.
1. Use a verb for a function that does work, even when it also returns a result
(`Parse`, `WriteDetail(w)`), so that a call reads as the work it does.
1. Never start a getter with `Get` (`Owner()`, not `GetOwner()`; the setter is
`SetOwner()`), because the capital letter already tells the method from the
field.
1. Start a getter's name with `Fetch` when it reads the value from a database
or the network (`FetchOwner`, never `Owner` or `GetOwner`), because the
reader must know the call can be slow or fail.
1. Name a one-method interface for its method plus `er` (`Reader`,
`Formatter`), because the name then says the one thing a value of it does.
1. Use a well-known method's name and signature for a method that does the same
thing (`String()`, never `ToString()`), because readers and the standard
interfaces expect them.
1. Give another name to a method that differs in meaning or signature from a
well-known method of the same name (`Read`, `Write`, `Close`, `String`),
because readers rely on each name meaning one thing.
1. Write an initialism in one case throughout (`ServeHTTP`, `appID`, `URL` or
`url`; never `Url`, `Id` or `Http`), because that is how the standard
library spells them.
1. Write a constant in MixedCaps like every other name (`MaxPacketSize`, never
`MAX_PACKET_SIZE`), because an all-capitals name is exported whether or not
that was meant.
1. Name an error value `Err` plus what went wrong (`ErrNotFound`) and an error
type for what went wrong plus `Error` (`NotFoundError`), because callers
know a package's errors by those two forms.
## Local names
1. Match a local name's length to how far from its declaration it is used (`i`
in a short loop), because a reader far from the declaration has only the
name.
1. Name a receiver with one or two letters, never `this`, `self` or `me`,
because its role is plain from the method.
1. Use the same receiver name in every method of a type, so that the name
always means the receiver.
# Other Golang Tips and Best Practices (Optional) # Other Golang Tips and Best Practices (Optional)
1. For any internet-facing http server, set appropriate timeouts and limits to 1. For any internet-facing http server, set appropriate timeouts and limits to
+22 -44
View File
@@ -1,6 +1,6 @@
--- ---
title: Existing Repo Checklist title: Existing Repo Checklist
last_modified: 2026-11-09 last_modified: 2026-11-16
--- ---
Use this checklist when beginning work in a repo that may not yet conform to our Use this checklist when beginning work in a repo that may not yet conform to our
@@ -49,32 +49,20 @@ with your task.
`--target` names it, so a lost `COPY --from=` edge leaves `docker build .` `--target` names it, so a lost `COPY --from=` edge leaves `docker build .`
passing while the gate never runs. Confirm by planting a violation, not by passing while the gate never runs. Confirm by planting a violation, not by
reading the file. reading the file.
- [ ] In every stage, every step that lints, tests or compiles comes after - [ ] No `docker build` in `script/` passes `--no-cache` or a cache-busting
`ARG CACHEBUST`. `ARG CACHEBUST` comes right after these steps: build argument such as `CACHEBUST`, and no `Dockerfile` stage declares
- the steps that install system packages `ARG CACHEBUST`.
- the steps that download Go's modules
- the step that runs `script/bootstrap` to install a Python `test` phase's
packages from `Pipfile.lock`
- [ ] A stage with none of these steps declares `ARG CACHEBUST` right after
`FROM`. A step that also installs anything else comes after
`ARG CACHEBUST` too. A `script/bootstrap` that also installs node packages
is one. The `script/` builds pass a new `CACHEBUST` value on every build,
which reruns every `RUN` step after that line and leaves the layers above
it and the cache mounts in place; `--no-cache` would build those layers
again and empty the mounts. A stage without the `ARG` line is served from
cache on an unchanged tree, so the scripts and the `ARG` lines are
re-vendored in one commit.
- [ ] Go: each Go stage downloads the modules (`COPY go.mod go.sum ./`, - [ ] Go: each Go stage downloads the modules (`COPY go.mod go.sum ./`,
`RUN go mod download`) above `ARG CACHEBUST`; the steps that compile `RUN go mod download`) before `COPY . .`; the steps that compile
(`golangci-lint run`, `go test`, `go build`) mount Go's build cache (`golangci-lint run`, `go test`, `go build`) mount Go's build cache
(`--mount=type=cache,target=/root/.cache/go-build`), `golangci-lint run` (`--mount=type=cache,target=/root/.cache/go-build`), `golangci-lint run`
also mounts golangci-lint's also mounts golangci-lint's
(`--mount=type=cache,target=/root/.cache/golangci-lint`), and no step (`--mount=type=cache,target=/root/.cache/golangci-lint`), and no step
mounts anything else; both `go test` runs carry `-count=1`; a first run mounts anything else; both `go test` runs carry `-count=1`; a first run
that timed out gets no rerun, as in the canonical Go `Dockerfile` in that timed out gets no rerun, as in `examples/go.Dockerfile` in the
`REPO_POLICIES.md` `prompts` repo
- [ ] Python: a `test` phase that installs its packages from `Pipfile.lock` does - [ ] Python: a `test` phase that installs its packages from `Pipfile.lock` does
it above `ARG CACHEBUST`, with `COPY script/ script/`, it before `COPY . .`, with `COPY script/ script/`,
`COPY Pipfile Pipfile.lock ./` and `RUN script/bootstrap`. When `COPY Pipfile Pipfile.lock ./` and `RUN script/bootstrap`. When
`script/bootstrap` runs in that step, it installs nothing beyond these: `script/bootstrap` runs in that step, it installs nothing beyond these:
- system packages - system packages
@@ -91,9 +79,8 @@ with your task.
a package with no wheel for the image stops the install. In that step it a package with no wheel for the image stops the install. In that step it
installs no Python, because a step above it already did. `Pipfile` names no installs no Python, because a step above it already did. `Pipfile` names no
`python_version`, because `--deploy` stops when the distribution's Python `python_version`, because `--deploy` stops when the distribution's Python
differs from it. The tests run after `ARG CACHEBUST`, and every other stage differs from it. The tests run after `COPY . .`, as in
installs its Python packages after it, as in the Python `test` phase example `examples/python-test-phase.Dockerfile` in the `prompts` repo
in `REPO_POLICIES.md`
- [ ] The gate phases invoke their tools directly, never through `make lint` or - [ ] The gate phases invoke their tools directly, never through `make lint` or
`script/test` — those are themselves a `docker build` and would recurse `script/test` — those are themselves a `docker build` and would recurse
@@ -223,23 +210,21 @@ with your task.
- [ ] README has an **Entrypoints** section documenting the `script/` - [ ] README has an **Entrypoints** section documenting the `script/`
entrypoints and linking the standard entrypoints and linking the standard
- [ ] `script/lint` and `script/test` each run - [ ] `script/lint` and `script/test` each run
`docker build --build-arg CACHEBUST="$(date +%s)-$$" --target <phase> --output type=cacheonly .`, `docker build --target <phase> --output type=cacheonly .`, which builds
which builds their phase by name and writes no image, and no host their phase by name and writes no image, and no host invocation anywhere
invocation anywhere in the repo can produce a lint verdict — grep for the in the repo can produce a lint verdict — grep for the linter's own name
linter's own name across `script/`, the `Makefile` and CI config, not just across `script/`, the `Makefile` and CI config, not just `script/lint`. A
`script/lint`. A second path is likeliest here: a `make lint-fast`, an second path is likeliest here: a `make lint-fast`, an older
older host-versus-container branch, or a CI step calling the binary host-versus-container branch, or a CI step calling the binary directly.
directly. `script/fmt` and `script/fmt-check` are expected hits and stay `script/fmt` and `script/fmt-check` are expected hits and stay on the
on the host. host.
- [ ] No `docker build` in `script/` leaves a dangling image behind: - [ ] No `docker build` in `script/` leaves a dangling image behind:
`script/lint` and `script/test` write no image, and `script/docker` and `script/lint` and `script/test` write no image, and `script/docker` and
`script/cibuild` tag theirs. A build that writes an untagged image leaves `script/cibuild` tag theirs. A build that writes an untagged image leaves
one behind on every run, on every host and CI runner. one behind on every run, on every host and CI runner.
- [ ] `script/cibuild` runs `script/bootstrap` before `script/check`, and builds - [ ] `script/cibuild` runs `script/bootstrap` before `script/check`. Without
the image with a new `CACHEBUST` value on every build, like every the bootstrap the CI run dies in `script/fmt-check`, which runs the
`docker build` in `script/`. Without the bootstrap the CI run dies in formatter on the host and finds nothing installed.
`script/fmt-check`, which runs the formatter on the host and finds nothing
installed.
- [ ] `script/bootstrap` installs node, yarn and the node packages only when - [ ] `script/bootstrap` installs node, yarn and the node packages only when
`yarn.lock` is in the tree. node and yarn come from the distribution when `yarn.lock` is in the tree. node and yarn come from the distribution when
they are missing. It installs the node packages with they are missing. It installs the node packages with
@@ -327,14 +312,7 @@ with your task.
- [ ] `script/cibuild` succeeds in a fresh clone on a host carrying what CI has. - [ ] `script/cibuild` succeeds in a fresh clone on a host carrying what CI has.
That host is the runner image That host is the runner image
`docker.gitea.com/runner-images:ubuntu-latest`, which has docker, git and `docker.gitea.com/runner-images:ubuntu-latest`, which has docker, git and
node 24. Take any yarn off `PATH` first. The run must show that the checks node 24. Take any yarn off `PATH` first.
executed. A sub-second build means nothing ran. So does `CACHED` on a step
that lints or tests, one of the `RUN` steps below `ARG CACHEBUST`. Above
that line, these steps are expected to show `CACHED`:
- the steps that install system packages
- the steps that download Go's modules
- the step that runs `script/bootstrap` to install a Python `test` phase's
packages from `Pipfile.lock`
- [ ] A planted lint violation fails both `make lint` and a plain - [ ] A planted lint violation fails both `make lint` and a plain
`docker build .`; revert it afterwards `docker build .`; revert it afterwards
- [ ] Commit and merge fixes before starting your actual task - [ ] Commit and merge fixes before starting your actual task
+20 -45
View File
@@ -1,6 +1,6 @@
--- ---
title: New Repo Checklist title: New Repo Checklist
last_modified: 2026-11-09 last_modified: 2026-11-16
--- ---
Use this checklist when creating a new repository from scratch. Follow the steps Use this checklist when creating a new repository from scratch. Follow the steps
@@ -118,32 +118,17 @@ Template files can be fetched from:
stage carries a `COPY --from=` of a harmless file from each so the image stage carries a `COPY --from=` of a harmless file from each so the image
cannot be built unless both passed. Keep the final stage last: a stage cannot be built unless both passed. Keep the final stage last: a stage
nothing depends on is built only when `--target` names it. nothing depends on is built only when `--target` names it.
- In every stage, every step that lints, tests or compiles comes after
`ARG CACHEBUST`. `ARG CACHEBUST` comes right after these steps:
- the steps that install system packages
- the steps that download Go's modules
- the step that runs `script/bootstrap` to install a Python `test`
phase's packages from `Pipfile.lock`
- A stage with none of these steps declares `ARG CACHEBUST` right after
`FROM`. A step that also installs anything else comes after
`ARG CACHEBUST` too. A `script/bootstrap` that also installs node packages
is one. The `script/` builds pass a new `CACHEBUST` value on every build,
which reruns every `RUN` step after that line and leaves the layers above
it and the cache mounts in place; `--no-cache` would build those layers
again and empty the mounts. A stage without the `ARG` line is served from
cache on an unchanged tree, so the scripts and every stage's
`ARG CACHEBUST` line are added in the same commit.
- Go: each Go stage downloads the modules (`COPY go.mod go.sum ./`, - Go: each Go stage downloads the modules (`COPY go.mod go.sum ./`,
`RUN go mod download`) above `ARG CACHEBUST`; the steps that compile `RUN go mod download`) before `COPY . .`; the steps that compile
(`golangci-lint run`, `go test`, `go build`) mount Go's build cache (`golangci-lint run`, `go test`, `go build`) mount Go's build cache
(`--mount=type=cache,target=/root/.cache/go-build`), `golangci-lint run` (`--mount=type=cache,target=/root/.cache/go-build`), `golangci-lint run`
also mounts golangci-lint's also mounts golangci-lint's
(`--mount=type=cache,target=/root/.cache/golangci-lint`), and no step (`--mount=type=cache,target=/root/.cache/golangci-lint`), and no step
mounts anything else; both `go test` runs carry `-count=1`; a first run mounts anything else; both `go test` runs carry `-count=1`; a first run
that timed out gets no rerun, as in the canonical Go `Dockerfile` in that timed out gets no rerun, as in `examples/go.Dockerfile` in the
`REPO_POLICIES.md` `prompts` repo
- Python: a `test` phase that installs its packages from `Pipfile.lock` does - Python: a `test` phase that installs its packages from `Pipfile.lock` does
it above `ARG CACHEBUST`, with `COPY script/ script/`, it before `COPY . .`, with `COPY script/ script/`,
`COPY Pipfile Pipfile.lock ./` and `RUN script/bootstrap`. When `COPY Pipfile Pipfile.lock ./` and `RUN script/bootstrap`. When
`script/bootstrap` runs in that step, it installs nothing beyond these: `script/bootstrap` runs in that step, it installs nothing beyond these:
- system packages - system packages
@@ -161,9 +146,8 @@ Template files can be fetched from:
for the image stops the install. In that step it installs no Python, for the image stops the install. In that step it installs no Python,
because a step above it already did. `Pipfile` names no because a step above it already did. `Pipfile` names no
`python_version`, because `--deploy` stops when the distribution's `python_version`, because `--deploy` stops when the distribution's
Python differs from it. The tests run after `ARG CACHEBUST`, and every Python differs from it. The tests run after `COPY . .`, as in
other stage installs its Python packages after it, as in the Python `examples/python-test-phase.Dockerfile` in the `prompts` repo
`test` phase example in `REPO_POLICIES.md`
- Server: the final stage builds and runs the application - Server: the final stage builds and runs the application
- Non-server: the final stage brings up the dev environment - Non-server: the final stage brings up the dev environment
@@ -227,13 +211,12 @@ are thin shims calling them. Model scripts:
- [ ] `script/setup` / `make setup` — readies a fresh clone: runs `bootstrap`, - [ ] `script/setup` / `make setup` — readies a fresh clone: runs `bootstrap`,
then `install-precommit`, plus repo-specific init then `install-precommit`, plus repo-specific init
- [ ] `script/test` / `make test` — - [ ] `script/test` / `make test` —
`docker build --build-arg CACHEBUST="$(date +%s)-$$" --target test --output type=cacheonly .`, `docker build --target test --output type=cacheonly .`, which writes no
which writes no image; the phase runs real tests, not a no-op (90-second image; the phase runs real tests, not a no-op (90-second timeout,
timeout, 60-second hard cap on wall time) 60-second hard cap on wall time)
- [ ] `script/lint` / `make lint` — - [ ] `script/lint` / `make lint` —
`docker build --build-arg CACHEBUST="$(date +%s)-$$" --target lint --output type=cacheonly .`, `docker build --target lint --output type=cacheonly .`, which writes no
which writes no image. No lint verdict may come from a host invocation of image. No lint verdict may come from a host invocation of the linter.
the linter.
- [ ] `script/fmt` / `make fmt` — formats code (writes; native, never in a - [ ] `script/fmt` / `make fmt` — formats code (writes; native, never in a
container). Go code gets `gofmt`, then `golines -m 77`. container). Go code gets `gofmt`, then `golines -m 77`.
- [ ] `script/fmt-check` / `make fmt-check` — checks formatting (read-only; - [ ] `script/fmt-check` / `make fmt-check` — checks formatting (read-only;
@@ -245,16 +228,15 @@ are thin shims calling them. Model scripts:
- [ ] `script/projectname` — outputs the project name (used by `script/docker` - [ ] `script/projectname` — outputs the project name (used by `script/docker`
for the image tag) for the image tag)
- [ ] `script/docker` / `make docker` — builds Docker image, tagged via - [ ] `script/docker` / `make docker` — builds Docker image, tagged via
`script/projectname` (byte-identical across repos); a new `CACHEBUST` `script/projectname` (byte-identical across repos), with the version as a
value on every build, plus the version as a build arg build arg
- [ ] `script/cibuild` — cd to repo root, run `script/bootstrap`, run - [ ] `script/cibuild` — cd to repo root, run `script/bootstrap`, run
`script/check`, then `script/check`, then
`docker build --build-arg CACHEBUST="$(date +%s)-$$" --build-arg VERSION="$version" -t "$tag" .` `docker build --build-arg VERSION="$version" -t "$tag" .` (what CI runs),
(what CI runs), with `$version` from with `$version` from `git describe --tags --always --dirty` (`unknown` if
`git describe --tags --always --dirty` (`unknown` if empty) and `$tag` empty) and `$tag` from `script/projectname`, each assigned on its own line
from `script/projectname`, each assigned on its own line before the build. before the build. The bootstrap is required: CI checks out and runs this
The bootstrap is required: CI checks out and runs this alone, and alone, and `script/fmt-check` runs the formatter on the host.
`script/fmt-check` runs the formatter on the host.
- [ ] `script/bootstrap`, `script/fmt` and `script/fmt-check` run yarn by - [ ] `script/bootstrap`, `script/fmt` and `script/fmt-check` run yarn by
whichever name is present: `yarn`, or `yarnpkg` on Debian and Ubuntu. With whichever name is present: `yarn`, or `yarnpkg` on Debian and Ubuntu. With
neither name on `PATH`, `script/fmt` and `script/fmt-check` print one line neither name on `PATH`, `script/fmt` and `script/fmt-check` print one line
@@ -279,14 +261,7 @@ are thin shims calling them. Model scripts:
- [ ] `script/cibuild` succeeds in a fresh clone on a host carrying what CI has. - [ ] `script/cibuild` succeeds in a fresh clone on a host carrying what CI has.
That host is the runner image That host is the runner image
`docker.gitea.com/runner-images:ubuntu-latest`, which has docker, git and `docker.gitea.com/runner-images:ubuntu-latest`, which has docker, git and
node 24. Take any yarn off `PATH` first. The run must show that the checks node 24. Take any yarn off `PATH` first.
executed. A sub-second build means nothing ran. So does `CACHED` on a step
that lints or tests, one of the `RUN` steps below `ARG CACHEBUST`. Above
that line, these steps are expected to show `CACHED`:
- the steps that install system packages
- the steps that download Go's modules
- the step that runs `script/bootstrap` to install a Python `test` phase's
packages from `Pipfile.lock`
- [ ] Plant a lint violation and confirm both `make lint` and a plain - [ ] Plant a lint violation and confirm both `make lint` and a plain
`docker build .` fail on it; revert. A plain build that passes proves the `docker build .` fail on it; revert. A plain build that passes proves the
final stage is missing its `COPY --from=` edge to the gate phases. final stage is missing its `COPY --from=` edge to the gate phases.
+575 -801
View File
File diff suppressed because it is too large. Load diff
+1 -9
View File
@@ -2,12 +2,6 @@
# script/cibuild: run the CI build. It bootstraps first: a CI runner # script/cibuild: run the CI build. It bootstraps first: a CI runner
# checks out and runs this and nothing else, and script/fmt-check runs # checks out and runs this and nothing else, and script/fmt-check runs
# the formatter on the host, which a pristine checkout cannot do. # the formatter on the host, which a pristine checkout cannot do.
# A new CACHEBUST value reruns every RUN step after the ARG CACHEBUST
# line, since a cached gate phase is a check that did not run; unlike
# --no-cache, it keeps the layers above that line and the cache mounts.
# This relies on every stage of the Dockerfile declaring ARG CACHEBUST
# before every step that lints, tests or compiles; a stage without that
# line is served from cache on an unchanged tree, with no warning.
set -eu set -eu
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)" SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
@@ -25,9 +19,7 @@ main() {
version="$(git describe --tags --always --dirty 2>/dev/null || true)" version="$(git describe --tags --always --dirty 2>/dev/null || true)"
[ -n "$version" ] || version="unknown" [ -n "$version" ] || version="unknown"
tag="$("$SCRIPT_DIR/projectname")" tag="$("$SCRIPT_DIR/projectname")"
docker build --build-arg CACHEBUST="$(date +%s)-$$" \ docker build --build-arg VERSION="$version" -t "$tag" .
--build-arg VERSION="$version" \
-t "$tag" .
} }
main "$@" main "$@"
+1 -9
View File
@@ -1,12 +1,6 @@
#!/bin/sh #!/bin/sh
# script/docker: build the Docker image tagged with the project name. # script/docker: build the Docker image tagged with the project name.
# Identical in all repos; the tag comes from script/projectname. # Identical in all repos; the tag comes from script/projectname.
# A new CACHEBUST value reruns every RUN step after the ARG CACHEBUST
# line, since a cached gate phase is a check that did not run; unlike
# --no-cache, it keeps the layers above that line and the cache mounts.
# This relies on every stage of the Dockerfile declaring ARG CACHEBUST
# before every step that lints, tests or compiles; a stage without that
# line is served from cache on an unchanged tree, with no warning.
set -eu set -eu
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)" SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
@@ -22,9 +16,7 @@ main() {
version="$(git describe --tags --always --dirty 2>/dev/null || true)" version="$(git describe --tags --always --dirty 2>/dev/null || true)"
[ -n "$version" ] || version="unknown" [ -n "$version" ] || version="unknown"
tag="$("$SCRIPT_DIR/projectname")" tag="$("$SCRIPT_DIR/projectname")"
docker build --build-arg CACHEBUST="$(date +%s)-$$" \ docker build --build-arg VERSION="$version" -t "$tag" .
--build-arg VERSION="$version" \
-t "$tag" .
} }
main "$@" main "$@"
+2 -2
View File
@@ -8,8 +8,8 @@ ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
main() { main() {
cd "$ROOT" cd "$ROOT"
hook=".git/hooks/pre-commit" hook=".git/hooks/pre-commit"
printf '#!/bin/sh\nset -e\nscript/precommit\n' > .git/hooks/pre-commit printf '#!/bin/sh\nset -e\nscript/precommit\n' > "$hook"
chmod +x .git/hooks/pre-commit chmod +x "$hook"
echo "pre-commit hook installed: runs script/precommit" echo "pre-commit hook installed: runs script/precommit"
} }
+4 -13
View File
@@ -1,18 +1,11 @@
#!/bin/sh #!/bin/sh
# script/lint: run the linter. Linting is a phase of the Dockerfile and # script/lint: run the linter. Linting is a phase of the Dockerfile and
# this builds that phase alone; the linter is never installed or run on # this builds that phase; the linter is never installed or run on
# a developer host, where a shared result cache and a host-global lock # a developer host, where a shared result cache and a host-global lock
# make its answer untrustworthy. # make its answer untrustworthy.
# #
# The phase is not the last stage in the file, so it is built only when # --target builds the lint phase and the stages it depends on, nothing
# --target names it. A new CACHEBUST value reruns every RUN step after # else. --output type=cacheonly writes no image, since nothing uses one.
# the ARG CACHEBUST line, since a cached lint layer is a lint that did
# not run; unlike --no-cache, it keeps the layers above that line and
# the cache mounts. This relies on every stage of the Dockerfile
# declaring ARG CACHEBUST before every step that lints, tests or
# compiles; a stage without that line is served from cache on an
# unchanged tree, with no warning.
# --output type=cacheonly writes no image, since nothing uses one.
set -eu set -eu
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)" SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
@@ -20,9 +13,7 @@ ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
main() { main() {
cd "$ROOT" cd "$ROOT"
docker build --build-arg CACHEBUST="$(date +%s)-$$" \ docker build --target lint --output type=cacheonly .
--target lint \
--output type=cacheonly .
} }
main "$@" main "$@"
+5 -12
View File
@@ -1,14 +1,9 @@
#!/bin/sh #!/bin/sh
# script/test: run the test suite. Testing is a phase of the Dockerfile # script/test: run the test suite. Testing is a phase of the Dockerfile
# and this builds that phase alone, on the same terms as script/lint: # and this builds that phase, on the same terms as script/lint:
# --target because a phase that is not the last stage is built only when # --target so that only the test phase and the stages it depends on are
# named, and a new CACHEBUST value because a cached test layer is a test # built, and --output type=cacheonly so that no image is written, since
# that did not run; unlike --no-cache, it keeps the layers above the ARG # nothing uses one.
# CACHEBUST line and the cache mounts. This relies on every stage of the
# Dockerfile declaring ARG CACHEBUST before every step that lints, tests
# or compiles; a stage without that line is served from cache on an
# unchanged tree, with no warning. --output type=cacheonly writes no
# image, since nothing uses one.
set -eu set -eu
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)" SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
@@ -16,9 +11,7 @@ ROOT="$(cd "$SCRIPT_DIR/.." && pwd -P)"
main() { main() {
cd "$ROOT" cd "$ROOT"
docker build --build-arg CACHEBUST="$(date +%s)-$$" \ docker build --target test --output type=cacheonly .
--target test \
--output type=cacheonly .
} }
main "$@" main "$@"