ibex 0.1.0 → 0.3.0

data/lib/ibex/cli/grammar_tests.rb

@@ -0,0 +1,140 @@
+# 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 = Hash[Symbol, untyped]
+    #   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 def configuration_value: (String) -> untyped
+    #   private def mark_configuration_option: (Symbol) -> void
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_grammar_tests_command(arguments)
+      settings = default_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 = normalize_analysis_grammar(resolution)
+      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 () -> Hash[Symbol, untyped]
+    def default_grammar_test_settings
+      {
+        mode: Configuration::Registry.fetch("grammar.mode").default,
+        algorithm: Configuration::Registry.fetch("parser.algorithm").default,
+        entry_isolation: Configuration::Registry.fetch("parser.entries").default == :isolated,
+        timeout: GrammarTests::DEFAULT_TIMEOUT, coverage: nil
+      }
+    end
+
+    # @rbs (Hash[Symbol, untyped] 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") do |value|
+          settings[:mode] = value.to_sym
+          mark_configuration_option(:mode)
+        end
+        options.on("--algorithm=NAME", %w[slr lalr ielr lr1], "parser construction algorithm") do |value|
+          settings[:algorithm] = value.to_sym
+          mark_configuration_option(:algorithm)
+        end
+        options.on("--entry-isolation", "build independent state sets for each start symbol") do
+          settings[:entry_isolation] = true
+          mark_configuration_option(:entry_isolation)
+        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 (Frontend::Resolution resolution) -> IR::Grammar
+    def normalize_analysis_grammar(resolution)
+      grammar = Normalizer.new(resolution, mode: configuration_value("grammar.mode")).normalize
+      activate_analysis_grammar(grammar)
+    end
+
+    # @rbs!
+    #   private def activate_analysis_grammar: (IR::Grammar, ?options: Hash[Symbol, Object?],
+    #     ?explicit_keys: Array[Symbol]) -> IR::Grammar
+
+    # @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

