fun_ci 2.1.1-aarch64-linux → 2.3.0-aarch64-linux

data/lib/fun_ci/pipeline/process_runner.rb

@@ -23,16 +23,26 @@ module FunCi
       DRAIN_SECONDS = 1
 
       # Where the command runs, what it finds in its environment besides
-      # fun-ci's own, the window what it prints is written to, and what to do
-      # with its pid when it runs over budget, before it is killed.
-      Launch = Data.define(:chdir, :env, :output, :before_kill)
+      # fun-ci's own, the window what it prints is written to, what to do
+      # with its pid when it runs over budget, before it is killed, the
+      # open files it holds as long as it runs, such as a lock, and what it
+      # is run under (a Priorities prefix, "" for fun-ci's own priority).
+      Launch = Data.define(:chdir, :env, :output, :before_kill, :held, :priority)
 
       class Launch
         def initialize(**given)
-          super(chdir: Dir.pwd, env: {}, output: OutputWindow.in_memory, before_kill: nil, **given)
+          super(chdir: Dir.pwd, env: {}, output: OutputWindow.in_memory, before_kill: nil, held: [], priority: "",
+                **given)
         end
       end
 
+      # Where the first file a command holds is open in it: past the gate's 9.
+      FIRST_HELD = 10
+
+      # { descriptor in the command => file } for the files it holds. Not their
+      # own descriptors, which in a process with few files open may be the gate's.
+      def self.held_descriptors(files) = files.each_with_index.to_h { |file, index| [FIRST_HELD + index, file] }
+
       # A command started and let go, and the pipe that carries what it prints.
       Started = Data.define(:pid, :reader)
 
@@ -69,10 +79,12 @@ module FunCi
       end
 
       def spawn_gated(cmd, writer, gate, launch)
-        Process.spawn(GitEnvironment::CLEAN.merge(launch.env), format(GATED, cmd),
-                      out: writer, err: writer, 9 => gate.child_end, pgroup: true, chdir: launch.chdir)
+        Process.spawn(GitEnvironment::CLEAN.merge(launch.env), format(GATED, "#{launch.priority}#{cmd}"),
+                      out: writer, err: writer, 9 => gate.child_end, pgroup: true, chdir: launch.chdir, **held(launch))
       end
 
+      def held(launch) = ProcessRunner.held_descriptors(launch.held)
+
       # The reader may be closed while this thread still reads, once a killed
       # command's output has drained or stopped coming.
       def read_until_closed(reader, printed)

data/lib/fun_ci/pipeline/progress_reporter.rb

@@ -17,6 +17,10 @@ module FunCi
         @stdout.puts "fun-ci: fast #{result_marker(passed)}"
       end
 
+      def cold_slot(seconds)
+        @stdout.puts "fun-ci: a new worktree, whose caches are empty, so lint and build have #{seconds}s this once."
+      end
+
       def slow_launched
         @stdout.puts "fun-ci: slow (running in background)"
       end

data/lib/fun_ci/pipeline/run_canceller.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../persistence/active_runs"
+require_relative "../persistence/active_jobs"
 require_relative "../persistence/run_status"
 require_relative "../persistence/write_trouble"
 require_relative "slot_lock"
@@ -36,6 +37,26 @@ module FunCi
         # The next poll looks again.
       end
 
+      # Stops a daily or weekly job's processes and records it cancelled,
+      # unless it has finished meanwhile; a group its runner recorded while
+      # this looked is stopped once the runner is dead, as a run's late stages are.
+      def cancel_job(db, id)
+        Persistence::ActiveJobs.with_id(db, id).each do |job|
+          stop(job)
+          Persistence::ActiveJobs.with_id(db, id).each { |now| kill_late(job, now) }
+          Persistence::ActiveJobs.cancelled(db, id)
+        end
+      end
+
+      # Records failed each daily or weekly job still running whose lock
+      # nobody holds: its process is gone (acceptance-tests.md, AT-13.6).
+      def record_dead_jobs(db)
+        Persistence::ActiveJobs.running(db).filter_map { |id, lock| id unless @slot_held.call(lock) }
+                               .each { |id| Persistence::ActiveJobs.died(db, id) }
+      rescue SQLite3::BusyException, *Persistence::WriteTrouble::UNWRITABLE
+        # The next poll looks again.
+      end
+
       def stop(run)
         return unless alive?(run)
 
