ibex 0.1.0 → 0.2.0

data/lib/ibex/cli/formatting.rb

@@ -0,0 +1,386 @@
+# frozen_string_literal: true
+
+require "tempfile"
+require "optparse"
+require_relative "../frontend"
+
+module Ibex
+  # CLI coordination for deterministic, semantics-preserving grammar formatting.
+  # rubocop:disable Metrics/ModuleLength -- transaction lifecycle stays cohesive and auditable.
+  module CLIFormatting
+    # @rbs!
+    #   type formatting_settings = {
+    #     paths: Array[String],
+    #     mode: Symbol,
+    #     check: bool,
+    #     write: bool,
+    #     ?stdin_filename: String,
+    #     ?help: bool
+    #   }
+    #   type formatting_result = {
+    #     path: String,
+    #     label: String,
+    #     source: String,
+    #     formatted: String
+    #   }
+    #   type formatting_target = {
+    #     path: String,
+    #     label: String,
+    #     target: String,
+    #     formatted: String,
+    #     mode: Integer,
+    #     directory: String,
+    #     basename: String,
+    #     changed: bool,
+    #     installed: bool,
+    #     ?stage: String,
+    #     ?backup: String
+    #   }
+    #   type formatting_cleanup_result = {
+    #     errors: Array[String],
+    #     remaining: Array[String]
+    #   }
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_format_command(arguments)
+      settings = formatting_options(arguments)
+      if settings[:help]
+        @stdout.puts(formatting_option_parser(settings))
+        return 0
+      end
+
+      validate_formatting_settings!(settings)
+      results, failed = prepare_formatting_results(settings)
+      if settings.fetch(:check)
+        check_status = check_formatting_results(results)
+        return 1 if failed
+
+        return check_status
+      end
+      return 1 if failed
+      return write_formatting_results(results) if settings.fetch(:write)
+
+      @stdout.write(results.fetch(0).fetch(:formatted))
+      0
+    end
+
+    # @rbs (Array[String] arguments) -> formatting_settings
+    def formatting_options(arguments)
+      settings = { paths: [], mode: :default, check: false, write: false } #: formatting_settings
+      settings[:paths] = formatting_option_parser(settings).parse(arguments)
+      settings
+    end
+
+    # @rbs (formatting_settings settings) -> OptionParser
+    def formatting_option_parser(settings)
+      OptionParser.new do |options|
+        options.banner = "Usage: ibex fmt [--check | --write] [options] grammar.y [...]"
+        options.on("--check", "report files that need formatting") { settings[:check] = true }
+        options.on("--write", "atomically format files in place") { settings[:write] = true }
+        options.on("--mode=MODE", %w[default extended], "grammar mode") { |value| settings[:mode] = value.to_sym }
+        options.on("--stdin-filename=FILE", "diagnostic filename for standard input") do |value|
+          settings[:stdin_filename] = value
+        end
+        options.on("--help", "show help") { settings[:help] = true }
+      end
+    end
+
+    # @rbs (formatting_settings settings) -> void
+    def validate_formatting_settings!(settings)
+      paths = settings.fetch(:paths)
+      raise Ibex::Error, "(cli):1:1: fmt requires at least one grammar file" if paths.empty?
+
+      validate_formatting_operation!(settings, paths)
+      validate_formatting_stdin!(settings, paths)
+    end
+
+    # @rbs (formatting_settings settings, Array[String] paths) -> void
+    def validate_formatting_operation!(settings, paths)
+      if settings.fetch(:check) && settings.fetch(:write)
+        raise Ibex::Error, "(cli):1:1: fmt --check and --write cannot be combined"
+      end
+      return if settings.fetch(:check) || settings.fetch(:write) || paths.length == 1
+
+      raise Ibex::Error, "(cli):1:1: fmt writes to stdout only for exactly one input"
+    end
+
+    # @rbs (formatting_settings settings, Array[String] paths) -> void
+    def validate_formatting_stdin!(settings, paths)
+      raise Ibex::Error, "(cli):1:1: fmt standard input may be specified only once" if paths.count("-") > 1
+
+      if paths.include?("-") && (settings.fetch(:check) || settings.fetch(:write))
+        raise Ibex::Error, "(cli):1:1: fmt --check and --write require file inputs"
+      end
+      if settings[:stdin_filename] && formatting_control_bytes?(settings.fetch(:stdin_filename))
+        raise Ibex::Error, "(cli):1:1: --stdin-filename must not contain control characters"
+      end
+      return unless settings[:stdin_filename] && paths != ["-"]
+
+      raise Ibex::Error, "(cli):1:1: --stdin-filename requires fmt -"
+    end
+
+    # @rbs (formatting_settings settings) -> [Array[formatting_result], bool]
+    def prepare_formatting_results(settings)
+      failed = false
+      results = [] #: Array[formatting_result]
+      settings.fetch(:paths).each do |path|
+        source = path == "-" ? @stdin.read : File.binread(path)
+        label = path == "-" ? settings[:stdin_filename] || "(stdin)" : formatting_label(path)
+        formatted = Frontend::Formatter.format(source, file: label, mode: settings.fetch(:mode))
+        results << { path: path, label: label, source: source, formatted: formatted }
+      rescue Ibex::Error, SystemCallError => e
+        @stderr.puts(formatting_label(e.message))
+        failed = true
+      end
+      [results, failed]
+    end
+
+    # @rbs (Array[formatting_result] results) -> Integer
+    def check_formatting_results(results)
+      changed = results.reject { |result| result.fetch(:source) == result.fetch(:formatted) }
+      changed.each { |result| @stderr.puts("#{result.fetch(:label)}: needs formatting") }
+      changed.empty? ? 0 : 1
+    end
+
+    # @rbs (Array[formatting_result] results) -> Integer
+    def write_formatting_results(results)
+      targets = formatting_targets(results)
+      validate_unique_formatting_targets!(targets)
+      targets = targets.select { |target| target.fetch(:changed) }
+      return 0 if targets.empty?
+
+      transactionally_write_formatted(targets)
+      0
+    end
+
+    # @rbs (Array[formatting_result] results) -> Array[formatting_target]
+    def formatting_targets(results)
+      results.map do |result|
+        target = File.realpath(result.fetch(:path))
+        {
+          path: result.fetch(:path), label: result.fetch(:label), target: target,
+          formatted: result.fetch(:formatted), mode: File.stat(target).mode & 0o7777,
+          directory: File.dirname(target), basename: File.basename(target),
+          changed: result.fetch(:source) != result.fetch(:formatted), installed: false
+        }
+      end
+    rescue SystemCallError => e
+      raise Ibex::Error, formatting_label(e.message)
+    end
+
+    # @rbs (Array[formatting_target] targets) -> void
+    def validate_unique_formatting_targets!(targets)
+      collision = duplicate_formatting_target_pair(targets)
+      return unless collision
+
+      labels = collision.map { |target| target.fetch(:label) }
+      raise Ibex::Error, "(cli):1:1: fmt inputs resolve to the same target: #{labels.join(', ')}"
+    end
+
+    # @rbs (Array[formatting_target] targets) -> [formatting_target, formatting_target]?
+    def duplicate_formatting_target_pair(targets)
+      targets.each_with_index do |left, index|
+        targets.drop(index + 1).each do |right|
+          same_path = left.fetch(:target) == right.fetch(:target)
+          return [left, right] if same_path || File.identical?(left.fetch(:target), right.fetch(:target))
+        end
+      end
+      nil
+    end
+
+    # @rbs (Array[formatting_target] targets) -> void
+    def transactionally_write_formatted(targets)
+      begin
+        stage_formatting_targets(targets)
+        backup_formatting_targets(targets)
+        sync_formatting_directories!(targets)
+        install_formatting_targets(targets)
+        sync_formatting_directories!(targets)
+      rescue StandardError => e
+        rollback_errors = rollback_formatting_targets(targets)
+        cleanup = cleanup_formatting_artifacts(targets, preserve_installed_backups: true)
+        sync_errors = sync_formatting_directories_best_effort(targets)
+        raise formatting_transaction_error(e, rollback_errors, cleanup, sync_errors)
+      end
+
+      cleanup = cleanup_formatting_artifacts(targets, preserve_installed_backups: false)
+      sync_errors = sync_formatting_directories_best_effort(targets)
+      report_formatting_cleanup_warning(cleanup, sync_errors)
+    end
+
+    # @rbs (Array[formatting_target] targets) -> void
+    def stage_formatting_targets(targets)
+      targets.each do |target|
+        temporary = Tempfile.create(
+          [".ibex-fmt-", ".stage"], target.fetch(:directory)
+        )
+        target[:stage] = temporary.path.dup
+        temporary.binmode
+        temporary.write(target.fetch(:formatted))
+        temporary.flush
+        temporary.fsync
+        temporary.chmod(target.fetch(:mode))
+        temporary.fsync
+        temporary.close
+      rescue StandardError
+        begin
+          temporary&.close
+        rescue StandardError
+          nil
+        end
+        raise
+      end
+    end
+
+    # @rbs (Array[formatting_target] targets) -> void
+    def backup_formatting_targets(targets)
+      targets.each do |target|
+        backup = "#{target.fetch(:stage)}.backup"
+        target[:backup] = backup
+        File.link(target.fetch(:target), backup)
+      end
+    end
+
+    # @rbs (Array[formatting_target] targets) -> void
+    def install_formatting_targets(targets)
+      targets.each do |target|
+        File.rename(target.fetch(:stage), target.fetch(:target))
+        target[:installed] = true
+      end
+    end
+
+    # @rbs (Array[formatting_target] targets) -> Array[String]
+    def rollback_formatting_targets(targets)
+      errors = [] #: Array[String]
+      targets.reverse_each do |target|
+        next unless target.fetch(:installed)
+
+        File.rename(target.fetch(:backup), target.fetch(:target))
+        target[:installed] = false
+      rescue StandardError => e
+        errors << "#{target.fetch(:label)}: #{formatting_label(e.message)}"
+      end
+      errors
+    end
+
+    # @rbs (Array[formatting_target] targets, preserve_installed_backups: bool) ->
+    #   formatting_cleanup_result
+    def cleanup_formatting_artifacts(targets, preserve_installed_backups:)
+      errors = [] #: Array[String]
+      remaining = [] #: Array[String]
+      targets.each do |target|
+        artifacts = [target[:stage]] #: Array[String?]
+        backup = target[:backup]
+        if preserve_installed_backups && target.fetch(:installed) && backup
+          remaining << backup
+        else
+          artifacts << backup
+        end
+        artifacts.compact.each do |path|
+          error = remove_formatting_artifact(path)
+          next unless error
+
+          errors << error
+          remaining << path
+        end
+      end
+      { errors: errors, remaining: remaining }
+    end
+
+    # @rbs (String path) -> String?
+    def remove_formatting_artifact(path)
+      attempts = 0
+      begin
+        attempts += 1
+        File.unlink(path)
+        nil
+      rescue Errno::ENOENT
+        nil
+      rescue StandardError => e
+        retry if attempts < 2
+
+        "#{formatting_label(path)}: #{formatting_label(e.message)}"
+      end
+    end
+
+    # @rbs (StandardError error, Array[String] rollback_errors,
+    #   formatting_cleanup_result cleanup, Array[String] sync_errors) -> Ibex::Error
+    def formatting_transaction_error(error, rollback_errors, cleanup, sync_errors)
+      details = ["fmt write failed: #{formatting_label(error.message)}"] #: Array[String]
+      details << "rollback failed: #{rollback_errors.join('; ')}" unless rollback_errors.empty?
+      details << "cleanup failed: #{cleanup.fetch(:errors).join('; ')}" unless cleanup.fetch(:errors).empty?
+      unless cleanup.fetch(:remaining).empty?
+        paths = cleanup.fetch(:remaining).map { |path| formatting_label(path) }
+        details << "preserved artifacts: #{paths.join(', ')}"
+      end
+      details << "rollback directory sync failed: #{sync_errors.join('; ')}" unless sync_errors.empty?
+      Ibex::Error.new(details.join("; "))
+    end
+
+    # @rbs (formatting_cleanup_result cleanup, Array[String] sync_errors) -> void
+    def report_formatting_cleanup_warning(cleanup, sync_errors)
+      details = cleanup.fetch(:errors).dup
+      details.concat(sync_errors)
+      unless cleanup.fetch(:remaining).empty?
+        paths = cleanup.fetch(:remaining).map { |path| formatting_label(path) }
+        details << "remaining artifacts: #{paths.join(', ')}"
+      end
+      return if details.empty?
+
+      @stderr.puts("fmt cleanup warning (formatted targets committed): #{details.join('; ')}")
+    end
+
+    # @rbs (Array[formatting_target] targets) -> void
+    def sync_formatting_directories!(targets)
+      errors = sync_formatting_directories(targets)
+      return if errors.empty?
+
+      raise Ibex::Error, "directory sync failed: #{errors.join('; ')}"
+    end
+
+    # @rbs (Array[formatting_target] targets) -> Array[String]
+    def sync_formatting_directories_best_effort(targets)
+      sync_formatting_directories(targets)
+    end
+
+    # @rbs (Array[formatting_target] targets) -> Array[String]
+    def sync_formatting_directories(targets)
+      errors = [] #: Array[String]
+      targets.map { |target| target.fetch(:directory) }.uniq.each do |directory|
+        sync_formatting_directory(directory)
+      rescue SystemCallError, IOError => e
+        errors << "#{formatting_label(directory)}: #{formatting_label(e.message)}"
+      end
+      errors
+    end
+
+    # @rbs (String directory) -> void
+    def sync_formatting_directory(directory)
+      File.open(directory, File::RDONLY, &:fsync)
+    rescue Errno::EINVAL, Errno::ENOTSUP, Errno::EBADF
+      nil
+    end
+
+    # @rbs (String value) -> String
+    def formatting_label(value)
+      escaped = String.new(encoding: Encoding::BINARY)
+      value.b.each_byte do |byte|
+        escaped << (control_byte?(byte) ? format("\\x%02X", byte) : byte)
+      end
+      escaped.force_encoding(value.encoding)
+    end
+
+    # @rbs (String value) -> bool
+    def formatting_control_bytes?(value)
+      value.b.each_byte.any? { |byte| control_byte?(byte) }
+    end
+
+    # @rbs (Integer byte) -> bool
+    def control_byte?(byte)
+      byte < 0x20 || byte == 0x7f
+    end
+  end
+  # rubocop:enable Metrics/ModuleLength
+end