data/lib/ibex/cli/ir_tools.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative "../ir"
+
+module Ibex
+  # CLI validation and structural comparison for current IR documents.
+  module CLIIRTools
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_validate_ir_command(arguments)
+      path = single_ir_path(arguments, "validate-ir")
+      value = IR::Validator.validate(File.read(path))
+      kind = if value.is_a?(IR::Grammar)
+               "grammar"
+             elsif value.is_a?(IR::Lexer)
+               "lexer"
+             else
+               "automaton"
+             end
+      @stdout.puts("valid current #{kind} IR")
+      0
+    end
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_compare_command(arguments)
+      raise Ibex::Error, "(cli):1:1: compare requires exactly two IR files" unless arguments.length == 2
+
+      before = IR::Validator.validate(File.read(arguments.fetch(0)))
+      after = IR::Validator.validate(File.read(arguments.fetch(1)))
+      compatible = (before.is_a?(IR::Grammar) && after.is_a?(IR::Grammar)) ||
+                   (before.is_a?(IR::Automaton) && after.is_a?(IR::Automaton)) ||
+                   (before.is_a?(IR::Lexer) && after.is_a?(IR::Lexer))
+      raise Ibex::Error, "(cli):1:1: cannot compare different IR kinds" unless compatible
+
+      @stdout.puts(JSON.pretty_generate(compare_ir(before, after)))
+      0
+    end
+
+    # @rbs (Array[String] arguments, String command) -> String
+    def single_ir_path(arguments, command)
+      return arguments.first if arguments.length == 1
+
+      raise Ibex::Error, "(cli):1:1: #{command} requires exactly one IR file"
+    end
+
+    # @rbs (IR::Grammar | IR::Automaton | IR::Lexer before,
+    #   IR::Grammar | IR::Automaton | IR::Lexer after) -> Hash[Symbol, Object?]
+    def compare_ir(before, after)
+      return compare_grammars(before, after) if before.is_a?(IR::Grammar) && after.is_a?(IR::Grammar)
+      if before.is_a?(IR::Automaton) && after.is_a?(IR::Automaton)
+        return {
+          kind: "automaton",
+          algorithm: { before: before.algorithm, after: after.algorithm },
+          states: numeric_change(before.states.length, after.states.length),
+          transitions: numeric_change(transition_count(before), transition_count(after)),
+          conflicts: %i[sr resolved_sr rr].to_h do |kind|
+            [kind, numeric_change(summary_count(before, kind), summary_count(after, kind))]
+          end,
+          grammar: compare_grammars(before.grammar, after.grammar)
+        }
+      end
+      return compare_lexers(before, after) if before.is_a?(IR::Lexer) && after.is_a?(IR::Lexer)
+
+      raise Ibex::Error, "(cli):1:1: unsupported IR comparison"
+    end
+
+    # @rbs (IR::Lexer before, IR::Lexer after) -> Hash[Symbol, Object?]
+    def compare_lexers(before, after)
+      before_rules = before.rules.map { |rule| [rule.state, rule.kind, rule.token, rule.pattern, rule.options] }
+      after_rules = after.rules.map { |rule| [rule.state, rule.kind, rule.token, rule.pattern, rule.options] }
+      {
+        kind: "lexer",
+        states: { added: after.states - before.states, removed: before.states - after.states },
+        rules: {
+          added: after_rules - before_rules, removed: before_rules - after_rules,
+          count: numeric_change(before.rules.length, after.rules.length)
+        },
+        warnings: numeric_change(before.warnings.length, after.warnings.length)
+      }
+    end
+
+    # @rbs (IR::Grammar before, IR::Grammar after) -> Hash[Symbol, Object?]
+    def compare_grammars(before, after)
+      before_symbols = before.symbols.map(&:name)
+      after_symbols = after.symbols.map(&:name)
+      before_productions = production_shapes(before)
+      after_productions = production_shapes(after)
+      {
+        kind: "grammar",
+        symbols: { added: (after_symbols - before_symbols).sort, removed: (before_symbols - after_symbols).sort },
+        productions: {
+          added: (after_productions - before_productions).sort,
+          removed: (before_productions - after_productions).sort,
+          count: numeric_change(before.productions.length, after.productions.length)
+        },
+        warnings: numeric_change(before.warnings.length, after.warnings.length)
+      }
+    end
+
+    # @rbs (IR::Grammar grammar) -> Array[String]
+    def production_shapes(grammar)
+      grammar.productions.map do |production|
+        lhs = grammar.symbol_by_id(production.lhs)&.name || production.lhs.to_s
+        rhs = production.rhs.map { |id| grammar.symbol_by_id(id)&.name || id.to_s }
+        "#{lhs} -> #{rhs.join(' ')}"
+      end
+    end
+
+    # @rbs (IR::Automaton automaton) -> Integer
+    def transition_count(automaton)
+      automaton.states.sum { |state| state.transitions.length }
+    end
+
+    # @rbs (IR::Automaton automaton, Symbol kind) -> Integer
+    def summary_count(automaton, kind)
+      value = automaton.conflict_summary.fetch(kind)
+      return value if value.is_a?(Integer)
+
+      raise Ibex::Error, "(ir):1:1: conflict count #{kind} must be an integer"
+    end
+
+    # @rbs (Integer before, Integer after) -> Hash[Symbol, Integer]
+    def numeric_change(before, after)
+      { before: before, after: after, delta: after - before }
+    end
+  end
+end

data/lib/ibex/cli/lsp.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../lsp"
+
+module Ibex
+  # CLI boundary for the stdio-only language server.
+  module CLILSP
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_lsp_command(arguments)
+      settings = { help: false, stdio: false } #: Hash[Symbol, bool]
+      remaining = lsp_option_parser(settings).parse(arguments)
+      raise Ibex::Error, "(cli):1:1: ibex lsp does not accept file arguments" unless remaining.empty?
+
+      if settings.fetch(:help)
+        @stdout.puts(lsp_option_parser(settings))
+        return 0
+      end
+
+      LSP::Server.new(stdin: @stdin, stdout: @stdout, stderr: @stderr).run
+    end
+
+    # @rbs (Hash[Symbol, bool] settings) -> OptionParser
+    def lsp_option_parser(settings)
+      OptionParser.new do |options|
+        options.banner = "Usage: ibex lsp [--stdio]"
+        options.on("--stdio", "use Content-Length framed JSON-RPC on standard IO") { settings[:stdio] = true }
+        options.on("--help", "show help") { settings[:help] = true }
+      end
+    end
+  end
+end

