refactor: convert checkmake and prettierd from fn to standard config (#81)

* test: add tests for all remaining tools

Problem: most formatters and linters in guard-collection had no test
coverage. The csharpier binary was renamed in v1.0+ and ruff's -e flag
was deprecated in favor of the check subcommand.

Solution: add 42 test files covering every remaining tool, fix the
csharpier and ruff definitions, extend the install script with gz/jar
archive types, add 6 new CI jobs (dotnet, ruby, clojure, elixir, nix,
swift), and expand existing jobs with newly tested tools.

* fix(ci): remove duplicate entry and untestable mypyc test

* fix(ci): restore CI config lost during merge

Problem: the -X theirs merge strategy replaced the full test/all-tools
CI config with the smaller fix/broken-configs version, losing install
entries for dart, fish_indent, google-java-format, pg_format, tombi,
typos, typstyle, xmllint, and zigfmt.

Solution: restore binary.txt, ci.yaml, and install script from the
pre-merge test/all-tools state which already had all entries.

* ci: extract repeated test setup into composite action

Problem: every test job repeated the same 5 steps for neovim, lua,
luarocks, busted/nlua, and guard.nvim clone — 175 lines of duplication
across 15 jobs.

Solution: extract into .github/actions/test-setup/action.yml and
replace with a single `uses: ./.github/actions/test-setup` per job.

* fix(test): use run_lint/run_fmt instead of manual vim.system

Problem: rebase picked up old test versions that manually construct
commands instead of using the config-driven helpers, defeating the
purpose of testing the actual tool definitions.

Solution: replace all 14 affected test files with the upstream/main
versions that use run_lint/run_fmt. Add buf lint test using run_lint.

* refactor: convert checkmake and prettierd from fn to standard config

Problem: checkmake and prettierd used custom fn handlers to spawn
processes manually, duplicating what guard.nvim's standard cmd/args/parse
pipeline already does. This prevented their tests from using the shared
run_lint/run_fmt helpers.

Solution: replace fn with cmd/args/fname fields. Update tests to use
run_lint and run_fmt instead of manual vim.system calls.

* ci(cljfmt): use standalone binary and extract apt packages to file

Problem: cljfmt required a dedicated CI job with Java, Clojure CLI, a
hand-rolled wrapper script, and dep pre-warming. The binary job also had
an inline apt-get install command inconsistent with other tool lists.

Solution: switch cljfmt to the standalone GraalVM binary from GitHub
releases, move its test into test/binary/, delete the test-clojure job,
and extract the binary job's apt packages into binary-apt.txt.

* test: exercise fn-based linter configs via coroutine helper

Problem: cpplint and zsh tests bypassed the fn config entirely by
manually constructing vim.system calls, so drift between the test and
the actual config could go undetected.

Solution: add run_lint_fn helper that wraps the fn call in a coroutine
and pumps the event loop via vim.wait, then update cpplint and zsh
tests to use it.

* refactor(test): run assertions inside coroutine in run_lint_fn

Problem: run_lint_fn busy-waited on an intermediate output variable,
then ran parse and returned results outside the coroutine.

Solution: accept an assertion callback, run the full pipeline (fn,
parse, assertions) inside the coroutine, and poll only on a completion
flag.

Author: barrettruth

lua/guard-collection/formatter.lua

@@ -186,29 +186,9 @@ M.prettier = {
 }
 
 M.prettierd = {
-  fn = function(buf, range)
-    if vim.fn.has('nvim-0.10') ~= 1 then
-      vim.notify('[guard-collection]: prettierd uses vim.system introduced in nvim 0.10', 4)
-      return
-    end
-    local srow = range and range['start'][1] or 0
-    local erow = range and range['end'][1] or -1
-    local handle = vim.system(
-      { 'prettierd', vim.api.nvim_buf_get_name(buf) },
-      {
-        stdin = true,
-      },
-      vim.schedule_wrap(function(result)
-        if result.code ~= 0 then
-          return
-        end
-        vim.api.nvim_buf_set_lines(buf, srow, erow, false, vim.split(result.stdout, '\r?\n'))
-        vim.cmd('silent! noautocmd write!')
-      end)
-    )
-    handle:write(table.concat(vim.api.nvim_buf_get_lines(buf, srow, erow, false), '\n'))
-    handle:write(nil)
-  end,
+  cmd = 'prettierd',
+  stdin = true,
+  fname = true,
 }
 
 M.rubocop = {

lua/guard-collection/linter/checkmake.lua

@@ -1,17 +1,9 @@
 local lint = require('guard.lint')
 
 return {
-  fn = function(_, fname)
-    local co = assert(coroutine.running())
-    vim.system({
-      'checkmake',
-      '--format={{.FileName}}:{{.LineNumber}}: [{{.Rule}}] {{.Violation}}\n',
-      fname,
-    }, {}, function(result)
-      coroutine.resume(co, result.stdout or '')
-    end)
-    return coroutine.yield()
-  end,
+  cmd = 'checkmake',
+  args = { '--format={{.FileName}}:{{.LineNumber}}: [{{.Rule}}] {{.Violation}}\n' },
+  fname = true,
   parse = function(result, bufnr)
     local diags = {}
     for line in result:gmatch('[^\n]+') do

test/binary/checkmake_spec.lua

@@ -1,25 +1,13 @@
 describe('checkmake', function()
   it('can lint', function()
-    local linter = require('test.helper').get_linter('checkmake')
-    local tmpfile = '/tmp/guard-test.make'
-    local input = {
+    local helper = require('test.helper')
+    local buf, diagnostics = helper.run_lint('checkmake', 'make', {
       [[all:]],
       [[\techo hello]],
-    }
-    vim.fn.writefile(input, tmpfile)
-    local bufnr = vim.api.nvim_create_buf(false, true)
-    local result = vim
-      .system({
-        'checkmake',
-        '--format={{.FileName}}:{{.LineNumber}}: [{{.Rule}}] {{.Violation}}\n',
-        tmpfile,
-      }, {})
-      :wait()
-    local output = result.stdout or ''
-    local diagnostics = linter.parse(output, bufnr)
+    })
     assert.is_true(#diagnostics > 0)
     for _, d in ipairs(diagnostics) do
-      assert.equal(bufnr, d.bufnr)
+      assert.equal(buf, d.bufnr)
       assert.equal('checkmake', d.source)
       assert.is_number(d.lnum)
       assert.is_string(d.message)

test/binary/zsh_spec.lua

@@ -1,18 +1,13 @@
 describe('zsh', function()
   it('can lint', function()
-    local linter = require('test.helper').get_linter('zsh')
-    local tmpfile = '/tmp/guard-test.zsh'
-    vim.fn.writefile({ 'if true; then' }, tmpfile)
-    local bufnr = vim.api.nvim_create_buf(false, true)
-    local result = vim.system({ 'zsh', '-n', tmpfile }, {}):wait()
-    local output = result.stderr or ''
-    local diagnostics = linter.parse(output, bufnr)
-    assert.is_true(#diagnostics > 0)
-    for _, d in ipairs(diagnostics) do
-      assert.equal(bufnr, d.bufnr)
-      assert.equal('zsh', d.source)
-      assert.is_number(d.lnum)
-      assert.is_string(d.message)
-    end
+    local helper = require('test.helper')
+    helper.run_lint_fn('zsh', 'zsh', { 'if true; then' }, function(bufnr, diagnostics)
+      assert.is_true(#diagnostics > 0)
+      for _, d in ipairs(diagnostics) do
+        helper.assert_diag(d, { bufnr = bufnr, source = 'zsh' })
+        assert.is_number(d.lnum)
+        assert.is_string(d.message)
+      end
+    end)
   end)
 end)

test/helper.lua

@@ -55,6 +55,27 @@ function M.run_lint(name, ft, input, opts)
   return bufnr, diags
 end
 
+function M.run_lint_fn(name, ft, input, assert_fn)
+  local linter = require('guard-collection.linter')[name]
+  assert(linter, 'unknown linter: ' .. name)
+  assert(linter.fn, name .. ' does not use custom fn')
+  local tmpfile = '/tmp/guard-test.' .. ft
+  vim.fn.writefile(input, tmpfile)
+  local bufnr = api.nvim_create_buf(false, true)
+  local done = false
+  local co = coroutine.create(function()
+    local output = linter.fn(nil, tmpfile)
+    local diags = linter.parse(output, bufnr)
+    assert_fn(bufnr, diags)
+    done = true
+  end)
+  coroutine.resume(co)
+  vim.wait(5000, function()
+    return done
+  end)
+  assert(done, name .. ' fn timed out')
+end
+
 function M.assert_diag(d, expect)
   local a = require('luassert')
   if expect.bufnr then

test/npm/prettierd_spec.lua

@@ -1,20 +1,12 @@
 describe('prettierd', function()
   it('can format', function()
-    local tmpfile = '/tmp/guard-test.js'
-    local input = {
+    local formatted = require('test.helper').run_fmt('prettierd', 'js', {
       'const x={a:1,b:2,c:3}',
       'const y = [1,2,3,4,5]',
-    }
-    vim.fn.writefile(input, tmpfile)
-    local result = vim
-      .system({ 'prettierd', tmpfile }, { stdin = table.concat(input, '\n') })
-      :wait()
-    assert.equal(0, result.code)
-    local expected = table.concat({
+    })
+    assert.are.same({
       'const x = { a: 1, b: 2, c: 3 };',
       'const y = [1, 2, 3, 4, 5];',
-      '',
-    }, '\n')
-    assert.equal(expected, result.stdout)
+    }, formatted)
   end)
 end)

test/pip/cpplint_spec.lua

@@ -1,19 +1,13 @@
 describe('cpplint', function()
   it('can lint', function()
-    local linter = require('test.helper').get_linter('cpplint')
-    local tmpfile = '/tmp/guard-test.cpp'
-    local input = { [[int main(){int x=1;}]] }
-    vim.fn.writefile(input, tmpfile)
-    local bufnr = vim.api.nvim_create_buf(false, true)
-    local result = vim.system({ 'cpplint', '--filter=-legal/copyright', tmpfile }, {}):wait()
-    local output = result.stderr or ''
-    local diagnostics = linter.parse(output, bufnr)
-    assert.is_true(#diagnostics > 0)
-    for _, d in ipairs(diagnostics) do
-      assert.equal(bufnr, d.bufnr)
-      assert.equal('cpplint', d.source)
-      assert.is_number(d.lnum)
-      assert.is_string(d.message)
-    end
+    local helper = require('test.helper')
+    helper.run_lint_fn('cpplint', 'cpp', { [[int main(){int x=1;}]] }, function(bufnr, diagnostics)
+      assert.is_true(#diagnostics > 0)
+      for _, d in ipairs(diagnostics) do
+        helper.assert_diag(d, { bufnr = bufnr, source = 'cpplint' })
+        assert.is_number(d.lnum)
+        assert.is_string(d.message)
+      end
+    end)
   end)
 end)