@@ -53,6 +74,9 @@ module FunCi
         end
       end
 
+      # The groups recorded since `before` was read.
+      def kill_late(before, now) = (now.stage_groups - before.stage_groups).each { |group| kill(-group) }
+
       def alive?(run) = run.slot_lock.nil? || @slot_held.call(run.slot_lock)
 
       # Whether a process with this pid exists; one this user may not signal does.

data/lib/fun_ci/pipeline/slot.rb

@@ -6,7 +6,7 @@ module FunCi
     # file. The fast suite and the slow suite each hold it; it frees when the
     # last of them lets go. A process that dies lets go with it.
     class Slot
-      attr_reader :path, :lock_file
+      attr_reader :path, :lock_file, :lock
 
       # +lock_file+ names the lock on disk; nil for a slot with nothing to lock.
       def initialize(path, lock, lock_file = nil)
@@ -25,6 +25,17 @@ module FunCi
         @holders -= 1
         @lock.close if @holders.zero? && !@lock.closed?
       end
+
+      # Whether its worktree was just made, so has no caches yet.
+      def cold? = false
+
+      # The same slot, before anyone shares it, in a worktree just made.
+      def as_cold = ColdSlot.new(path, lock, lock_file)
+    end
+
+    # A slot whose worktree was just made: its build starts from nothing.
+    class ColdSlot < Slot
+      def cold? = true
     end
   end
 end

data/lib/fun_ci/pipeline/slot_run.rb

@@ -34,22 +34,36 @@ module FunCi
 
       def recorder = @seams.recorder
       def progress = ProgressReporter.new(stdout: @io.stdout)
-      def stage_runner = StageRunner.new(commit: @commit, stdout: @io.stdout, seams: @seams, dir: @slot.path)
+
+      def stage_runner(seams = @seams)
+        StageRunner.new(commit: @commit, stdout: @io.stdout, seams: seams, dir: @slot.path)
+      end
 
       # This process's part is over; the slow suite may still be running.
       def released(exit_code)
         @slot.release
-        recorder.foreground_done
         exit_code
       end
 
       def phase_one_passed?(config)
-        results = %w[lint build].to_h { |stage| [stage, Thread.new { stage_runner.passes?(config, stage) }] }
+        runner = stage_runner(phase_one_seams)
+        results = %w[lint build].to_h { |stage| [stage, Thread.new { runner.passes?(config, stage) }] }
                                 .transform_values(&:value)
         progress.phase_one_result(results)
         results.values.all?
       end
 
+      # A worktree just made has no caches, so its lint and build are no
+      # measure of the project's: they get the slow suite's budget, this once.
+      def phase_one_seams
+        return @seams unless @slot.cold?
+
+        cold = @seams.budgets["slow"]
+        progress.cold_slot(cold)
+        longer = %w[lint build].to_h { |stage| [stage, [@seams.budgets[stage], cold].max] }
+        @seams.with(time_budgets: @seams.time_budgets.merge(longer))
+      end
+
       def fast_passed?(config)
         passed = stage_runner.passes?(config, "fast")
         progress.fast_result(passed)
@@ -65,7 +79,8 @@ module FunCi
       # Called with the recorder and job to record the slow suite with, in
       # whichever process runs it; the slot is let go once it is recorded.
       def slow_suite(config, slot)
-        execution = StageExecution.new(seams: @seams, dir: slot.path, commit: @commit)
+        execution = StageExecution.new(seams: @seams, dir: slot.path, commit: @commit,
+                                       launching: { priority: @seams.priorities.slow })
         command = config.stage_command("slow", @commit.sha)
         ->(recorder, job_id) { holding(slot) { execution.run("slow", command, recorder, job_id) } }
       end

data/lib/fun_ci/pipeline/stage_execution.rb

@@ -7,12 +7,18 @@ module FunCi
   module Pipeline
     # Runs a stage that has been started, in `dir`, with a stage directory of
     # its own, and records how it ended while it still holds both. The same
-    # for every stage, the slow suite in its forked child included.
+    # for every stage, the slow suite in its forked child included, and for
+    # a daily or weekly job.
     class StageExecution