data/lib/ibex/cli/outputs.rb

@@ -3,15 +3,21 @@
 module Ibex
   # Files, warnings, and progress emitted by CLI pipeline stages.
   module CLIOutputs
-    WARNING_MESSAGES = {
-      undeclared_terminal: ->(warning) { "undeclared terminal #{warning[:symbol]}" },
-      unused_terminal: ->(warning) { "unused terminal #{warning[:symbol]}" },
-      unreachable_nonterminal: ->(warning) { "unreachable nonterminal #{warning[:symbol]}" },
-      duplicate_production: lambda do |warning|
-        "duplicate production #{warning[:production]} (first defined as #{warning[:original]})"
-      end,
-      empty_language: ->(warning) { "start symbol #{warning[:symbol]} derives no terminal sentence" }
-    }.freeze #: Hash[Symbol, ^(IR::grammar_warning) -> String]
+    # @rbs!
+    #   private def register_artifact: (Symbol, String, String, ?mode: Integer?, ?status: bool) -> Artifact
+    #   private def configuration_value: (String) -> Object?
+
+    WARNING_MESSAGE_IDS = {
+      undeclared_terminal: "warning.undeclared_terminal",
+      unused_terminal: "warning.unused_terminal",
+      unused_precedence: "warning.unused_precedence",
+      unreachable_terminal: "warning.unreachable_terminal",
+      unreachable_nonterminal: "warning.unreachable_nonterminal",
+      duplicate_production: "warning.duplicate_production",
+      implicit_empty: "warning.implicit_empty",
+      empty_language: "warning.empty_language",
+      lexer_redos: "warning.lexer_redos"
+    }.freeze #: Hash[Symbol, String]
 
     private
 
@@ -32,57 +38,161 @@ module Ibex
       categories = @options[:warnings]
       return if categories.nil? || categories.include?(:none) || grammar.warnings.empty?
 
-      messages = grammar.warnings.map { |warning| format_grammar_warning(warning, input_path) }
       if categories.include?(:error)
-        promoted = messages.map { |message| message.sub(": warning:", ": warning treated as error:") }
+        promoted = grammar.warnings.map do |warning|
+          format_grammar_warning(warning, input_path, promoted: true)
+        end
         raise Ibex::Error, promoted.join("\n")
       end
 
-      messages.each { |message| @stderr.puts(message) }
+      grammar.warnings.each { |warning| @stderr.puts(format_grammar_warning(warning, input_path)) }
     end
 
-    # @rbs (IR::grammar_warning warning, String input_path) -> String
-    def format_grammar_warning(warning, input_path)
+    # @rbs (IR::grammar_warning warning, String input_path, ?promoted: bool) -> String
+    def format_grammar_warning(warning, input_path, promoted: false)
       location = warning[:loc]
       rendered = if location
                    "#{location[:file] || input_path}:#{location[:line] || 1}:#{location[:column] || 1}"
                  else
                    "#{input_path}:1:1"
                  end
-      formatter = WARNING_MESSAGES.fetch(warning[:type]) { ->(item) { item[:type].to_s.tr("_", " ") } }
-      "#{rendered}: warning: #{formatter.call(warning)}"
+      label_id = promoted ? "label.warning_as_error" : "label.warning"
+      label = Messages.translate(label_id, language: @language)
+      "#{rendered}: #{label}: #{grammar_warning_message(warning)}"
+    end
+
+    # @rbs (IR::grammar_warning warning) -> String
+    def grammar_warning_message(warning)
+      id = WARNING_MESSAGE_IDS.fetch(warning[:type])
+      id = "warning.lexer_redos_symbol" if warning[:type] == :lexer_redos && warning[:symbol]
+      values = warning.to_h.transform_values(&:to_s) #: Hash[Symbol, String]
+      Messages.translate(id, language: @language, **values)
     end
 
     # @rbs (IR::Automaton automaton, String input_path) -> void
     def report_conflicts(automaton, input_path)
