hecks 5.0.0 → 7.0.0

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Hecks
+  module Adapters
+    module Codebase
+      # Which specs a set of changed files runs, by name alone: a changed spec runs itself, and a
+      # changed source file runs the spec of the same name (`lib/x/thing.rb` runs `thing_spec.rb`).
+      #
+      # A file that maps to no spec is reported, not guessed at, so a change to a file no spec
+      # names runs nothing rather than the whole suite.
+      module ChangedSpecs
+        module_function
+
+        # @param changed [Array<String>] the changed files, relative to the folder
+        # @param specs [Array<String>] every spec file of the folder, relative to the folder
+        # @return [Array<String>] the specs to run, sorted and without duplicates
+        def call(changed, specs)
+          by_name = specs.group_by { |spec| File.basename(spec) }
+          changed.flat_map do |file|
+            next [file] if specs.include?(file)
+
+            by_name.fetch("#{File.basename(file, ".rb")}_spec.rb", [])
+          end.uniq.sort
+        end
+
+        # @param changed [Array<String>] the changed files
+        # @param specs [Array<String>] every spec file of the folder
+        # @return [Array<String>] the changed Ruby files that map to no spec, for the report
+        def unmapped(changed, specs)
+          mapped = call(changed, specs)
+          changed.select { |file| file.end_with?(".rb") && !mapped.include?(file) && call([file], specs).empty? }
+        end
+
+        # The files that differ from the ref, tracked and untracked, relative to the folder.
+        #
+        # @param tree [Tree] the folder under git
+        # @param base [String] the ref to compare against
+        # @return [Array<String>] the changed files
+        # @raise [ConsoleCapture::Failure] when git refuses, with what it said
+        def changed_files(tree, base)
+          diff, status = Open3.capture2e("git", "-C", tree.root, "diff", "--name-only", base, "--")
+          raise ConsoleCapture::Failure, diff.strip unless status.success?
+
+          untracked, = Open3.capture2("git", "-C", tree.root, "ls-files", "--others", "--exclude-standard")
+          (diff.lines + untracked.lines).map(&:strip).reject(&:empty?).uniq
+        end
+      end
+    end
+  end
+end

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

@@ -16,11 +16,12 @@ module Hecks
       # when the request is confirmed.
       module Codemods
         # Every operation this family carries out.
-        OPERATIONS = %w[hoist_local_givens drop_implicit_append_fields].freeze
+        OPERATIONS = %w[hoist_local_givens drop_implicit_append_fields move_former_name].freeze
 
         # The script each operation runs.
         SCRIPTS = { "hoist_local_givens"          => "codemod_hoist_local_givens",
-                    "drop_implicit_append_fields" => "codemod_implicit_append_fields" }.freeze
+                    "drop_implicit_append_fields" => "codemod_implicit_append_fields",
+                    "move_former_name"            => "codemod_move_former_name" }.freeze
 
         module_function
 

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

@@ -25,7 +25,8 @@ module Hecks
         # Opens the editor.
         #
         # @param operation [String] `compose`
-        # @param held [Hash] the `CorpusRun` record's fields: `port`, `domains` (the directory)
+        # @param held [Hash] the `CorpusRun` record's fields: `port`, `domains` (the directory) and
+        #   `agent` (`claude`, or `fake` for a scripted assistant)
         # @param tree [Tree] the working tree, already known to be a hecks checkout
         # @param shell [#capture, nil] unused
         # @return [String] a note that the server stopped
@@ -37,7 +38,7 @@ module Hecks
           port = fields[:port] || DEFAULT_PORT
           warn "composer over #{workspace} on http://#{HOST}:#{port}/composer - no authentication, " \
                "no CSRF protection, no caller identity; do not expose beyond localhost"
-          app = Composer::Web.app(workspace: workspace)
+          app = Composer::Web.app(workspace: workspace, agents: Composer::Workbench.agents_named(fields[:agent]))
           (CorpusTasks.web_server || method(:serve)).call(app: app, port: port, host: HOST)
           "composed on port #{port}, now stopped"
         end

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