-      def initialize(seams:, dir:, commit:)
+      # launching: what the script is launched with besides its output window
+      # (ProcessRunner::Launch): what it is told about itself, by default its
+      # stage's name in FUN_CI_STAGE (acceptance-tests.md, AT-10.7), and the
+      # files it holds open.
+      def initialize(seams:, dir:, commit:, launching: {})
         @seams = seams
         @dir = dir
         @commit = commit
+        @launching = launching
       end
 
       # Answers [the outcome recorded, what the stage printed].
@@ -36,10 +42,9 @@ module FunCi
         StageEnd::Finished.new(output: output, status: status, timed_out: timed_out, overrun: overrun)
       end
 
-      # The stage learns its name from FUN_CI_STAGE (acceptance-tests.md, AT-10.7).
       def execute(stage, command, stage_dir, before_kill, &)
         window = stage_dir.window
-        launch = ProcessRunner::Launch.new(env: { "FUN_CI_STAGE" => stage }, output: window,
+        launch = ProcessRunner::Launch.new(env: { "FUN_CI_STAGE" => stage }, **@launching, output: window,
                                            before_kill: before_kill)
         @seams.executor(@dir).call(command, @seams.budgets[stage], launch, &)
       ensure

data/lib/fun_ci/pipeline/trigger.rb

@@ -29,9 +29,12 @@ module FunCi
       def run
         config = Setup::ProjectConfig.new(@project)
         return handle_config_errors(config) if config.validate.any?
-        return unknown_commit unless known_commit?
 
-        start_run
+        full = full_sha
+        return unknown_commit unless full
+
+        @commit = @commit.with(sha: full)
+        start_run(config)
         checking_the_trunk { run_in(workspace.acquire(@commit.sha)) }
       end
 
@@ -44,7 +47,8 @@ module FunCi
       private
 
       def recorder = @seams.recorder
-      def known_commit? = @commit.sha == NULL_SHA || @seams.commit_validator.call(@commit.sha)
+      # Runs are kept under the full SHA, whatever revision named the commit.
+      def full_sha = @commit.sha == NULL_SHA ? NULL_SHA : @seams.commit_resolver.call(@commit.sha)
 
       def workspace = @seams.workspace || Workspaces.for(@project, @commit.sha)
       def branch = Persistence::Branch.new(project: @project, name: @commit.branch)
@@ -56,11 +60,16 @@ module FunCi
         committed.folder_exists? ? committed : Setup::ProjectConfig.new(@project)
       end
 
-      # The check is recorded by the recorder the run holds once its stages are done.
+      # The check is recorded by the recorder the run holds once its stages are
+      # done, and before the run says its foreground is: until then, a reader
+      # takes a check not yet recorded to be still going.
       def checking_the_trunk
         trunk = TrunkRun.start(@seams.trunk || Trunk::Checker.for(@project), @commit.sha, recorder)
         @io.stdout.puts(trunk.notice) if trunk.notice
-        yield.tap { trunk.finish(recorder) }
+        yield.tap do
+          trunk.finish(recorder)
+          recorder.foreground_done
+        end
       end
 
       def handle_config_errors(config)
@@ -77,7 +86,9 @@ module FunCi
         1
       end
 
-      def start_run
+      # A mistake in the config is named, and its defaults used.
+      def start_run(config)
+        config.settings_errors.each { |e| @io.stdout.puts "fun-ci: #{e}" }
         recorder.report_trouble_to(@io.stdout)
         cancel_stale_pipelines
         recorder.create_run(commit_hash: @commit.sha, branch: @commit.branch, project_path: @project)

data/lib/fun_ci/pipeline/trigger_command.rb

@@ -56,11 +56,21 @@ module FunCi
         return 0 unless forked
 
         say_how_to_wait(commit.sha[0, 7])
-        @io.stdout.puts(forked.notice) if forked.notice
+        say(forked)
         0
       end
 
-      def say_how_to_wait(sha) = @io.stdout.puts("fun-ci: testing #{sha}. Verdict: fun-ci wait #{sha} --need all")
+      # The config's mistakes and the first fetch's notice, and on stderr, why
+      # the jobs didn't start; the run itself prints nowhere.
+      def say(forked)
+        Setup::ProjectConfig.new(@project).settings_errors.each { |e| @io.stdout.puts "fun-ci: #{e}" }
+        @io.stdout.puts(forked.notice) if forked.notice
+        @io.stderr.puts(forked.jobs) if forked.jobs
+      end
+
+      def say_how_to_wait(sha)
+        @io.stdout.puts("fun-ci: testing #{sha}. Verdict: fun-ci wait #{sha} --need all --follow-branch")
+      end
     end
   end
 end

data/lib/fun_ci/pipeline/trigger_params.rb

@@ -5,13 +5,13 @@ require_relative "../persistence/pipeline_recorder"
 require_relative "command_executor"
 require_relative "stage_dir"
 require_relative "git_environment"
+require_relative "priorities"
+require_relative "budgets"
 require_relative "../evidence/command_runner"
 require_relative "../evidence/process_table"
 
 module FunCi
   module Pipeline
-    DEFAULT_BUDGETS = { "lint" => 30, "build" => 30, "fast" => 10, "slow" => 300 }.freeze
-
     Commit = Data.define(:sha, :branch)
 
     # On a detached HEAD git names no branch, and the hooks pass "": the run
@@ -33,22 +33,33 @@ module FunCi
     # own extractors (`run:` entries), given dir:, env: and scratch:;
     # `process_table` answers what ps lists, for a stage over budget; `trunk`
     # checks a commit against the trunk (#check(sha) answers a Trunk::Check,
-    # or nil for no check), nil for the project's own.
-    Seams = Data.define(:command_runner, :time_budgets, :commit_validator, :recorder, :background_launcher, :workspace,
-                        :stage_dir, :environment, :clock, :extractor_runner, :process_table, :trunk)
+    # or nil for no check), nil for the project's own; `priorities` what jobs
+    # and the slow suite start under.
+    Seams = Data.define(:command_runner, :time_budgets, :commit_resolver, :recorder, :background_launcher, :workspace,
+                        :stage_dir, :environment, :clock, :extractor_runner, :process_table, :trunk, :priorities)
 
     # Reopened rather than given as a block to Data.define, so tools that read
     # the source (mutineer) see these as Seams' methods.
     class Seams
+      # Seconds, for the evidence budget. Kept out of `defaults`' hash: a block
+      # on a line the hash continues onto gives that line the block's count,
+      # and the mutation lane then runs the hash's later lines' mutants only
+      # against tests that call it (test/support/statement_coverage.rb).
+      MONOTONIC = -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+
       def self.defaults
         { command_runner: nil, time_budgets: {}, recorder: Persistence::NullRecorder.new, background_launcher: nil,
-          workspace: nil, commit_validator: method(:commit_exists?), stage_dir: StageDir.method(:create),
-          environment: ENV.to_h, clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) },
+          workspace: nil, commit_resolver: method(:full_sha), stage_dir: StageDir.method(:create),
+          environment: ENV.to_h, clock: MONOTONIC,
           extractor_runner: Evidence::CommandRunner.method(:new),
