hecks 5.0.0 → 7.0.0

data/lib/hecks/hecks/adapters/codebase/test_runner.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "stringio"
+require "open3"
+require "rbconfig"
 require_relative "tree"
 require_relative "../console_capture"
 
@@ -13,10 +15,28 @@ module Hecks
       # description for a shell. What the runner prints is captured and comes back as the answer;
       # a run that fails refuses with the same text.
       class TestRunner
+        # The program a fresh process runs: the test runner, on the arguments it is handed.
+        FRESH_RUNNER = 'require "rspec/core"; exit RSpec::Core::Runner.run(ARGV)'
+
         class << self
           # @return [#call, nil] takes `(args, err, out)` and answers the exit status; the test
           #   runner when nil. A spec replaces it so no example has to run to test what is asked.
           attr_accessor :runner
+
+          # The runner is asked for from inside a command's own reaction cascade, and the
+          # dispatcher keeps that cascade's depth on the thread. A run starts at depth zero, as a
+          # plain run does, so work that cascades four deep is not cut off by the cascade that
+          # launched it.
+          #
+          # @yield the work to run at depth zero
+          # @return [Object] what the block answers
+          def at_reaction_depth_zero
+            depth = Thread.current[:hecks_reaction_depth]
+            Thread.current[:hecks_reaction_depth] = 0
+            yield
+          ensure
+            Thread.current[:hecks_reaction_depth] = depth
+          end
         end
 
         # @param tree [Tree] the checkout whose spec is run
@@ -28,38 +48,86 @@ module Hecks
         #
         # @param file [String] the spec file, relative to the checkout or absolute
         # @param example [String] part of the example's description
+        # @param env [Hash{String => String}] variables the specs read, set for this run only
+        # @param tags [String, nil] RSpec tag filters as the runner spells them, such as
+        #   `--tag cloudfront`
         # @return [String] what the runner printed when every matching example passed
         # @raise [ConsoleCapture::Failure] when the file is not there, or an example failed
-        def run(file:, example:)
+        def run(file:, example:, env: {}, tags: nil)
           path = File.expand_path(file, @tree.root)
           raise ConsoleCapture::Failure, "no such spec file #{file}" unless File.file?(path)
 
-          report = run_example(path, example)
+          report = with_env(env) { run_example(path, example, tags.to_s.split) }
           raise ConsoleCapture::Failure, "the test runner printed nothing for #{file}" if report.empty?
 
           report
         end
 
+        # Runs every spec in the given files or directories, from the checkout's root: a whole suite
+        # is one directory, a changed-file run is the specs those files map to.
+        #
+        # @param paths [Array<String>] spec files or directories, relative to the checkout or
+        #   absolute
+        # @param env [Hash{String => String}] variables the specs read, set for this run only
+        # @param tags [String, nil] RSpec tag filters as the runner spells them
+        # @return [String] what the runner printed when every spec it ran passed
+        # @raise [ConsoleCapture::Failure] when a path is not there, or a spec failed
+        def run_paths(paths:, env: {}, tags: nil)
+          missing = paths.reject { |path| File.exist?(File.expand_path(path, @tree.root)) }
+          raise ConsoleCapture::Failure, "no such spec #{missing.first}" unless missing.empty?
+
+          report = with_env(env) { run_args([*tags.to_s.split, *paths]) }
+          raise ConsoleCapture::Failure, "the test runner printed nothing for #{paths.join(" ")}" if report.empty?
+
+          report
+        end
+
+        # Runs the runner on the arguments and answers how it ended, whatever the result: a
+        # caller that reports each of several runs reads the status, not a refusal.
+        #
+        # @param args [Array<String>] the runner's arguments
+        # @param env [Hash{String => String}] variables the specs read, set for this run only
+        # @param fresh [Boolean] whether to run it in a new process of its own (nothing a spec
+        #   defined, stubbed or registered carries over) or in this one
+        # @return [Array(Integer, String)] the exit status and what the runner printed
+        def outcome(args, env: {}, fresh: false)
+          return with_env(env) { in_process(args) } unless fresh
+
+          printed, status = Open3.capture2e(env, RbConfig.ruby, "-e", FRESH_RUNNER, "--", *args, chdir: @tree.root)
+          [status.exitstatus || 1, printed.strip]
+        end
+
         private
 
         # What the runner printed for the example, when it passed.