-      summary = automaton.conflict_summary
+      messages = conflict_messages(automaton.conflict_summary, input_path)
+      if @options[:warnings]&.include?(:error) && messages.any?
+        promoted = messages.map do |message|
+          Messages.translate("conflict.treated_as_error", language: @language, detail: message)
+        end
+        raise Ibex::Error, promoted.join("\n")
+      end
+
+      messages.each { |message| @stderr.puts(message) }
+    end
+
+    # @rbs (IR::conflict_summary summary, String input_path) -> Array[String]
+    def conflict_messages(summary, input_path)
+      messages = [] #: Array[String]
       unless summary[:expectation_met]
-        @stderr.puts("#{input_path}:1:1: #{summary[:sr]} shift/reduce conflicts; expected #{summary[:expected_sr]}")
+        detail = Messages.translate(
+          "conflict.shift_reduce_expected",
+          language: @language,
+          actual: summary[:sr],
+          expected: summary[:expected_sr]
+        )
+        messages << "#{input_path}:1:1: #{detail}"
       end
-      @stderr.puts("#{input_path}:1:1: #{summary[:rr]} reduce/reduce conflicts") if summary[:rr].positive?
+      if summary.key?(:rr_expectation_met)
+        unless summary[:rr_expectation_met]
+          detail = Messages.translate(
+            "conflict.reduce_reduce_expected",
+            language: @language,
+            actual: summary[:rr],
+            expected: summary[:expected_rr]
+          )
+          messages << "#{input_path}:1:1: #{detail}"
+        end
+      elsif summary[:rr].positive?
+        detail = Messages.translate("conflict.reduce_reduce", language: @language, actual: summary[:rr])
+        messages << "#{input_path}:1:1: #{detail}"
+      end
+      messages
+    end
+
+    # @rbs (IR::Automaton automaton, String input_path) -> void
+    # rubocop:disable Metrics/AbcSize -- the bounded comparison reports each conflict class independently.
+    def suggest_ielr(automaton, input_path)
+      return unless @options[:suggest_ielr]
+      return unless automaton.algorithm == "lalr1"
+      return unless configuration_value("parser.algorithm") == :lalr
+
+      summary = automaton.conflict_summary
+      return if summary[:expectation_met] && summary.fetch(:rr_expectation_met, summary[:rr].zero?)
+
+      ielr = LALR::Builder.new(
+        Configuration::AnalysisGrammar.for_algorithm(automaton.grammar, :ielr),
+        algorithm: :ielr, entry_isolation: configuration_value("parser.entries") == :isolated
+      ).build
+      removed_sr = [summary[:sr] - ielr.conflict_summary[:sr], 0].max
+      removed_rr = [summary[:rr] - ielr.conflict_summary[:rr], 0].max
+      avoided = [] #: Array[String]
+      avoided << conflict_count(removed_sr, "shift/reduce") if removed_sr.positive?
+      avoided << conflict_count(removed_rr, "reduce/reduce") if removed_rr.positive?
+      return if avoided.empty?
+
+      conjunction = @language == "ja" ? "、" : " and "
+      detail = Messages.translate("note.ielr", language: @language, avoided: avoided.join(conjunction))
+      @stderr.puts("#{input_path}:1:1: #{detail}")
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    # @rbs (Integer count, String kind) -> String
+    def conflict_count(count, kind)
+      plural = @language == "en" && count != 1 ? "s" : ""
+      Messages.translate("conflict.count", language: @language, count: count, kind: kind, plural: plural)
     end
 
     # @rbs (IR::Automaton automaton, String input_path) -> void
     def write_report(automaton, input_path)
+      require_relative "../codegen/report"
       path = @options[:log_file] || default_output_path(input_path, ".output")
       report = Codegen::Report.render(
         automaton,
         max_tokens: @options[:counterexample_max_tokens],
         max_configurations: @options[:counterexample_max_configurations]
       )
-      File.write(path, report)
-      report_status("wrote #{path}")
+      register_artifact(:report, path, report, status: true)
     end
 
     # @rbs (String input_path, String extension) -> String
     def default_output_path(input_path, extension)