-          process_table: Evidence::ProcessTable.method(:now), trunk: nil }
+          process_table: Evidence::ProcessTable.method(:now), trunk: nil, priorities: Priorities.for(RUBY_PLATFORM) }
       end
 
-      def self.commit_exists?(sha) = Open3.capture2e(GitEnvironment::CLEAN, "git", "cat-file", "-t", sha).last.success?
+      # The full SHA of the commit `rev` names, or nil when the repository has none.
+      def self.full_sha(rev)
+        out, status = Open3.capture2(GitEnvironment::CLEAN, "git", "rev-parse", "--verify", "-q", "#{rev}^{commit}")
+        out.strip if status.success?
+      end
 
       def initialize(**given) = super(**self.class.defaults.merge(given))
       def budgets = DEFAULT_BUDGETS.merge(time_budgets)

data/lib/fun_ci/pipeline/worktree_pool.rb

@@ -20,10 +20,10 @@ module FunCi
         @waiter = waiter
       end
 
+      # A ColdSlot when the slot's worktree had to be made.
       def acquire(sha)
         slot = wait_for_free_slot
-        @worktrees.check_out(slot.path, sha)
-        slot
+        @worktrees.check_out(slot.path, sha) ? slot.as_cold : slot
       rescue StandardError
         slot&.release
         raise

