From 6ec851cc769c8ac20aa25abeabf6b15ced5556e1 Mon Sep 17 00:00:00 2001 From: sotashimozono Date: Sun, 13 Sep 2026 09:48:11 +0000 Subject: [PATCH] Resolve the formatter in a temp project, not the runner's shared depot `Pkg.add(name="JuliaFormatter", version="2")` ran with no active project, so it resolved into whatever environment the runner happened to have. The compat bounds already sitting in that depot cap the resolve, which makes the installed version a property of the machine rather than of this file: the same commit resolved 2.3.2 on a self-hosted runner and 2.10.1 on a GitHub-hosted one. Formatting differs across 2.x minors, so format-check returned a verdict on the runner, not on the diff. A leftover ITensorFormatter in a shared depot also pinned JuliaSyntax to 0.4 and turned the install into a hard resolve failure, which presents as a flake because it depends on which runner you land on. `Pkg.activate(; temp=true)` before the add is the fix, and the install and the check are now one process so the environment cannot expire between them. The version still floats, deliberately. A pin converts each new release into permanent debt in every calling repo and rots while the ecosystem moves; the answer to a release that reflows files is to adopt it and reformat. Isolation is what this check needed to be reproducible, and it is orthogonal to the version spec. Added an assertion that the loaded version is the one the temp project holds. `using` silently falls back to the depot's default environment when the active project does not declare the package, which has bitten this fleet twice through an env that looked right by its name. The failure message now names the version CI resolved and gives the same floating spec in a temp env, with `overwrite=true` and a retry loop, since `overwrite=false` is a check rather than a fix and one pass does not always converge. Runs the script through `shell: julia --color=yes {0}` rather than `julia -e`, which is how lab-sotashimozono/.github has run this check for months. The failure message has to contain a Julia command with its own quotes, and that does not survive nesting inside `-e '...'`. The two orgs' scripts are now byte-identical, so a fix to one is a copy-paste to the other. Verified locally on both arms rather than by CI round trip: a formatted tree exits 0 with the success line, a misformatted one exits 1 with the message. The YAML and the embedded script both parse. Co-Authored-By: Claude Opus 5 (1M context) --- .github/workflows/format-check.yml | 43 ++++++++++++++++++++++-------- 1 file changed, 32 insertions(+), 11 deletions(-) diff --git a/.github/workflows/format-check.yml b/.github/workflows/format-check.yml index 633a022..e68f390 100644 --- a/.github/workflows/format-check.yml +++ b/.github/workflows/format-check.yml @@ -1,5 +1,15 @@ # Reusable JuliaFormatter (v2) check. Call from a repo with: # jobs: { format: { uses: QAtlasHub/.github/.github/workflows/format-check.yml@main } } +# +# `Pkg.activate(; temp=true)` is load-bearing. A bare `Pkg.add` resolves into the runner's +# shared/default environment, where the compat bounds already there cap the result: the same +# commit resolved JuliaFormatter 2.3.2 on a self-hosted runner and 2.10.1 on a GitHub-hosted one, +# and a leftover ITensorFormatter in such a depot once made the install fail outright. Same code, +# different verdict, which presented for months as a "format-check flake". +# +# The version floats, deliberately. When a new 2.x reflows files the answer is to adopt it and +# reformat, not to freeze the old one: a pin here becomes standing debt in every caller and rots +# while the ecosystem moves. Reproducibility comes from the clean env above, not from a pin. name: Format Check (reusable) on: workflow_call: @@ -13,16 +23,27 @@ jobs: - uses: julia-actions/setup-julia@v3 with: version: '1' - - name: Install JuliaFormatter - run: julia -e 'using Pkg; Pkg.add(name="JuliaFormatter", version="2"); using JuliaFormatter; @info "JuliaFormatter $(pkgversion(JuliaFormatter))"' - - name: Check formatting + - name: JuliaFormatter check + shell: julia --color=yes {0} run: | - julia -e ' - using JuliaFormatter - ok = format(".", verbose=true, overwrite=false) - if !ok - println(stderr, "❌ Formatting issues found. Run locally: julia -e \"using JuliaFormatter; format(\\\".\\\")\"") + using Pkg + Pkg.activate(; temp = true) # clean env — no depot compat capping the resolve + Pkg.add(PackageSpec(name = "JuliaFormatter", version = "2")) + using JuliaFormatter + v = pkgversion(JuliaFormatter) + # `using` falls back to the depot's default env when the active project does not declare + # the package, loading a different version and saying nothing, so ask the project itself. + declared = [p.version for (_, p) in Pkg.dependencies() if p.name == "JuliaFormatter"] + if declared != [v] + println(stderr, "❌ JuliaFormatter $v came from outside the temp project, which holds $declared.") exit(1) - end - println("✅ All files are properly formatted.") - ' + end + @info "JuliaFormatter $v" + ok = format("."; verbose = true, overwrite = false) + if !ok + println(stderr, "❌ Not formatted, under JuliaFormatter $v. `overwrite=false` above is the check;") + println(stderr, " locally you want `true`, and one pass does not always converge. Run:") + println(stderr, " julia -e 'using Pkg; Pkg.activate(;temp=true); Pkg.add(PackageSpec(name=\"JuliaFormatter\", version=\"2\")); using JuliaFormatter; for _ in 1:5; format(\".\"; overwrite=true) && break end'") + exit(1) + end + println("✅ All files properly formatted.")