-        def run_example(path, example)
-          out = StringIO.new
-          status = Dir.chdir(@tree.root) { at_reaction_depth_zero { runner.call(["--example", example, path], out, out) } }
-          raise ConsoleCapture::Failure, out.string.strip unless status.zero?
+        def run_example(path, example, tags = [])
+          run_args(["--example", example, *tags, path])
+        end
 
-          out.string.strip
+        # What the runner printed for the arguments, when every spec it ran passed.
+        def run_args(args)
+          status, printed = in_process(args)
+          raise ConsoleCapture::Failure, printed unless status.zero?
+
+          printed
         end
 
-        # The runner is asked for from inside a command's own reaction cascade, and the dispatcher
-        # keeps that cascade's depth on the thread. An example starts at depth zero, as a plain run
-        # does, so a spec that cascades four deep is not cut off by the cascade that launched it.
-        def at_reaction_depth_zero
-          depth = Thread.current[:hecks_reaction_depth]
-          Thread.current[:hecks_reaction_depth] = 0
+        # The runner's exit status and what it printed, for the arguments, in this process.
+        def in_process(args)
+          out = StringIO.new
+          status = Dir.chdir(@tree.root) { at_reaction_depth_zero { runner.call(args, out, out) } }
+          [status, out.string.strip]
+        end
+
+        def at_reaction_depth_zero(&) = self.class.at_reaction_depth_zero(&)
+
+        # Sets the variables for the block and puts each back as it was.
+        def with_env(env)
+          before = env.keys.to_h { |name| [name, ENV.fetch(name, nil)] }
+          env.each { |name, value| ENV[name] = value }
           yield
         ensure
-          Thread.current[:hecks_reaction_depth] = depth
+          before.each { |name, value| value.nil? ? ENV.delete(name) : ENV[name] = value }
         end
 
         def runner

data/lib/hecks/hecks/adapters/codebase/test_scope.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "../console_capture"
+
+module Hecks
+  module Adapters
+    module Codebase
+      # How much of the spec suite this machine may run, from the world's
+      # `test_scope "Local", suite_runs_in: "ci", spec_files_limit: n` setting. Owner decision: the
+      # full suite runs only in CI (the `rspec` check is `runs_in: "ci"` in the Vocabulary rows),
+      # and a change is checked locally by the quick gate and the specs named for it, at most
+      # `spec_files_limit` files per call.
+      #
+      # CI is detected here, by the environment (`CI` or `GITHUB_ACTIONS`), never by the bluebook. A
+      # world that declares no `test_scope` (a client's project) is not limited.
+      class TestScope
+        # The world verb that carries the setting.
+        VERB = "test_scope"
+
+        # The spec files a directory holds.
+        SPEC_GLOB = "**/*_spec.rb"
+
+        # @param registry [Runtime::Registry, nil] the booted registry whose Hecks world is read
+        # @return [Hash{Symbol => Object}] the declared setting, empty when none is
+        def self.setting(registry) = registry&.world("Hecks")&.for_verb(VERB) || {}
+
+        # @param registry [Runtime::Registry, nil]
+        # @return [Integer, nil] the most spec files a local call may run, nil when none is declared
+        def self.limit(registry)
+          declared = setting(registry)[:spec_files_limit]
+          declared && Integer(declared)
+        end
+
+        # @param registry [Runtime::Registry, nil] the booted registry whose Hecks world is read
+        # @param env [#[]] the process environment
+        def initialize(registry, env: ENV)
+          @setting = self.class.setting(registry)
+          @env = env
+        end
+
+        # @return [Integer, nil] the limit that holds here: nil in CI or when none is declared
+        def limit = (Integer(@setting[:spec_files_limit]) if @setting[:spec_files_limit] && !ci?)
+
+        # @return [Boolean] whether this process runs in CI
+        def ci? = %w[CI GITHUB_ACTIONS].any? { |name| !["", "false"].include?(@env[name].to_s) }
+
+        # Lets a request through, or refuses one that would run more than this machine may. An
+        # impacted run that names no cap gets the limit as its cap.
+        #
+        # @param operation [String] the `TestSuiteRun` operation
+        # @param held [Hash] the record's fields, each perhaps a value object's `{ value: x }`
+        # @param tree [Tree] the folder whose specs would run
+        # @return [Hash] the fields to carry the operation out with
+        # @raise [ConsoleCapture::Failure] naming the limit and CI
+        def admit(operation, held, tree)
+          args = held.transform_values { |value| value.is_a?(Hash) ? value[:value] : value }
+          refuse!(operation, args, tree) unless ci?
+          return held unless operation == "run_impacted_specs" && limit && args[:cap].nil?
+
+          held.merge(cap: { value: limit })
+        end
+
+        private
+
+        def refuse!(operation, args, tree)
+          case operation
+          when "run_suite" then refuse_suite
+          when "run_spec_files" then refuse_files(files_in(args[:files], tree))
+          when "run_impacted_specs" then refuse_cap(args[:cap])
+          end
+        end
+
+        def refuse_suite
+          return unless @setting[:suite_runs_in].to_s == "ci"
+
+          fail!("the full suite runs in CI (rspec runs_in \"ci\"); run named specs, or run_impacted_specs!")
+        end
+
+        def refuse_files(count)
+          return if limit.nil? || count <= limit
+
+          fail!("run_spec_files! runs at most #{limit} spec files per call locally (spec_files_limit); #{count} named. " \
+                "The full suite runs in CI (rspec runs_in \"ci\"): name fewer files, or run_impacted_specs!")
+        end
+
+        def refuse_cap(cap)
+          return if limit.nil? || cap.nil? || Integer(cap) <= limit
+
+          fail!("run_impacted_specs! caps at #{limit} spec files locally (spec_files_limit); cap.value=#{cap} is more. " \
+                "The full suite runs in CI (rspec runs_in \"ci\")")
+        end
+
+        # A named directory counts as the spec files it holds.
+        def files_in(files, tree)
+          Array(files).flat_map { |name| name.to_s.split }.uniq.sum do |name|
+            path = File.expand_path(name, tree.root)
+            File.directory?(path) ? Dir.glob(File.join(path, SPEC_GLOB)).size : 1
+          end
+        end
+
+        def fail!(message) = raise(ConsoleCapture::Failure, message)
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/codebase/test_suite.rb