data/lib/fun_ci/pipeline/worktree_prune.rb

@@ -5,8 +5,9 @@ require_relative "worktrees"
 
 module FunCi
   module Pipeline
-    # Removes every slot of a project's worktree pool, and git's entries for
-    # them, when no run holds one. It takes each slot's lock first, so a run
+    # Removes every slot of a project's worktree pool and every daily or
+    # weekly job's worktree, and git's entries for them, when no run or job
+    # holds one. It takes each slot's lock first, so a run
     # starting meanwhile waits until the slot is gone and then checks it out
     # afresh.
     class WorktreePrune
@@ -16,8 +17,8 @@ module FunCi
         @worktrees = worktrees
       end
 
-      # How many slots it removed. Raises Busy, removing nothing, while a run
-      # holds a slot.
+      # How many worktrees it removed. Raises Busy, removing nothing, while a
+      # run or a job holds one.
       def run
         locks = take_locks
         locks.each { |lock| FileUtils.rm_rf(lock.path.delete_suffix(".lock")) }
@@ -37,12 +38,13 @@ module FunCi
           next if locks.last.flock(File::LOCK_EX | File::LOCK_NB)
 
           locks.each(&:close)
-          raise Busy, "a pipeline is running in #{path}"
+          raise Busy, "fun-ci is running something in #{path}"
         end
       end
 
       def slot_paths
-        Dir.glob(File.join(@worktrees.root, "slot-*")).map { |path| path.delete_suffix(".lock") }.uniq
+        (Dir.glob(File.join(@worktrees.root, "slot-*")) + Dir.glob(File.join(@worktrees.jobs_root, "*")))
+          .map { |path| path.delete_suffix(".lock") }.uniq
       end
     end
   end

data/lib/fun_ci/pipeline/worktrees.rb

@@ -13,18 +13,20 @@ module FunCi
         @project_root = project_root
       end
 
-      def root
-        File.join(File.expand_path(git(@project_root, "rev-parse", "--git-common-dir").strip, @project_root),
-                  "fun-ci", "worktrees")
-      end
+      def root = File.join(fun_ci_dir, "worktrees")
+
+      # Where each daily and weekly job has a worktree of its own (Jobs::Locks).
+      def jobs_root = File.join(fun_ci_dir, "jobs")
 
       # Leaves +path+ as a clean detached checkout of +sha+. Ignored files stay,
       # so caches such as vendor/bundle survive between runs in the same slot.
+      # Answers whether it made the worktree, which then has no caches.
       def check_out(path, sha)
-        return add(path, sha) unless File.exist?(File.join(path, ".git"))
+        return add(path, sha).then { true } unless File.exist?(File.join(path, ".git"))
 
         git(path, "checkout", "--detach", "--force", sha)
         git(path, "clean", "-fd")
+        false
       end
 
       # Has git forget the worktrees whose directories are gone.
@@ -32,6 +34,10 @@ module FunCi
 
       private
 
+      def fun_ci_dir
+        File.join(File.expand_path(git(@project_root, "rev-parse", "--git-common-dir").strip, @project_root), "fun-ci")
+      end
+
       def add(path, sha) = git(@project_root, "worktree", "add", "--detach", "--force", path, sha)
 
       def git(dir, *args)

data/lib/fun_ci/setup/agent_instructions.rb

@@ -4,7 +4,8 @@ module FunCi
   module Setup
     # What `fun-ci init` tells a coding agent working in the project, in the
     # instructions file agents read (acceptance-tests.md, AT-9.15): AGENTS.md,
-    # or CLAUDE.md when that is the only one. The marker keeps it to once.
+    # or CLAUDE.md when that is the only one. The marker keeps it to once, and
+    # finds a section an older fun-ci wrote, to bring it up to date.
     module AgentInstructions
       MARKER = "<!-- fun-ci: agent instructions -->"
       SECTION = <<~MD.freeze
@@ -13,22 +14,40 @@ module FunCi
         #{MARKER}
         This project runs fun-ci on every commit. After each commit, run the
         `fun-ci wait` command it prints, in the background, and act on its exit