@@ -2,8 +2,11 @@
 
 require_relative "tree"
 require_relative "ruby_child"
+require_relative "launcher_text"
 require "hecks/engine_agreement"
 require "hecks/doc/reference"
+require "hecks/shape_ledger"
+require "hecks/tools/gate_memo/standalone"
 
 module Hecks
   module Adapters
@@ -17,7 +20,8 @@ module Hecks
       # script only reports, and with it the script rewrites the committed matrix and its fixtures.
       module Conformance
         # Every operation this family carries out.
-        OPERATIONS = %w[check_engine_agreement measure_doc_coverage argument_gate_matrix].freeze
+        OPERATIONS = %w[check_engine_agreement measure_doc_coverage check_shape_ledger check_command_names
+                        check_workflow_pagination argument_gate_matrix].freeze
 
         module_function
 
@@ -32,6 +36,9 @@ module Hecks
           case operation
           when "check_engine_agreement" then engine_agreement(tree)
           when "measure_doc_coverage" then doc_coverage(tree)
+          when "check_shape_ledger" then shape_ledger(held, tree)
+          when "check_command_names" then LauncherText.command_names(tree)
+          when "check_workflow_pagination" then LauncherText.workflow_pagination(tree)
           else gate_matrix(held, tree)
           end
         end
@@ -56,6 +63,28 @@ module Hecks
           report
         end
 
+        # @param held [Hash] the record's fields; `confirm` rewrites the ledger, and `additive`
+        #   with it writes the empty edge for a shape that moved with none
+        # @param tree [Tree] the checkout
+        # @return [String] the clean verdict, or what was written
+        # @raise [ConsoleCapture::Failure] with each bluebook whose shape moved without an edge
+        def shape_ledger(held, tree)
+          return judge_shape_ledger(held, tree) if on?(held[:confirm]) || on?(held[:additive])
+
+          Tools::GateMemo::Standalone.guard(tree.root, "shape_ledger") { judge_shape_ledger(held, tree) }
+        end
+
+        # @return [String] the ledger's verdict, or what it wrote
+        # @raise [ConsoleCapture::Failure] with each bluebook whose shape moved without an edge
+        def judge_shape_ledger(held, tree)
+          ShapeLedger.check(tree.path("lib/hecks/hecks"), confirm: on?(held[:confirm]), additive: on?(held[:additive]))
+        rescue ShapeLedger::Failure => e
+          raise ConsoleCapture::Failure, e.message
+        end
+
+        # @return [Boolean] whether a switch field is true, whether given bare or as `{ value: }`
+        def on?(field) = (field.is_a?(Hash) ? field[:value] : field) == true
+
         # @param held [Hash] the record's fields; `confirm` makes the script write
         # @param tree [Tree] the checkout
         # @return [String] what the script printed: the rows kept and dropped, and what it wrote

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Adapters
+    class SourceTree
+      # The `SourceTree` queries that read the corpus of domains: which have Rust, the order regeneration
+      # walks them in, and what the IR and its propagation touchpoints say. Each is answered through
+      # `corpus`, which the includer provides.
+      module CorpusQueries
+        # @return [Hash] `text:` the feature and directory of every domain with a Rust feature
+        # @raise [Codebase::Tree::NeedsCheckout] when the tree is not a hecks checkout
+        def rust_domains(**)
+          { text: corpus("rust_domains", {}) }
+        end
+
+        # @return [Hash] `text:` the directories regeneration walks, in the order it walks them
+        # @raise [Codebase::Tree::NeedsCheckout] when the tree is not a hecks checkout
+        def regen_order(**)
+          { text: corpus("regen_order", {}) }
+        end
+
+        # @return [Hash] `text:` whether each generated Rust module is covered
+        # @raise [Codebase::Tree::NeedsCheckout] when the tree is not a hecks checkout
+        # @raise [ConsoleCapture::Failure] when a module is not covered
+        def corpus_rust_coverage(**)
+          { text: corpus("corpus_rust_coverage", {}) }
+        end
+
+        # @param args [Hash] the query's arguments: `names`
+        # @return [Hash] `text:` each IR construct's diff from its meta-domain
+        # @raise [Codebase::Tree::NeedsCheckout] when the tree is not a hecks checkout
+        def ir_constructs(**args)
+          { text: corpus("ir_constructs", args) }
+        end
+
+        # @param args [Hash] the query's arguments: `domains`, `meta`
+        # @return [Hash] `text:` the rules declared more than once
+        # @raise [Codebase::Tree::NeedsCheckout] when the tree is not a hecks checkout
+        def ir_duplicates(**args)
+          { text: corpus("ir_duplicates", args) }
+        end
+
+        # @param args [Hash] the query's arguments: `name`, `field`
+        # @return [Hash] `text:` which propagation touchpoints already show the field
+        # @raise [Codebase::Tree::NeedsCheckout] when the tree is not a hecks checkout
+        # @raise [ConsoleCapture::Failure] when the construct is not one
+        def ir_impact(**args)
+          { text: corpus("ir_impact", args) }
+        end
+      end
+    end
+  end
+end

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