@@ -1,8 +1,15 @@
 # frozen_string_literal: true
 
+require "fileutils"
 require_relative "tree"
+require_relative "minitest_runs"
+require_relative "run_options"
 require_relative "test_runner"
+require_relative "changed_specs"
+require_relative "batch_runs"
 require_relative "sqlite_fixture"
+require_relative "cargo_tests"
+require_relative "cache_clearing"
 
 module Hecks
   module Adapters
@@ -10,15 +17,23 @@ module Hecks
       # What Codebase's `TestSuiteRun` asks of the working tree: the tooling around this
       # repository's specs.
       #
-      # The tooling owns its options, so each ask runs one of the `Hecks::CLI` commands in this
+      # The tooling owns its options, so each ask runs one of the `Hecks::Tools` commands in this
       # process from the checkout's root, except a single example (the `TestRunner` adapter runs it)
       # and the persistence fixtures (the `SqliteFixture` adapter). A listing is a pure read.
       # Refreshing the committed timings, regenerating the fixtures and writing the committed spec
       # list change tracked files, so unconfirmed they report what they would do and write nothing.
       module TestSuite
         # Every operation this family carries out.
-        OPERATIONS = %w[refresh_runtime_baseline run_spec_example stress_concurrency
-                        regenerate_legacy_fixtures seed_semantics_corpus write_io_parallel_spec_list].freeze
+        OPERATIONS = %w[refresh_runtime_baseline run_spec_example run_spec_files run_impacted_specs run_suite run_changed
+                        stress_concurrency run_cargo_tests clear_caches regenerate_legacy_fixtures seed_semantics_corpus
+                        write_io_parallel_spec_list].freeze
+
+        # The operations that run specs in a folder of their own: they need that folder to hold
+        # specs, not to be this checkout, so any project's suite runs through them.
+        FOLDER_OPERATIONS = %w[run_spec_example run_spec_files run_impacted_specs run_suite run_changed].freeze
+
+        # The spec directory a folder's whole suite lives in.
+        SPEC_DIRECTORY = "spec"
 
         # The tag filter the postgres job lists its specs by when none is named.
         DEFAULT_TAGS = "--tag io --tag ~fuzzing"