data/lib/ibex/cli/generation_artifacts.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require_relative "../artifact_set"
+require_relative "../generation_input"
+require_relative "../generation_transaction"
+
+module Ibex
+  # Collects, verifies, and transactionally publishes CLI generation outputs.
+  module CLIGenerationArtifacts
+    # @rbs!
+    #   private def report_status: (String) -> void
+    #   private def verify_file: (String, String, String) -> void
+    #   private def default_output_path: (String, String) -> String
+
+    private
+
+    # @rbs () -> void
+    def begin_artifact_generation
+      @generation_artifacts = ArtifactSet.new
+      @generation_statuses = [] #: Array[String]
+      @generation_sources = [] #: Array[String]
+      @generation_inputs = [] #: Array[GenerationInput]
+    end
+
+    # @rbs (Symbol kind, String path, String content, ?mode: Integer?, ?status: bool) -> Artifact
+    def register_artifact(kind, path, content, mode: nil, status: false)
+      artifact = generation_artifacts.add(kind: kind, path: path, content: content, mode: mode)
+      @generation_statuses << "wrote #{path}" if status
+      artifact
+    end
+
+    # @rbs (Array[String] source_paths) -> Integer
+    def finish_artifact_generation(_source_paths)
+      add_generation_manifest if @options[:manifest]
+      return 0 if @defer_generation_publication
+
+      ensure_generation_inputs_stable!
+      if @options[:verify_output]
+        verify_artifact_generation
+        ensure_generation_inputs_stable!
+      elsif !generation_artifacts.empty?
+        GenerationTransaction.new(
+          generation_artifacts,
+          warning: ->(message) { @stderr.puts("ibex: warning: #{message}") },
+          stability_check: -> { generation_inputs_stable? },
+          source_records: @generation_inputs
+        ).commit
+        @generation_statuses.each { |message| report_status(message) }
+      end
+      0
+    end
+
+    # @rbs () -> void
+    def add_generation_manifest
+      require_relative "../generation_manifest"
+
+      path = manifest_output_path
+      source = GenerationManifest.render(
+        generation_artifacts,
+        source_records: @generation_inputs,
+        options: generation_manifest_options
+      )
+      register_artifact(:manifest, path, source, status: true)
+    end
+
+    # @rbs () -> void
+    def verify_artifact_generation
+      generation_artifacts.each do |artifact|
+        verify_file(artifact.path, artifact.content, artifact_label(artifact.kind))
+      end
+      parser = generation_artifacts.find { |artifact| artifact.kind == :parser }
+      report_status("verified #{parser.path}") if parser
+    end
+
+    # @rbs (Symbol kind) -> String
+    def artifact_label(kind)
+      {
+        parser: "parser",
+        rbs: "RBS signature",
+        action_source: "action source",
+        manifest: "generation manifest"
+      }.fetch(kind, kind.to_s.tr("_", " "))
+    end
+
+    # @rbs () -> ArtifactSet
+    def generation_artifacts
+      @generation_artifacts || raise(Ibex::Error, "(generation):1:1: artifact collection is not active")
+    end
+
+    # @rbs () -> bool
+    def generation_inputs_stable?
+      @generation_inputs.all?(&:current?)
+    end
+
+    # @rbs () -> void
+    def ensure_generation_inputs_stable!
+      return if generation_inputs_stable?
+
+      raise GenerationTransaction::SourceChanged, "(generation):1:1: source changed while rendering outputs"
+    end
+
+    # @rbs (String path, String source) -> GenerationInput
+    def record_generation_input(path, source)
+      input = GenerationInput.new(path, source)
+      @generation_inputs.reject! { |entry| entry.path == input.path }
+      @generation_inputs << input
+      @generation_sources = @generation_inputs.map(&:path)
+      input
+    end
+
+    # @rbs () -> String
+    def manifest_output_path
+      configured = @options[:manifest]
+      return configured if configured.is_a?(String) && !configured.empty?
+
+      parser = generation_artifacts.find { |artifact| artifact.kind == :parser }
+      raise Ibex::Error, "(generation):1:1: generation manifest requires a parser artifact" unless parser
+
+      default_output_path(parser.path, ".ibex.json")
+    end
+
+    # @rbs () -> Hash[String, untyped]
+    def generation_manifest_options
+      keys = %i[
+        action_source algorithm counterexample_max_configurations counterexample_max_tokens debug
+        embedded emit entry_isolation executable frozen line_convert line_convert_all messages mode omit_actions rbs
+        superclass table
+      ]
+      options = {} #: Hash[String, untyped]
+      keys.each do |key|
+        value = @options[key]
+        options[key.to_s] = value unless value.nil?
+      end
+      options
+    end
+  end
+end