-        code: 0 passed, 1 failed, 2 over budget, 3 undecided, 4 superseded.
+        code: 0 passed, 1 failed, 2 over budget, 3 undecided. A newer commit on
+        the branch cancels the run and the wait moves on to the newer one's.
         `fun-ci wait --need all` must exit 0 before the work is called done.
         Before calling work done, run `fun-ci wait --need all --trunk`; 6 means
         the commit conflicts with the trunk, which has to be integrated first,
         as it prints.
         `fun-ci runs` lists recent runs, and `fun-ci status` says where one stands.
+        `fun-ci jobs` lists the daily and weekly jobs, which run beside the
+        pipeline and never hold up a verdict, and `fun-ci why --job NAME` says
+        why one failed.
       MD
 
+      # A section in the text: from the heading over the marker, if it has
+      # one, to the next heading or the end.
+      WRITTEN = /^(?:## fun-ci\n\s*)?#{Regexp.escape(MARKER)}\n.*?(?=^#|\z)/m
+
       def self.file_for(names) = names.include?("CLAUDE.md") && !names.include?("AGENTS.md") ? "CLAUDE.md" : "AGENTS.md"
 
-      # The text with the section added, or nil when it has it already.
+      # The text with the section added, or brought up to date; nil when it
+      # has this one already.
       def self.merged(text)
-        return nil if text.include?(MARKER)
+        merged = text.include?(MARKER) ? replaced(text) : added(text)
+        merged unless merged == text
+      end
 
-        text.strip.empty? ? SECTION : "#{text.rstrip}\n\n#{SECTION}"
+      def self.said(text, file)
+        return "Told agents what to do after a commit, in #{file}." unless text.include?(MARKER)
+
+        "Brought the fun-ci section of #{file} up to date."
       end
+
+      def self.added(text) = text.strip.empty? ? SECTION : "#{text.rstrip}\n\n#{SECTION}"
+      def self.replaced(text) = text.sub(WRITTEN) { Regexp.last_match.post_match.empty? ? SECTION : "#{SECTION}\n" }
+      private_class_method :added, :replaced
     end
   end
 end

data/lib/fun_ci/setup/commands.rb

@@ -32,7 +32,9 @@ module FunCi
         install(args.any? ? [args.first] : HookScript.types)
       end
 
-      def check(_args) = SetupChecker.run(project_root: @project_root, stdout: @stdout)
+      def check(_args)
+        SetupChecker.run(project_root: @project_root, stdout: @stdout, hooks_dir: @hooks_dir.call(@project_root))
+      end
 
       private
 

data/lib/fun_ci/setup/hook_script.rb

@@ -7,11 +7,15 @@ module FunCi
       MARKER = "# fun-ci-managed-hook"
       NULL_SHA = "0" * 40
 
+      NOT_INSTALLED = %(echo "fun-ci is not installed or not on PATH, so this runs without CI. ) +
+                      %(Install it with: gem install fun_ci" >&2)
+      INSTALLED = "command -v fun-ci >/dev/null 2>&1"
+
       GUARD = <<~SH.freeze
         #!/bin/sh
         #{MARKER}
-        if ! command -v fun-ci >/dev/null 2>&1; then
-          echo "fun-ci is not installed or not on PATH, so this runs without CI. Install it with: gem install fun_ci" >&2
+        if ! #{INSTALLED}; then
+          #{NOT_INSTALLED}
           exit 0
         fi
       SH
@@ -26,7 +30,7 @@ module FunCi
       # Before a push: the fast verdict of each commit git says it pushes
       # (acceptance-tests.md, AT-9.13). A deleted ref pushes the null SHA, and
       # exit 5 is a project not set up for fun-ci, which pushes without CI.
-      PRE_PUSH = <<~SH.freeze
+      PRE_PUSH_WAITS = <<~SH.freeze
         status=0
         while read -r local_ref local_sha remote_ref remote_sha; do
           [ "$local_sha" = "#{NULL_SHA}" ] && continue
@@ -34,9 +38,10 @@ module FunCi
           code=$?
           [ "$code" -eq 0 ] || [ "$code" -eq 5 ] || status=1
         done
-        exit $status
       SH
 
+      PRE_PUSH = "#{PRE_PUSH_WAITS}exit $status\n".freeze
+
       BODIES = { "post-commit" => POST_COMMIT, "pre-push" => PRE_PUSH }.freeze
 
       def self.types = BODIES.keys

data/lib/fun_ci/setup/hook_writer.rb

@@ -2,6 +2,7 @@
 
 require "fileutils"
 require_relative "hook_script"
+require_relative "lfs_hook"
 
 module FunCi
   module Setup
@@ -23,8 +24,9 @@ module FunCi
         return reject("Unknown hook type: #{@hook_type}") unless HookScript.types.include?(@hook_type)
         return skip("Hook #{@hook_type} already exists from another tool, so it was left alone.") if foreign_hook?
 
-        write_hook
-        @stdout.puts "Installed #{@hook_type} hook."
+        lfs = lfs?
+        write_hook(lfs ? LfsHook.script(@hook_type) : HookScript.for(@hook_type))
+        @stdout.puts "Installed #{@hook_type} hook#{", which runs git-lfs's too" if lfs}."
         0
       end
 
@@ -33,13 +35,19 @@ module FunCi
       def git_repo? = !@hooks_dir.nil?
       def hook_path = File.join(@hooks_dir, @hook_type)
 
+      def existing = File.exist?(hook_path) ? File.read(hook_path) : ""
+
+      # git-lfs's own hook is not left alone: fun-ci's runs it.
       def foreign_hook?
-        File.exist?(hook_path) && !HookScript.managed?(File.read(hook_path))
+        script = existing
+        !script.empty? && !HookScript.managed?(script) && !LfsHook.stock?(script, @hook_type)
       end
 
-      def write_hook
+      def lfs? = LfsHook.runs_lfs?(existing, @hook_type)
+
+      def write_hook(script)
         FileUtils.mkdir_p(@hooks_dir)
-        File.write(hook_path, HookScript.for(@hook_type))
+        File.write(hook_path, script)
         File.chmod(0o755, hook_path)
       end
 

data/lib/fun_ci/setup/installed_hooks.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "lfs_hook"
+
+module FunCi
+  module Setup
+    # The post-commit and pre-push hooks git runs, as `fun-ci check` warns of
+    # them: one that doesn't run fun-ci tests no commit, or lets a push
+    # through without a verdict. `fun-ci install-hooks` writes either when it
+    # is missing or git-lfs's own; another tool's has to call fun-ci itself.
+    class InstalledHooks
+      WHAT = { "post-commit" => "No commit is tested", "pre-push" => "No push waits for a verdict" }.freeze
+      INSTALL = "Run `fun-ci install-hooks`"
+      CALL = { "post-commit" => "`fun-ci trigger --background <commit> <branch>`",
+               "pre-push" => "`fun-ci wait <commit> --need fast` for each commit pushed" }.freeze
+
+      # hooks_dir: where git runs the project's hooks from; nil outside a git repository.
+      def initialize(hooks_dir)
+        @hooks_dir = hooks_dir
+      end
+
+      def warnings
+        return [] unless @hooks_dir
+
+        WHAT.keys.map { |type| warning(type, script(type)) }.compact
+      end
+
+      private
+
+      def script(type)
+        path = File.join(@hooks_dir, type)
+        File.exist?(path) ? File.read(path) : ""
+      end
+
+      def warning(type, script)
+        return nil if script.include?("fun-ci")
+        return "#{WHAT[type]}: the #{type} hook doesn't run fun-ci. #{INSTALL}" if install_fixes?(script, type)
+
+        "#{WHAT[type]}: the #{type} hook is another tool's and doesn't run fun-ci. Have it run #{CALL[type]}"
+      end
+
+      def install_fixes?(script, type) = script.empty? || LfsHook.stock?(script, type)
+    end
+  end
+end

data/lib/fun_ci/setup/installer.rb

@@ -44,11 +44,12 @@ module FunCi
       def tell_agents
         file = AgentInstructions.file_for(Dir.children(@project_root))
         path = File.join(@project_root, file)
-        merged = AgentInstructions.merged(File.exist?(path) ? File.read(path) : "")
+        told = File.exist?(path) ? File.read(path) : ""
+        merged = AgentInstructions.merged(told)
         return unless merged
 
         File.write(path, merged)
-        @stdout.puts "Told agents what to do after a commit, in #{file}."
+        @stdout.puts AgentInstructions.said(told, file)
       end
 
       def initialised?