@@ -28,14 +43,14 @@ module Hecks
 
         module_function
 
-        # Loads the command a `Hecks::CLI` file defines, the first time an ask needs it: several
+        # Loads the command a `Hecks::Tools` file defines, the first time an ask needs it: several
         # read the checkout's specs or need a development gem, which an installed gem lacks.
         #
-        # @param file [String] the command's file under `lib/hecks/cli/`, without the extension
+        # @param file [String] the command's file under `lib/hecks/tools/`, without the extension
         # @return [Module] the command, named as the file is, in camel case
         def command(file)
-          require "hecks/cli/#{file}"
-          Hecks::CLI.const_get(file.split("_").map(&:capitalize).join)
+          require "hecks/tools/#{file}"
+          Hecks::Tools.const_get(file.split("_").map(&:capitalize).join)
         end
 
         # Carries out one operation.
@@ -48,9 +63,23 @@ module Hecks
         # @raise [ConsoleCapture::Failure] when a run fails or a script is refused
         def call(operation, held, tree, shell: nil)
           args = plain(held)
+          case operation
+          when *BatchRuns::OPERATIONS then BatchRuns.call(operation, args, tree)
+          when "run_suite" then suite(args, tree)
+          when "run_changed" then changed(args, tree)
+          when "run_cargo_tests" then CargoTests.run(args, tree, shell)
+          when "clear_caches" then CacheClearing.clear
+          else tooling(operation, args, tree, shell)
+          end
+        end
+
+        # The operations that run one of the repository's own tools.
+        #
+        # @param operation [String] one of `OPERATIONS`
+        # @return [String] what the tool printed
+        def tooling(operation, args, tree, shell)
           case operation
           when "refresh_runtime_baseline" then refresh(args, tree)
-          when "run_spec_example" then TestRunner.new(tree).run(file: args[:file], example: args[:example])
           when "stress_concurrency" then stress(args, tree)
           when "regenerate_legacy_fixtures" then regenerate_fixtures(args, tree, shell)
           when "seed_semantics_corpus" then seed(args, tree)
@@ -58,11 +87,41 @@ module Hecks
           end
         end
 
+        # Runs every spec of the folder's spec directory in one process.
+        #
+        # @param args [Hash] `tags`, `strict`, `seeds` and `environment`, each perhaps absent
+        # @param tree [Tree] the folder whose specs run
+        # @return [String] what the runner printed
+        def suite(args, tree)
+          rspec = TestRunner.new(tree).run_paths(paths: [SPEC_DIRECTORY], env: RunOptions.spec_env(args), tags: args[:tags])
+          minitest = MinitestRuns.files(tree)
+          return rspec if minitest.empty?
+
+          ([rspec] + MinitestRuns.reports(tree, minitest)).join("\n")
+        end
+
+        # Runs the specs the files changed since a git ref map to, by name. Says so and runs nothing
+        # when no spec maps to a change, so an unmapped change never falls back to the whole suite.
+        #
+        # @param args [Hash] `base` (the ref, `origin/main` when absent), and the run's variables
+        # @param tree [Tree] the folder whose changes are read
+        # @return [String] what the runner printed, or that no spec maps to the changes
+        # @raise [ConsoleCapture::Failure] when git cannot read the changes
+        def changed(args, tree)
+          base = args[:base] || "origin/main"
+          files = ChangedSpecs.changed_files(tree, base)
+          specs = Dir.glob("#{SPEC_DIRECTORY}/**/*_spec.rb", base: tree.root).sort
+          mapped = ChangedSpecs.call(files, specs)
+          return "no spec maps to the #{files.size} changed file(s) since #{base}; nothing run" if mapped.empty?
+
+          TestRunner.new(tree).run_paths(paths: mapped, env: RunOptions.spec_env(args), tags: args[:tags])
+        end
+
         # @param args [Hash] `runs`, `parallel` and `seed_start`
         # @param tree [Tree] the checkout
         # @return [String] what the stress run printed
         def stress(args, tree)
-          answer { command("stress_concurrency_specs").call(stress_flags(args), root: tree.root) }
+          answer { command("stress_concurrency_specs").call(RunOptions.stress_flags(args), root: tree.root) }
         end
 
         # @param args [Hash] `confirm`