data/lib/ibex/cli/generation_error_messages.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  # Optional example-keyed error-message support for parser generation.
+  module CLIGenerationErrorMessages
+    # @rbs!
+    #   private def record_generation_input: (String, String) -> GenerationInput
+
+    private
+
+    # @rbs (OptionParser options) -> void
+    def add_error_messages_generation_option(options)
+      options.on("--messages=FILE", "embed example-keyed syntax error messages") do |value|
+        @options[:messages] = value
+      end
+    end
+
+    # @rbs (IR::Automaton automaton) -> Hash[Integer, untyped]
+    def configured_error_messages(automaton)
+      path = @options[:messages]
+      return {} unless path
+
+      require_relative "../error_messages"
+      source = File.binread(path)
+      record_generation_input(path, source)
+      document = ErrorMessages.parse(source, file: path)
+      ErrorMessages.records_for(document, automaton, file: path)
+    end
+
+    # @rbs () -> void
+    def validate_messages_options
+      return unless @options[:messages]
+      raise Ibex::Error, "(cli):1:1: --messages is available only with --emit=ruby" unless @options[:emit] == "ruby"
+
+      raise Ibex::Error, "(cli):1:1: --messages cannot be combined with --check-only" if @options[:check_only]
+    end
+  end
+end

data/lib/ibex/cli/grammar_tests.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "optparse"
+require_relative "../grammar_tests"
+
+module Ibex
+  # `%test` command parsing and human-readable result reporting.
+  module CLIGrammarTests
+    # @rbs!
+    #   type grammar_test_settings = {
+    #     mode: Symbol,
+    #     algorithm: Symbol,
+    #     entry_isolation: bool,
+    #     timeout: Integer,
+    #     coverage: Integer?,
+    #     ?help: bool
+    #   }
+    #   private def print_help: (OptionParser) -> Integer
+    #   private def resolve_grammar_path: (String) -> Frontend::Resolution
+    #   private def handle_grammar_warnings: (IR::Grammar, String) -> void
+    #   private def build_automaton: (IR::Grammar, String) -> IR::Automaton
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_grammar_tests_command(arguments)
+      settings = {
+        mode: :default, algorithm: :lalr, entry_isolation: false, timeout: GrammarTests::DEFAULT_TIMEOUT, coverage: nil
+      } #: grammar_test_settings
+      options = grammar_test_option_parser(settings)
+      remaining = options.parse(arguments)
+      return print_help(options) if settings[:help]
+      unless settings[:coverage].nil? || settings[:coverage].between?(1, 100)
+        raise OptionParser::InvalidArgument, "coverage must be between 1 and 100"
+      end
+
+      path = single_grammar_test_path(remaining, options)
+      @options[:mode] = settings[:mode]
+      @options[:algorithm] = settings[:algorithm]
+      @options[:entry_isolation] = settings[:entry_isolation]
+      resolution = resolve_grammar_path(path)
+      grammar = Normalizer.new(resolution, mode: settings[:mode]).normalize
+      handle_grammar_warnings(grammar, path)
+      automaton = build_automaton(grammar, path)
+      runner = GrammarTests::Runner.new(automaton, timeout: settings[:timeout])
+      results = runner.run
+      failures = render_grammar_test_results(results)
+      coverage = settings[:coverage]
+      return failures unless coverage
+
+      render_grammar_test_coverage(runner.production_coverage(results), coverage, failures)
+    end
+
+    # @rbs (grammar_test_settings settings) -> OptionParser
+    def grammar_test_option_parser(settings)
+      OptionParser.new do |options|
+        options.banner = "Usage: ibex test [options] grammarfile"
+        options.on("--mode=MODE", %w[default extended], "grammar mode") { |value| settings[:mode] = value.to_sym }
+        options.on("--algorithm=NAME", %w[slr lalr ielr lr1], "parser construction algorithm") do |value|
+          settings[:algorithm] = value.to_sym
+        end
+        options.on("--entry-isolation", "build independent state sets for each start symbol") do
+          settings[:entry_isolation] = true
+        end
+        options.on("--timeout=SECONDS", Integer, "whole-suite timeout (default: 10)") do |value|
+          raise OptionParser::InvalidArgument, "timeout must be positive" unless value.positive?
+
+          settings[:timeout] = value
+        end
+        options.on("--coverage=PERCENT", Integer, "require production coverage (1..100)") do |value|
+          settings[:coverage] = value
+        end
+        options.on("-h", "--help", "show this help") { settings[:help] = true }
+      end
+    end
+
+    # @rbs (Array[String] remaining, OptionParser options) -> String
+    def single_grammar_test_path(remaining, options)
+      return remaining.fetch(0) if remaining.one?
+
+      raise OptionParser::MissingArgument, options.banner if remaining.empty?
+
+      raise OptionParser::InvalidArgument, "test accepts exactly one grammarfile"
+    end
+
+    # @rbs (Array[GrammarTests::Result] results) -> Integer
+    def render_grammar_test_results(results)
+      failures = 0
+      results.each_with_index do |result, index|
+        label = "#{result.expectation} #{result.location[:file]}:#{result.location[:line]}"
+        if result.passed?
+          @stdout.puts("ok #{index + 1} - #{label}")
+        else
+          failures += 1
+          @stdout.puts("not ok #{index + 1} - #{label} (#{grammar_test_failure(result)})")
+        end
+      end
+      @stdout.puts("#{results.length} tests, #{failures} failures")
+      failures.zero? ? 0 : 1
+    end
+
+    # @rbs (GrammarTests::ProductionCoverage coverage, Integer minimum, Integer failures) -> Integer
+    def render_grammar_test_coverage(coverage, minimum, failures)
+      @stdout.puts(
+        format(
+          "production coverage: %<covered>d/%<total>d (%<percentage>.1f%%), required %<minimum>d%%",
+          covered: coverage.covered_ids.length, total: coverage.production_count,
+          percentage: coverage.percentage, minimum: minimum
+        )
+      )
+      @stdout.puts("missing production ids: #{coverage.missing_ids.join(', ')}") unless coverage.complete?
+      failures.zero? && coverage.meets?(minimum) ? 0 : 1
+    end
+
+    # @rbs (GrammarTests::Result result) -> String
+    def grammar_test_failure(result)
+      return "parser #{result.actual}ed the input" unless result.actual == :error
+
+      "#{result.error_class}: #{result.error_message}"
+    end
+  end
+end