@@ -209,7 +209,7 @@ module Hecks
 
         # @param list [String, nil] a comma-separated list
         # @return [Array<String>] its items
-        def words(list) = list.to_s.split(",").map(&:strip).reject(&:empty?)
+        def words(list) = Text.comma_list(list)
       end
     end
   end

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative "tree"
+require_relative "search"
+require "hecks/composer/outline"
+
+module Hecks
+  module Adapters
+    module Codebase
+      # What `Reading` knows about where things are declared: the `kind "Name"` lines of every
+      # declaring file with the extent of each block, kept per checkout and rebuilt only when a
+      # declaring file's size or modification time moves.
+      #
+      # The scan reads the text alone, as the Composer outline does, so it works on a file that
+      # does not parse. It also reads the definitions of a Ruby file and the headings of a
+      # Markdown file, for `Outline`, which are scanned on demand and never kept.
+      module Declarations
+        # What a bluebook-family file declares: the constructs the Composer outline jumps to, and
+        # the ones it leaves out.
+        KINDS = (Composer::Outline::KINDS + %w[read_model lifecycle port adapter]).freeze
+
+        # The files whose declarations are indexed.
+        DECLARING = "**/*.{bluebook,hecksagon,behaviors,world,adapter,port}"
+
+        # A declaration line: the keyword, then its name between quotes.
+        DECLARATION = /\A(?<indent>\s*)(?<kind>#{KINDS.join("|")})\s+"(?<name>[^"]+)"/
+
+        # A Ruby definition line.
+        DEFINITION = %r{\A(?<indent>\s*)(?<kind>class|module|def)\s+(?<name>[\w:.?!=<>\[\]+*/-]+)}
+
+        # A heading of a Markdown file.
+        HEADING = /\A(?<hashes>\#{1,6})\s+(?<name>.+)/
+
+        # A line that opens a block closed by a later `end`.
+        OPENING = /\bdo\b(\s*\|[^|]*\|)?\s*\z|\A\s*(class|module|def)\s(?!.*\bend\b\s*\z)/
+
+        # A Ruby method written on one line: `def name(args) = body`.
+        ENDLESS = /\A\s*def\s+[^\s(]+(\(.*\))?\s=\s/
+
+        # One declaration of the index.
+        Entry = Struct.new(:file, :from, :to, :kind, :name, keyword_init: true) do
+          def range = "#{file}:#{from}-#{to}"
+          def label = KINDS.include?(kind) ? "#{kind} #{name.inspect}" : "#{kind} #{name}"
+        end
+
+        @kept = {}
+
+        class << self
+          # @return [Hash{String => Hash}] per checkout root, the scan and the stamp it was built
+          #   from
+          attr_reader :kept
+        end
+
+        module_function
+
+        # @param tree [Tree] the working tree, already known to be a hecks checkout
+        # @param paths [String, nil] files or directories, comma separated; all when nil
+        # @return [Array<Entry>] every declaration of those paths, from the kept scan
+        def entries(tree, paths = nil)
+          all = scanned(tree)
+          paths ? within(all, paths) : all
+        end
+
+        # @return [Array<Entry>] every declaration of the checkout, rescanned only when a declaring
+        #   file's size or modification time differs from the kept scan's
+        def scanned(tree)
+          files = declaring_files(tree)
+          stamp = stamped(tree, files)
+          held = Declarations.kept[tree.root]
+          return held[:all] if held && held[:stamp] == stamp
+
+          Declarations.kept[tree.root] = { stamp: stamp, all: build(tree, files) }
+          Declarations.kept[tree.root][:all]
+        end
+
+        # @return [Array<String>] the declaring files below the root, sorted
+        def declaring_files(tree)
+          Dir.glob(DECLARING, base: tree.root).select { |file| Search.walkable?(file) }.sort
+        end
+
+        # @return [Array<Array>] each file with the modification time and size it has now
+        def stamped(tree, files) = files.map { |file| [file, *stat(tree, file)] }
+
+        # @param file [String] the file's path, which says what kind of text it holds
+        # @param lines [Array<String>] the file's lines
+        # @return [Array<Entry>] its declarations, definitions or headings
+        def outline(file, lines)
+          return headings(file, lines) if file.end_with?(".md")
+
+          scan(file, lines, file.end_with?(".rb") ? DEFINITION : DECLARATION)
+        end
+
+        # @return [Array<Entry>] the matches of `pattern` in one file's lines
+        def scan(file, lines, pattern = DECLARATION)
+          lines.each_with_index.filter_map do |text, index|
+            found = text.match(pattern) or next
+            Entry.new(file: file, from: index + 1, to: block_end(lines, index, found[:indent].length),
+                      kind: found[:kind], name: found[:name])
+          end
+        end
+
+        # @return [Integer] the line the block opened at `index` closes on: the next `end` at its
+        #   own indent, or the line itself when it opens no block
+        def block_end(lines, index, indent)
+          return index + 1 if !lines[index].match?(OPENING) || lines[index].match?(ENDLESS)
+
+          close = lines[(index + 1)..].to_a.index { |text| text.match?(/\A {#{indent}}end\b/) }
+          close ? index + close + 2 : lines.length
+        end
+
+        # @return [Array<Entry>] the headings of a Markdown file, each ending where the next of its
+        #   level or higher begins
+        def headings(file, lines)
+          found = lines.each_with_index.filter_map { |text, at| heading(text, at) }
+          found.each_with_index.map do |(at, level, name), position|
+            stop = found[(position + 1)..].find { |_, other, _| other <= level }
+            Entry.new(file: file, from: at + 1, to: stop ? stop[0] : lines.length, kind: "#" * level, name: name)
+          end
+        end
+
+        # @return [Array, nil] the line index, level and title when `text` is a heading
+        def heading(text, index)
+          match = text.match(HEADING) or return
+          [index, match[:hashes].length, match[:name]]
+        end
+
+        # @return [Array<Entry>] the entries whose file is one of `paths`, or below one
+        def within(all, paths)
+          prefixes = paths.split(",").map { |path| path.delete_prefix("./").chomp("/") }
+          all.select { |entry| prefixes.any? { |prefix| entry.file == prefix || entry.file.start_with?("#{prefix}/") } }
+        end
+
+        def build(tree, files)
+          files.flat_map { |file| scan(file, File.readlines(tree.path(file), chomp: true).map(&:scrub)) }
+        end
+
+        def stat(tree, file)
+          info = File.stat(tree.path(file))
+          [info.mtime.to_i, info.size]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "hecks/corpus"
+require_relative "tree"
+require_relative "../console_capture"
+
+module Hecks
+  module Adapters
+    module Codebase
+      # What Codebase's `GeneratedKey` query asks of the working tree: the hash of everything
+      # regenerating some domains' Rust reads, which a cache of the generated tree is keyed on.
+      #
+      # The hash is `Hecks::Corpus::GeneratedKey`'s; this answers it in this process and turns a
+      # refusal of a domain name into the failure a query raises.
+      module GeneratedKeys
+        module_function
+
+        # @param args [Hash] the query's plain arguments: `domains` (feature names), `files`
+        # @param tree [Tree] the working tree, already known to be a hecks checkout
+        # @return [String] the hash, with each file hashed above it when `files` is true
+        # @raise [ConsoleCapture::Failure] when a name is not a domain, listing the valid ones
+        def report(args, tree)
+          names = args[:domains]&.split(",")
+          Corpus::GeneratedKey.report(names, files: args[:files] == true, root: tree.root)
+        rescue Corpus::UnknownDomain => e
+          raise ConsoleCapture::Failure, e.message
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "tree"
+require_relative "spec_files"
+require_relative "changed_specs"
+require_relative "../git_rehearsal/spec_map"
+require_relative "../git_rehearsal/impacted"
+require_relative "../git_rehearsal/impacted/skips"
+
+module Hecks
+  module Adapters
+    module Codebase
+      # The specs a branch's changes touch, found by the push rehearsal's own map and run in one
+      # launcher boot.
+      #
+      # The changed files are those between the merge base with the base ref and the working tree
+      # (uncommitted and untracked files included). `GitRehearsal::SpecMap` names the specs, and
+      # `GitRehearsal::Impacted::Skips` leaves out those that need `cargo`, `gh` or the network, and
+      # the `:io` ones when no scratch Postgres answers, exactly as the rehearsal's stage does.
+      class ImpactedSpecs
+        # The most spec files a run takes, as the rehearsal's stage does.
+        DEFAULT_CAP = GitRehearsal::Impacted::DEFAULT_LIMIT
+
+        DIGITS = /\d+/
+        TOTALS = /\d+ examples?, \d+ failures?\z/
+
+        # @param tree [Tree] the checkout
+        # @param scratch [#call, nil] says whether a scratch Postgres answers; `pg_isready` when nil
+        # @param files [SpecFiles, nil] runs the mapped specs
+        def initialize(tree, scratch: nil, files: nil)
+          @tree = tree
+          @scratch = scratch || -> { scratch_answers? }
+          @files = files || SpecFiles.new(tree)
+        end
+
+        # @param base [String] the ref the branch is compared with
+        # @param cap [Integer] the most spec files to run
+        # @param dry [Boolean] list the mapped specs and run none
+        # @param run_options [Hash] `isolation`, `example`, `env` and `tags`, as `SpecFiles#run`
+        #   takes them
+        # @return [String] the changed files, the mapped, skipped and run specs and how each ended
+        # @raise [ConsoleCapture::Failure] when git refuses or a spec fails
+        def call(base:, cap: DEFAULT_CAP, dry: false, **run_options)
+          changed = changed_files(base)
+          skips = GitRehearsal::Impacted::Skips.new(@tree.root, scratch: @scratch)
+          mapping = GitRehearsal::SpecMap.new(@tree.root).map(changed, limit: cap, skip: skips)
+          head = describe(base, changed, mapping)
+          return "#{head}\nnothing impacted; nothing run" if mapping.specs.empty?
+          return "#{head}\ndry run: no spec run" if dry
+
+          [head, run(mapping.specs, skips, run_options)].join("\n\n")
+        end
+
+        private
+
+        def changed_files(base)
+          merge, status = Open3.capture2e("git", "-C", @tree.root, "merge-base", "HEAD", base)
+          ChangedSpecs.changed_files(@tree, status.success? ? merge.strip : base)
+        end
+
+        def describe(base, changed, mapping)
+          lines = ["changed since #{base}: #{changed.size} file(s)", *changed.map { |file| "  #{file}" },
+                   "impacted specs: #{mapping.specs.size}", *mapping.specs.map { |spec| "  #{spec}" }]
+          lines << mapping.cap_note unless mapping.cap_note.empty?
+          (lines + mapping.skipped.map { |spec, why| "skipped: #{spec} (#{why})" }).join("\n")
+        end
+
+        # The `:io` specs run as CI does (`CI=true`), the rest as they are; with both, the report
+        # ends with the counts of both runs together.
+        def run(specs, skips, options)
+          io, plain = specs.partition { |spec| skips.io?(spec) }
+          env = options.fetch(:env, {})
+          groups = [[plain, env], [io, env.merge("CI" => "true")]].reject { |group, _env| group.empty? }
+          reports = groups.map { |group, group_env| batch(group, options.merge(env: group_env)) }
+          answer(reports)
+        end
+
+        def answer(reports)
+          text = (reports.map(&:text) + [(combined(reports) if reports.size > 1)]).compact.join("\n\n")
+          raise ConsoleCapture::Failure, text if reports.any?(&:failed)
+
+          text
+        end
+
+        # What a batch said, and whether a file of it failed.
+        Batch = Struct.new(:text, :failed)
+
+        def batch(group, options)
+          Batch.new(@files.run(files: group, **options), false)
+        rescue ConsoleCapture::Failure => e
+          Batch.new(e.message, true)
+        end
+
+        def combined(reports)
+          counts = reports.map { |report| final_counts(report.text) }
+          "#{counts.sum(&:first)} examples, #{counts.sum(&:last)} failures"
+        end
+
+        def final_counts(text) = text[TOTALS].scan(DIGITS).map(&:to_i)
+
+        def scratch_answers?
+          Open3.capture2e("pg_isready").last.success?
+        rescue SystemCallError
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -61,10 +61,10 @@ module Hecks
         # @return [String] its output
         # @raise [ConsoleCapture::Failure] when it ended in a status that is not a report
         def report(operation, result)
-          return result.out if REPORTING.fetch(operation, [0]).include?(result.status.exitstatus)
+          code = result.exit_code
+          return result.out if REPORTING.fetch(operation, [0]).include?(code)
 
-          raise ConsoleCapture::Failure,
-                "#{operation} ended with status #{result.status.exitstatus}: #{result.err}#{result.out}".strip
+          raise ConsoleCapture::Failure, "#{operation} ended with status #{code}: #{result.err}#{result.out}".strip
         end
 
         # @param text [String] a report
@@ -81,7 +81,8 @@ module Hecks
         # @return [Array<String>] the files, relative to the root and sorted
         def ruby_files(tree, paths)
           excluded = exclusions(tree)
-          paths.split(",").flat_map { |path| listing(tree, path) }.uniq.sort.reject do |file|
+          listed = paths.split(",").flat_map { |path| listing(tree, path) }.uniq
+          listed.sort.reject do |file|
             excluded.any? { |glob| File.fnmatch?(glob, file, File::FNM_PATHNAME | File::FNM_EXTGLOB) }
           end
         end

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

@@ -25,6 +25,7 @@ module Hecks
           "project_rust_vocabulary"   => :rust_vocabulary,
           "project_reserved_names"    => :reserved_names,
           "project_parser_table"      => :parser_table,
+          "project_phrase_table"      => :phrase_table,
           "project_bootstrap_table"   => :bootstrap_table,
           "project_field_hints"       => :field_hints,
           "project_expression_tables" => :expression_tables,
@@ -48,14 +49,14 @@ module Hecks
 
         # What the tool says after a proposal or a rename, which still needs hand work.
         FOLLOW_UP = {
-          "propose"          => "Proposed. It reaches no projection until admitted. Before `hecks admit`:\n  " \
+          "propose"          => "Proposed. It reaches no projection until admitted. Before `hecks language_run.admit!`:\n  " \
                                 "1. teach the %<context>s builder the word (and its spec/dsl_spec example)",
           "rename"           => "Renamed. The old spelling keeps parsing — that is the point. Before this holds:\n  " \
                                 "1. alias the new word to the old in the %<context>s builder " \
                                 "(alias_method :%<new_name>s, :%<word>s)\n  " \
                                 "2. add the identical-IR example to spec/dsl_spec.rb",
           "propose_argument" => "Proposed. It reaches no projection until admitted. Before " \
-                                "`hecks admit_argument`:\n  " \
+                                "`hecks language_run.admit_argument!`:\n  " \
                                 "1. teach the %<context>s builder's %<word>s method the argument"
         }.freeze
 

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "hecks/command_names"
+require "hecks/workflow_pagination"
+
+module Hecks
+  module Adapters
+    module Codebase
+      # What Codebase's `ConformanceRun` asks of the text that drives the launcher and GitHub: the
+      # workflows, hooks, gate rows, specs and guides.
+      #
+      # Both checks read files in this process and write nothing. They look for the two ways such
+      # text goes quietly wrong: a command name the launcher does not accept, and a count of
+      # GitHub list items taken from the first page only.
+      module LauncherText
+        module_function
+
+        # @param tree [Tree] the working tree, already known to be a hecks checkout
+        # @return [String] the clean verdict
+        # @raise [ConsoleCapture::Failure] with each invocation the launcher would refuse
+        def command_names(tree)
+          runtime = Hecks.describe(tree.path("lib/hecks/hecks"))
+          CommandNames.check(root: tree.root, runtime: runtime)
+        rescue CommandNames::Failure => e
+          raise ConsoleCapture::Failure, e.message
+        end
+
+        # @param tree [Tree] the working tree
+        # @return [String] the clean verdict
+        # @raise [ConsoleCapture::Failure] with each list call that counts one page
+        def workflow_pagination(tree)
+          WorkflowPagination.check(root: tree.root)
+        rescue WorkflowPagination::Failure => e
+          raise ConsoleCapture::Failure, e.message
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Hecks
+  module Adapters
+    module Codebase
+      # The minitest files of a spec directory. RSpec does not run them, so each one runs in its own Ruby
+      # process, and its run summary is reported beside the RSpec output.
+      module MinitestRuns
+        # The summary line minitest prints, such as "3 runs, 5 assertions".
+        SUMMARY = /\d+ runs?, /
+
+        module_function
+
+        # @param tree [Tree] the folder whose specs are listed
+        # @return [Array<String>] their paths, relative to the folder, sorted
+        def files(tree)
+          Dir.glob("#{TestSuite::SPEC_DIRECTORY}/**/*_test.rb", base: tree.root).sort
+        end
+
+        # Runs each file in its own Ruby process, from the folder, outside this process's bundle so the
+        # folder's own gems are the ones it loads.
+        #
+        # @param tree [Tree] the folder the files run in
+        # @param files [Array<String>] the minitest files
+        # @return [Array<String>] one line per file: its path and its run summary
+        # @raise [ConsoleCapture::Failure] with the output of the first file that fails
+        def reports(tree, files)
+          files.map do |file|
+            out, status = unbundled { Open3.capture2e(RbConfig.ruby, file, chdir: tree.root) }
+            raise ConsoleCapture::Failure, "#{file} failed\n#{out.strip}" unless status.success?
+
+            "#{file}: #{summary(out)}"
+          end
+        end
+
+        # @param out [String] what a minitest file printed
+        # @return [String] its last run summary line, or nothing when it printed none
+        def summary(out)
+          matches = out.lines.grep(SUMMARY)
+          matches.last.to_s.strip
+        end
+
+        # Runs the block without the bundle this process was started under, when Bundler is loaded.
+        def unbundled(&)
+          defined?(Bundler) ? Bundler.with_unbundled_env(&) : yield
+        end
+      end
+    end
+  end
+end

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

@@ -47,7 +47,7 @@ module Hecks
           return false if result.stderr.include?("E404")
 
           raise Release::Runner::Refusal,
-                "could not check npm for #{PACKAGE}@#{version} (#{result.stderr.strip.lines.first}); " \
+                "could not check npm for #{PACKAGE}@#{version} (#{first_error_line(result)}); " \
                 "check the network and re-run"
         end
 
@@ -85,6 +85,12 @@ module Hecks
 
         private
 
+        # The first line of what npm wrote to stderr, nil when it wrote nothing.
+        def first_error_line(result)
+          error = result.stderr.strip
+          error.lines.first
+        end
+
         def package_dir = File.join(@root, PACKAGE_DIR)
 
         def with_userconfig