-      replaced = input_path.sub(/\.[^.]+\z/, extension)
-      replaced == input_path ? "#{input_path}#{extension}" : replaced
+      directory = File.dirname(input_path)
+      basename = File.basename(input_path)
+      replaced = basename.sub(/\.[^.]+\z/, extension)
+      replaced = "#{basename}#{extension}" if replaced == basename
+      directory == "." ? replaced : File.join(directory, replaced)
     end
 
     # @rbs (String message) -> void
     def report_status(message)
       @stderr.puts("ibex: #{message}") if @options[:status]
     end
+
+    # @rbs (String path, String source) -> void
+    def atomic_write_ir(path, source)
+      require "tempfile"
+
+      target_path = File.symlink?(path) ? File.realpath(path) : path
+      directory = File.dirname(File.expand_path(target_path))
+      basename = File.basename(target_path)
+      Tempfile.create([".#{basename}.", ".tmp"], directory) do |temporary|
+        temporary.binmode
+        temporary.write(source)
+        temporary.flush
+        temporary.fsync
+        temporary.chmod(ir_file_mode(target_path))
+        temporary.close
+        File.rename(temporary.path, target_path)
+      end
+    end
+
+    # @rbs (String path) -> Integer
+    def ir_file_mode(path)
+      return File.stat(path).mode & 0o777 if File.exist?(path)
+
+      0o666 & ~File.umask
+    end
   end
 end

data/lib/ibex/cli/racc_migration.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "json"
+require "optparse"
+require_relative "../racc_migration"
+
+module Ibex
+  # Static racc migration checks and differential harness generation.
+  module CLIRaccMigration
+    # @rbs!
+    #   type migration_check_settings = {
+    #     format: String,
+    #     ?help: bool
+    #   }
+    #   type migration_harness_settings = {
+    #     ?output: String,
+    #     ?help: bool
+    #   }
+    #
+    #   private def input_path: (Array[String]) -> String
+    #   private def atomic_write_ir: (String path, String source) -> void
+    #   private def same_file_target?: (String left, String right) -> bool
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_migrate_check_command(arguments)
+      settings = { format: "text" } #: migration_check_settings
+      parser = migrate_check_options(settings)
+      paths = parser.parse(arguments)
+      if settings[:help]
+        @stdout.puts(parser)
+        return 0
+      end
+
+      path = input_path(paths)
+      report = RaccMigration::Checker.new.check(File.binread(path), file: path)
+      @stdout.write(settings.fetch(:format) == "json" ? "#{report.to_json}\n" : report.to_text)
+      report.compatible? ? 0 : 1
+    end
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_migrate_harness_command(arguments)
+      settings = {} #: migration_harness_settings
+      parser = migrate_harness_options(settings)
+      paths = parser.parse(arguments)
+      if settings[:help]
+        @stdout.puts(parser)
+        return 0
+      end
+
+      path = input_path(paths)
+      report = RaccMigration::Checker.new.check(File.binread(path), file: path)
+      unless report.compatible? && report.class_name
+        raise Ibex::Error, "(migration):1:1: grammar must pass migrate-check before harness generation"
+      end
+
+      source = RaccMigration::Harness.generate(report.class_name)
+      output = settings[:output]
+      if output && same_file_target?(path, output)
+        raise Ibex::Error, "(migration):1:1: grammar and harness output paths must be distinct"
+      end
+
+      output ? atomic_write_ir(output, source) : @stdout.write(source)
+      0
+    end
+
+    # @rbs (migration_check_settings settings) -> OptionParser
+    def migrate_check_options(settings)
+      OptionParser.new do |options|
+        options.banner = "Usage: ibex migrate-check [--format=text|json] grammarfile"
+        options.on("--format=FORMAT", %w[text json], "text or json") { |value| settings[:format] = value }
+        options.on("--help", "show help") { settings[:help] = true }
+      end
+    end
+
+    # @rbs (migration_harness_settings settings) -> OptionParser
+    def migrate_harness_options(settings)
+      OptionParser.new do |options|
+        options.banner = "Usage: ibex migrate-harness [-o FILE] grammarfile"
+        options.on("-o FILE", "--output=FILE", "write the harness atomically") { |value| settings[:output] = value }
+        options.on("--help", "show help") { settings[:help] = true }
+      end
+    end
+  end
+end