@@ -73,11 +132,15 @@ module Hecks
           SqliteFixture.new(tree, shell: shell).regenerate(confirm: args[:confirm] == true)
         end
 
+        # Seeds at reaction depth zero, as a plain run would: the replay's sagas cascade, and the
+        # launching command's own cascade would otherwise cut them short.
+        #
         # @param args [Hash] `fixture`, perhaps absent
         # @param tree [Tree] the checkout
         # @return [String] what the seeding printed
         def seed(args, tree)
-          answer { command("seed_semantics_corpus").call(root: tree.root, env: seed_env(args)) }
+          seeding = command("seed_semantics_corpus")
+          answer { TestRunner.at_reaction_depth_zero { seeding.call(root: tree.root, env: RunOptions.seed_env(args)) } }
         end
 
         # A pure read: a listing, or the recorded pattern cases.
@@ -153,17 +216,6 @@ module Hecks
             "and rewrite #{BASELINES.join(", ")} (add --confirm)"
         end
 
-        # @param args [Hash] `runs`, `parallel` and `seed_start`
-        # @return [Array<String>] the script's flags for those that are named
-        def stress_flags(args)
-          { "--runs" => :runs, "--parallel" => :parallel, "--seed-start" => :seed_start }
-            .filter_map { |flag, name| [flag, args[name].to_s] if args[name] }.flatten
-        end
-
-        # @param args [Hash] `fixture`, perhaps absent
-        # @return [Hash{String => String}] the variable that names the one fixture to re-seed
-        def seed_env(args) = args[:fixture] ? { "SEED" => args[:fixture] } : {}
-
         # @param args [Hash] `exclude`, `tags`, `write` and `confirm`
         # @param tree [Tree] the checkout whose spec list is written
         # @return [String] what was written, or (unconfirmed) how many files would be

data/lib/hecks/hecks/adapters/console_capture.rb

@@ -6,7 +6,7 @@ require "stringio"
 module Hecks
   module Adapters
     # Runs a command-line entry point that prints and exits, and hands back what it said and how
-    # it ended, so an adapter can reuse `Hecks::CLI::*` unchanged.
+    # it ended, so an adapter can reuse `Hecks::Tools::*` unchanged.
     #
     # It is the shared base for every Custodian adapter that wraps an existing CLI: the entry
     # point keeps its own printing, `exit` and `abort`, and the adapter turns the outcome into a
@@ -67,6 +67,33 @@ module Hecks
         e.status
       end
 
+      # Runs the block captured and answers what it printed to stdout alone. What it printed to
+      # stderr (a domain's boot notices) goes on to the real stderr instead of into the answer, and
+      # a run that ended otherwise refuses with both.
+      #
+      # @yield the entry point to run
+      # @return [String] stdout when the entry point ended with status 0
+      # @raise [Failure] when it ended otherwise; the message is what it printed
+      def answer_apart(&)
+        out, err, status = synchronize { apart(&) }
+        raise Failure, (out + err).strip unless status.zero?
+
+        $stderr.write(err)
+        out
+      end
+
+      # Runs the block with each stream pointed at a buffer of its own, putting them back
+      # afterwards.
+      def apart(&)
+        saved = [$stdout, $stderr]
+        out = $stdout = StringIO.new
+        err = $stderr = StringIO.new
+        status = exit_status(&)
+        [out.string, err.string, status]
+      ensure
+        $stdout, $stderr = saved
+      end
+
       # Runs the block captured and answers its text, or refuses with it.
       #
       # @yield the entry point to run

data/lib/hecks/hecks/adapters/cost_explorer.rb

@@ -41,7 +41,7 @@ module Hecks
       # @raise [Error] when no complete day has passed since `since`, `aws` fails, or the
       #   rate is over the budget
       def measure(**held)
-        budget = Integer(plain(held[:budget]))
+        budget = whole_dollars(plain(held[:budget]))
         first = Date.iso8601(plain(held[:since]).to_s)
         last = today
         raise Error, "no complete day since #{first}; today (#{last}) is still being billed" if first >= last
@@ -55,6 +55,14 @@ module Hecks
 
       private
 
+      # @return [Integer] the budget as whole dollars
+      # @raise [Error] when none was given
+      def whole_dollars(budget)
+        raise Error, "no budget given: a whole number of dollars a month" if budget.nil?
+
+        Integer(budget)
+      end
+
       # @return [Date] the day the span ends before: today, in UTC
       def today = @today ? Date.iso8601(@today.to_s) : Time.now.utc.to_date
 

data/lib/hecks/hecks/adapters/deploy_plans.rb

@@ -5,6 +5,15 @@ module Hecks
     # The plan a write to AWS prints when it is refused unconfirmed or run with `dry_run`: what the
     # project's script would do, read from the script's own text, so nothing is run to say it.
     module DeployPlans
+      # The CloudFormation output a companion script reads its box's instance id from.
+      INSTANCE_STACK = /out\s+(\S+)\s+InstanceId/
+
+      # The Compose project a companion script names.
+      COMPOSE_PROJECT = /compose -p (\w+)/
+
+      # The absolute directory a companion script makes on the box.
+      MADE_DIRECTORY = %r{mkdir -p (/\S+)}
+
       module_function
 
       # What `preview.sh <action>` would do for a branch.
@@ -33,9 +42,9 @@ module Hecks
       # @param taskdef [String] the task definition its image and settings are read from
       # @return [String]
       def companion(text, companion, taskdef)
-        stack = text[/out\s+(\S+)\s+InstanceId/, 1]
-        project = text[/compose -p (\w+)/, 1] || companion
-        directory = text[%r{mkdir -p (/\S+)}, 1]
+        stack = text[INSTANCE_STACK, 1]
+        project = text[COMPOSE_PROJECT, 1] || companion
+        directory = text[MADE_DIRECTORY, 1]
         place = directory ? " in #{directory}" : +""
         "roll #{companion} (Compose project #{project}#{place}) from task definition " \
           "#{taskdef} onto the box of stack #{stack || "<box stack>"} over SSM, beside the app's project, " \

data/lib/hecks/hecks/adapters/deploy_toolchain/answers.rb

@@ -10,6 +10,15 @@ module Hecks
       module Answers
         include Statuses
 
+        # The `SCHEMAS=` line of a data-copy script, capturing its default schema list.
+        COPY_SCHEMAS = /^SCHEMAS=(?:\$\{SCHEMAS:-)?"([^"]*)"/
+
+        # The data-copy script's database defaults, capturing the source's and the target's.
+        COPY_DATABASES = /^SRC_DB=\$\{SRC_DB:-([^}]*)\}; DST_DB=\$\{DST_DB:-([^}]*)\}/
+
+        # The last line of a service roll, capturing the taskdef and the tag it rolled.
+        ROLLED_LINE = /^==> rolled taskdef=(\S*) tag=(\S+)$/
+
         private
 
         # Runs the confirmed restore and answers what it printed.
@@ -55,7 +64,7 @@ module Hecks
           report = BluebookReport.new(File.read(File.expand_path(old)), File.read(File.expand_path(new)))
           diff_answer(report.changed? ? "changed" : "unchanged", report.text)
         rescue SystemCallError, JSON::ParserError, TypeError, KeyError => e
-          diff_answer("unavailable", "bluebooks: could not compare #{old} and #{new} (#{e.message.lines.first.strip})")
+          diff_answer("unavailable", "bluebooks: could not compare #{old} and #{new} (#{Text.first_line(e.message)})")
         end
 
         # The script reads the registry and the local image; its report says what it found.
@@ -65,7 +74,7 @@ module Hecks
 
           diff_answer(text.include?("no bluebook changes.") ? "unchanged" : "changed", text)
         rescue ConsoleCapture::Failure => e
-          diff_answer("unavailable", "bluebooks: #{e.message.lines.first.strip}; nothing to compare.")
+          diff_answer("unavailable", "bluebooks: #{Text.first_line(e.message)}; nothing to compare.")
         end
 
         def diff_answer(outcome, text) = { outcome: { value: outcome }, report: { value: text } }
@@ -92,7 +101,7 @@ module Hecks
         # Its schemas are the default of the `SCHEMAS=${SCHEMAS:-"..."}` line (overridable).
         def copy_plan(script, held)
           text = File.read(script)
-          schemas = text[/^SCHEMAS=(?:\$\{SCHEMAS:-)?"([^"]*)"/, 1].to_s.split.join(", ")
+          schemas = text[COPY_SCHEMAS, 1].to_s.split.join(", ")
           source_db, target_db = copy_databases(text, held)
           drop = plain(held[:force]) == true ? "; force=true drops each target schema first" : ""
           "copy schemas #{schemas} from database #{source_db} on #{plain(held[:source])} into database " \
@@ -102,7 +111,7 @@ module Hecks
 
         # The source and target databases: the record's, else the script's defaults.
         def copy_databases(text, held)
-          databases = text.match(/^SRC_DB=\$\{SRC_DB:-([^}]*)\}; DST_DB=\$\{DST_DB:-([^}]*)\}/)
+          databases = text.match(COPY_DATABASES)
           [database(held[:source_db]) || databases&.[](1), database(held[:target_db]) || databases&.[](2)]
         end
 
@@ -133,7 +142,7 @@ module Hecks
 
         # The taskdef and tag a service roll's last line names.
         def rolled(text)
-          match = text.match(/^==> rolled taskdef=(\S*) tag=(\S+)$/)
+          match = text.match(ROLLED_LINE)
           { taskdef: wrapped(match&.[](1)), tag: wrapped(match&.[](2)) }
         end
       end

data/lib/hecks/hecks/adapters/deploy_toolchain/scripts.rb

@@ -16,6 +16,9 @@ module Hecks
           def initialize(name, label, statuses, args = [], answering = []) = super
         end
 
+        # A path inside installed or vendored code, or git's own directory.
+        VENDORED_PATH = %r{/(node_modules|vendor|\.git)/}
+
         private
 
         # Runs one generated script, found for the record's project, from its own directory. Answers
@@ -26,7 +29,7 @@ module Hecks
           report = printed(result)
           return { report: { value: report } } if result.ok?
 
-          answer_or_refuse(script, result.status.exitstatus, report)
+          answer_or_refuse(script, result.exit_code, report)
         end
 
         # What the script printed to either stream, trimmed.
@@ -47,7 +50,7 @@ module Hecks
           beside = File.join(root, name)
           return beside if File.file?(beside)
 
-          found = Dir.glob(File.join(root, "**", name)).grep_v(%r{/(node_modules|vendor|\.git)/})
+          found = Dir.glob(File.join(root, "**", name)).grep_v(VENDORED_PATH)
           return found.first if found.one?
 
           raise ConsoleCapture::Failure, ambiguity(name, root, found.sort)
@@ -87,7 +90,7 @@ module Hecks
 
         def message_of(result)
           text = [result.err, result.out].map(&:strip).reject(&:empty?).join("\n")
-          text.empty? ? "the tool ended with status #{result.status.exitstatus}" : text
+          text.empty? ? "the tool ended with status #{result.exit_code}" : text
         end
       end
     end

data/lib/hecks/hecks/adapters/deploy_toolchain.rb

@@ -70,12 +70,12 @@ module Hecks
       # @raise [ConsoleCapture::Failure] when the tree is not a checkout, or the linter found a
       #   violation; the message is its report
       def scan(**held)
-        paths = plain(held[:makefiles]).to_s.split(",").map(&:strip).reject(&:empty?)
+        paths = Text.comma_list(plain(held[:makefiles]))
         { report: { value: child(:lint, paths).dig(:output, :value) } }
       end
 
       # Projects each domain's OIDC client and scope manifest into its `oidc.json`, or into one
-      # `<chapter>.oidc.json` for each chapter of a directory that holds several, through
+      # `<bluebook>.oidc.json` for each bluebook of a directory that holds several, through
       # `hecks deploy oidc_manifest.project_oidc`.
       #
       # @param held [Hash] the `OidcManifest` record: `domains` (comma separated directories; every
@@ -83,7 +83,7 @@ module Hecks
       # @return [Hash{Symbol => Hash}] `output:` one line per manifest written or skipped
       # @raise [ConsoleCapture::Failure] when the tree is not a checkout
       def manifest(**held)
-        domains = plain(held[:domains]).to_s.split(",").map(&:strip).reject(&:empty?)
+        domains = Text.comma_list(plain(held[:domains]))
         child(:manifest, domains)
       end