rigortype 0.1.19 → 0.2.1

data/lib/rigor/cli/coverage_command.rb

@@ -1,14 +1,30 @@
 # frozen_string_literal: true
 
+require "English"
 require "optionparser"
 require "prism"
+require "shellwords"
 
 require_relative "../configuration"
+require_relative "options"
 require_relative "../environment"
 require_relative "../inference/precision_scanner"
+require_relative "../inference/protection_scanner"
+require_relative "../inference/parameter_inference_collector"
+require_relative "../protection/mutation_scanner"
+require_relative "../protection/test_suite_oracle"
+require_relative "../language_server/project_context"
 require_relative "../scope"
 require_relative "coverage_report"
 require_relative "coverage_renderer"
+require_relative "coverage_scan"
+require_relative "protection_report"
+require_relative "protection_renderer"
+require_relative "mutation_protection_report"
+require_relative "mutation_protection_renderer"
+require_relative "fused_protection_report"
+require_relative "fused_protection_renderer"
+require_relative "coverage_mutation"
 require_relative "command"
 
 module Rigor
@@ -27,15 +43,28 @@ module Rigor
     #   1  — precision ratio < threshold, or parse errors encountered
     #   64 — usage error
     class CoverageCommand < Command
+      include CoverageMutation
+
       USAGE = "Usage: rigor coverage [options] PATH..."
 
+      # ADR-70 — the default test runner hook for `--with-tests`. The
+      # conventional Ruby test task; override with `--test-command`.
+      DEFAULT_TEST_COMMAND = %w[bundle exec rake].freeze
+
       # @return [Integer] CLI exit status.
       def run
         options = parse_options
+        return mutation_misuse_error if options[:mutation] && !options[:protection]
+        return with_tests_misuse_error if options[:with_tests] && !options[:mutation]
+        return include_dynamic_misuse_error if options[:include_dynamic] && !options[:with_tests]
+        return run_mutation_protection(options) if options[:mutation]
+
         paths = collect_paths(@argv, command_name: "coverage")
         return CLI::EXIT_USAGE if paths.nil?
         return usage_error if paths.empty?
 
+        return run_protection(paths, options) if options[:protection]
+
         report = scan_paths(paths, options)
         CoverageRenderer.new(out: @out).render(report, format: options.fetch(:format))
         determine_exit(report, options)
@@ -44,53 +73,131 @@ module Rigor
       private
 
       def parse_options
-        options = { format: "text", threshold: nil, config: nil }
-
-        OptionParser.new do |opts|
-          opts.banner = USAGE
-          opts.on("--format=FORMAT", "Output format: text or json") { |v| options[:format] = v }
-          opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
-          opts.on(
-            "--threshold=RATIO", Float,
-            "Exit 1 when precision ratio is below RATIO (0.0–1.0)"
-          ) { |v| options[:threshold] = v }
-        end.parse!(@argv)
-
+        options = { format: "text", threshold: nil, config: nil, protection: false, mutation: false,
+                    with_tests: false, test_command: DEFAULT_TEST_COMMAND, include_dynamic: false,
+                    limit: nil, seed: 1 }
+        OptionParser.new { |opts| define_options(opts, options) }.parse!(@argv)
         options
       end
 
-      def usage_error
-        @err.puts("coverage: at least one path is required")
+      def define_options(opts, options)
+        opts.banner = USAGE
+        opts.on("--format=FORMAT", "Output format: text or json") { |v| options[:format] = v }
+        Options.add_config(opts, options)
+        opts.on("--protection", "Report type-protection coverage (ADR-63 Tier 1) instead of type precision") do
+          options[:protection] = true
+        end
+        define_mutation_options(opts, options)
+        opts.on("--threshold=RATIO", Float, "Exit 1 when the precision (or, with --protection, " \
+                                            "protection/effectiveness) ratio is below RATIO (0.0–1.0)") do |v|
+          options[:threshold] = v
+        end
+      end
+
+      def define_mutation_options(opts, options)
+        opts.on("--mutation", "With --protection: measure actual mutation effectiveness (ADR-63 Tier 2). " \
+                              "Scopes to git-changed files when no paths are given; explicit paths override.") do
+          options[:mutation] = true
+        end
+        opts.on("--with-tests", "With --mutation: also measure dynamic (test-suite) protection (ADR-70). " \
+                                "Runs --test-command against each type-survivor; reports the fused map.") do
+          options[:with_tests] = true
+        end
+        opts.on("--test-command=CMD", "The test runner hook for --with-tests " \
+                                      "(default: #{DEFAULT_TEST_COMMAND.join(' ')})") do |v|
+          options[:test_command] = Shellwords.split(v)
+        end
+        opts.on("--include-dynamic", "With --with-tests: also mutate Dynamic-receiver (untyped) sites, where a " \
+                                     "test is the only protection (ADR-69 Seam 2). Completes the map, runs more.") do
+          options[:include_dynamic] = true
+        end
+        opts.on("--limit=N", Integer,
+                "Sample at most N mutations/file under --mutation (caps cost; ratios become estimates)") do |v|
+          options[:limit] = v
+        end
+        opts.on("--seed=N", Integer, "RNG seed for --limit sampling (default 1)") { |v| options[:seed] = v }
+      end
+
+      def mutation_misuse_error
+        @err.puts("coverage: --mutation requires --protection")
         @err.puts(USAGE)
         CLI::EXIT_USAGE
       end
 
-      def scan_paths(paths, options)
+      def with_tests_misuse_error
+        @err.puts("coverage: --with-tests requires --mutation (and --protection)")
+        @err.puts(USAGE)
+        CLI::EXIT_USAGE
+      end
+
+      def include_dynamic_misuse_error
+        @err.puts("coverage: --include-dynamic requires --with-tests (a Dynamic site's only protection is a test)")
+        @err.puts(USAGE)
+        CLI::EXIT_USAGE
+      end
+
+      def run_protection(paths, options)
+        report = scan_protection(paths, options)
+        ProtectionRenderer.new(out: @out).render(report, format: options.fetch(:format))
+        determine_protection_exit(report, options)
+      end
+
+      def scan_protection(paths, options)
         configuration = Configuration.load(options.fetch(:config))
-        scope = Scope.empty(environment: project_environment(configuration))
-        scanner = Inference::PrecisionScanner.new(scope: scope)
-        accumulator = CoverageAccumulator.new
+        environment = project_environment(configuration)
+        scope = scope_with_inferred_params(paths, configuration, environment)
+        scanner = Inference::ProtectionScanner.new(scope: scope)
+        accumulator = ProtectionAccumulator.new
 
         paths.each { |path| scan_one(path, scanner, accumulator, configuration) }
-        accumulator.to_report(paths, options)
+        accumulator.to_report
       end
 
-      def project_environment(configuration)
-        Environment.for_project(
-          libraries: configuration.libraries,
-          signature_paths: configuration.signature_paths
+      # ADR-67 WD3 — seed the call-site parameter-inference table so the
+      # protection scan counts an inferred-parameter receiver (e.g. `node.loc`
+      # where `node` is a `def compile(node)` parameter) as protected when its
+      # call sites resolve to concrete argument types. ONLY the parameter table
+      # is seeded — no cross-file discovery — so every site that does not gain
+      # an inferred parameter type is classified byte-identically to the
+      # un-inferred baseline. Collection spans the scanned `paths`.
+      def scope_with_inferred_params(paths, configuration, environment)
+        base = Scope.empty(environment: environment)
+        table = Inference::ParameterInferenceCollector.collect(
+          files: paths, environment: environment, target_ruby: configuration.target_ruby
         )
+        return base if table.empty?
+
+        base.with_discovery(base.discovery.with(param_inferred_types: table))
       end
 
-      def scan_one(path, scanner, accumulator, configuration)
-        source = File.read(path)
-        parse_result = Prism.parse(source, filepath: path, version: configuration.target_ruby)
-        if parse_result.errors.any?
-          accumulator.record_parse_error(path, parse_result.errors)
-          return
-        end
+      def determine_protection_exit(report, options)
+        return 1 unless report.parse_errors.empty?
+
+        threshold = options[:threshold]
+        return 0 if threshold.nil?
+
+        report.ratio < threshold ? 1 : 0
+      end
 
-        accumulator.absorb(path, scanner.scan(parse_result.value))
+      def usage_error
+        @err.puts("coverage: at least one path is required")
+        @err.puts(USAGE)
+        CLI::EXIT_USAGE
+      end
+
+      def scan_paths(paths, options)
+        CoverageScan.precision_report(files: paths, configuration: Configuration.load(options.fetch(:config)))
+      end
+
+      # Delegated to the shared scan module (see {CoverageScan}); the
+      # protection path below reuses both, and `rigor check --coverage`
+      # reuses `precision_report` over the same machinery.
+      def project_environment(configuration)
+        CoverageScan.project_environment(configuration)
+      end
+
+      def scan_one(path, scanner, accumulator, configuration)
+        CoverageScan.scan_into(path, scanner, accumulator, configuration)
       end
 
       def determine_exit(report, options)

data/lib/rigor/cli/coverage_mutation.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "English"
+require "prism"
+
+module Rigor
+  class CLI
+    # ADR-63 Tier 2 + ADR-70 — the mutation-effectiveness and fused static∪dynamic
+    # protection paths, factored out of {CoverageCommand} to keep that command
+    # focused on dispatch. Mixed in, so each method runs in the command instance
+    # (using `@out` / `@err` / `@argv` / `collect_paths` / `determine_protection_exit`
+    # and the Protection + LanguageServer collaborators the command requires).
+    module CoverageMutation
+      private
+
+      # ADR-63 Tier 2 — the mutation-effectiveness deep dive. Builds the RBS
+      # environment + project pre-pass once (the warm loop), then re-analyses
+      # each target file's mutants against its clean baseline. Defaults to the
+      # git-changed `.rb` files; explicit paths override (and enable the
+      # whole-project opt-in, which is minutes).
+      def run_mutation_protection(options)
+        explicit = collect_paths(@argv, command_name: "coverage")
+        return CLI::EXIT_USAGE if explicit.nil?
+
+        target_files = explicit.empty? ? changed_ruby_files : explicit
+        if target_files.empty?
+          @out.puts("No changed Ruby files to measure — pass paths to measure explicitly.")
+          return 0
+        end
+
+        note_sampling(options)
+        return run_fused_protection(target_files, options) if options[:with_tests]
+
+        report = scan_mutation_protection(target_files, options)
+        MutationProtectionRenderer.new(out: @out).render(report, format: options.fetch(:format))
+        determine_protection_exit(report, options)
+      end
+
+      # A `--limit` sample makes the report an estimate (per-file ratios over a
+      # random N of the mutations). Say so on stderr — stdout stays clean for JSON.
+      def note_sampling(options)
+        return unless options[:limit]
+
+        @err.puts(
+          "coverage: sampling at most #{options[:limit]} mutations/file " \
+          "(seed #{options[:seed]}); ratios are estimates."
+        )
+      end
+
+      # ADR-70 — the fused static∪dynamic deep dive. The type pass is the ADR-63
+      # Tier 2 warm loop; each type-survivor is then run against the project's
+      # test suite (the runner hook). The suite MUST pass on clean code first, or
+      # "a mutant survived" is meaningless — abort with a clear message if not.
+      def run_fused_protection(paths, options)
+        configuration = Configuration.load(options.fetch(:config))
+        test_oracle = Protection::TestSuiteOracle.new(command: options.fetch(:test_command))
+        return suite_not_green_error(options) unless test_oracle.green?
+
+        context = LanguageServer::ProjectContext.new(configuration: configuration)
+        scanner = Protection::MutationScanner.new(
+          configuration: configuration, environment: context.environment, project_scan: context.project_scan,
+          limit: options[:limit], seed: options[:seed],
+          site_selector: options[:include_dynamic] ? :all : :biteable
+        )
+        accumulator = FusedProtectionAccumulator.new
+        paths.each { |path| scan_fused_one(path, scanner, accumulator, test_oracle, configuration) }
+        report = accumulator.to_report
+        FusedProtectionRenderer.new(out: @out).render(report, format: options.fetch(:format))
+        determine_protection_exit(report, options)
+      end
+
+      def scan_fused_one(path, scanner, accumulator, test_oracle, configuration)
+        source = File.read(path)
+        parse_result = Prism.parse(source, filepath: path, version: configuration.target_ruby)
+        if parse_result.errors.any?
+          accumulator.record_parse_error(path, parse_result.errors)
+          return
+        end
+
+        accumulator.absorb(scanner.scan_file_fused(path, source: source, test_oracle: test_oracle))
+      end
+
+      def suite_not_green_error(options)
+        @err.puts(
+          "coverage: the test suite must pass on clean code to measure test protection " \
+          "(ran: #{options.fetch(:test_command).join(' ')})"
+        )
+        @err.puts(
+          "  the command must exit 0 on a clean tree. A non-zero exit on otherwise-passing " \
+          "tests also trips this — e.g. a SimpleCov coverage floor on a file-scoped run; " \
+          "point --test-command at a plain pass/fail runner."
+        )
+        1
+      end
+
+      def scan_mutation_protection(paths, options)
+        configuration = Configuration.load(options.fetch(:config))
+        context = LanguageServer::ProjectContext.new(configuration: configuration)
+        scanner = Protection::MutationScanner.new(
+          configuration: configuration, environment: context.environment, project_scan: context.project_scan,
+          limit: options[:limit], seed: options[:seed]
+        )
+        accumulator = MutationProtectionAccumulator.new
+
+        paths.each { |path| scan_mutation_one(path, scanner, accumulator, configuration) }
+        accumulator.to_report
+      end
+
+      def scan_mutation_one(path, scanner, accumulator, configuration)
+        source = File.read(path)
+        parse_result = Prism.parse(source, filepath: path, version: configuration.target_ruby)
+        if parse_result.errors.any?
+          accumulator.record_parse_error(path, parse_result.errors)
+          return
+        end
+
+        accumulator.absorb(scanner.scan_file(path, source: source))
+      end
+
+      # The git-changed (modified / added / untracked) `.rb` files that exist on
+      # disk — the default Tier 2 scope. Returns [] outside a git work tree or
+      # when git is unavailable; the caller then reports "nothing to measure".
+      def changed_ruby_files
+        output = git_status_porcelain
+        return [] if output.nil?
+
+        output.each_line.filter_map { |line| changed_path(line) }.uniq.select { |p| File.file?(p) }
+      end
+
+      # Parse one `git status --porcelain` line (`XY <path>`, or `R  old -> new`)
+      # into a candidate `.rb` path, or nil.
+      def changed_path(line)
+        path = line[3..]&.chomp
+        return nil if path.nil? || path.empty?
+
+        path = path.split(" -> ", 2).last if path.include?(" -> ")
+        path = path.delete_prefix('"').delete_suffix('"')
+        path.end_with?(".rb") ? path : nil
+      end
+
+      def git_status_porcelain
+        output = IO.popen(%w[git status --porcelain --untracked-files=all], err: File::NULL, &:read)
+        $CHILD_STATUS&.success? ? output : nil
+      rescue SystemCallError
+        nil
+      end
+    end
+  end
+end

data/lib/rigor/cli/coverage_scan.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../configuration"
+require_relative "../environment"
+require_relative "../inference/precision_scanner"
+require_relative "../scope"
+require_relative "coverage_report"
+
+module Rigor
+  class CLI
+    # Shared type-precision scan behind both `rigor coverage` (the
+    # dedicated command) and `rigor check --coverage` (the in-run
+    # coverage block). Walks each file's AST, types every expression via
+    # `Scope#type_of`, and accumulates the precision-tier breakdown into a
+    # `CoverageReport`. Extracted so the two surfaces stay byte-identical
+    # on the same file set.
+    module CoverageScan
+      module_function
+
+      # @param files [Array<String>] explicit `.rb` file paths to scan.
+      # @param configuration [Rigor::Configuration]
+      # @return [Rigor::CLI::CoverageReport]
+      def precision_report(files:, configuration:)
+        scope = Scope.empty(environment: project_environment(configuration))
+        scanner = Inference::PrecisionScanner.new(scope: scope)
+        accumulator = CoverageAccumulator.new
+        files.each { |path| scan_into(path, scanner, accumulator, configuration) }
+        accumulator.to_report(files, {})
+      end
+
+      def project_environment(configuration)
+        Environment.for_project(
+          libraries: configuration.libraries,
+          signature_paths: configuration.signature_paths
+        )
+      end
+
+      # Parses one file and feeds the scan result (or a parse-error
+      # record) into `accumulator`. `scanner` / `accumulator` are a
+      # matched pair — a `PrecisionScanner` + `CoverageAccumulator`, or a
+      # `ProtectionScanner` + `ProtectionAccumulator` — both of which
+      # respond to `scan(node)` and `absorb(path, result)`.
+      def scan_into(path, scanner, accumulator, configuration)
+        source = File.read(path)
+        parse_result = Prism.parse(source, filepath: path, version: configuration.target_ruby)
+        if parse_result.errors.any?
+          accumulator.record_parse_error(path, parse_result.errors)
+          return
+        end
+
+        accumulator.absorb(path, scanner.scan(parse_result.value))
+      end
+    end
+  end
+end

data/lib/rigor/cli/explain_command.rb

@@ -95,6 +95,7 @@ module Rigor
         render_section("Fires when:", entry.fires_when)
         render_section("Does not fire when:", entry.does_not_fire_when)
         @out.puts("Suppression: #{entry.suppression}")
+        @out.puts("Documentation: #{entry.documentation_url}")
         @out.puts("Since: rigor #{entry.since}")
       end
 
@@ -109,6 +110,7 @@ module Rigor
         @out.puts("Authored severity: :#{entry.severity_authored}")
         profile_table = entry.severity_by_profile.map { |profile, sev| "#{profile} → :#{sev}" }.join(", ")
         @out.puts("Severity by profile: #{profile_table}")
+        @out.puts("Evidence tier: #{entry.evidence_tier || 'n/a (informational)'}")
         @out.puts("")
       end
 

data/lib/rigor/cli/fused_protection_renderer.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Rigor
+  class CLI
+    # Renders a {FusedProtectionReport} (ADR-70) as text or JSON. The text form
+    # leads with the fused protected ratio (caught by *either* a type or a test),
+    # splits it into the two axes, then lists the unprotected breakages ("add a
+    # type or a test here") and the least-protected files. The framing is always
+    # *where to add protection*, never "your code is broken".
+    class FusedProtectionRenderer
+      TOP_CALLS = 15
+      TOP_FILES = 10
+
+      def initialize(out:)
+        @out = out
+      end
+
+      def render(report, format:)
+        format == "json" ? render_json(report) : render_text(report)
+      end
+
+      private
+
+      def render_json(report)
+        @out.puts(JSON.pretty_generate(report.to_h))
+      end
+
+      def render_text(report)
+        pct = (report.ratio * 100).round(1)
+        @out.puts "Fused protection (static type ∪ dynamic test)"
+        @out.puts "  protected: #{report.protected_total} / #{report.grand_total}  (#{pct}%)"
+        @out.puts "    by type:  #{report.total_type_killed}"
+        @out.puts "    by test:  #{report.total_test_killed}  (type-survivors a test caught)"
+        @out.puts "  unprotected: #{report.total_unprotected}  (neither — add a type or a test)"
+        render_unprotected(report)
+        render_files(report)
+      end
+
+      def render_unprotected(report)
+        unprotected = report.unprotected
+        return if unprotected.empty?
+
+        @out.puts "\nAdd protection here — breakages neither a type nor a test caught:"
+        unprotected.first(TOP_CALLS).each do |call|
+          @out.puts format("  %<count>-5d #%<method>s   e.g. %<sites>s",
+                           count: call.count, method: call.method_name, sites: call.examples.join("  "))
+        end
+        @out.puts "  (#{unprotected.size - TOP_CALLS} more)" if unprotected.size > TOP_CALLS
+      end
+
+      def render_files(report)
+        worst = report.files.reject { |f| f.unprotected.zero? }.sort_by(&:ratio).first(TOP_FILES)
+        return if worst.empty?
+
+        @out.puts "\nLeast-protected files:"
+        worst.each do |file|
+          total = file.type_killed + file.test_killed + file.unprotected
+          protected_n = file.type_killed + file.test_killed
+          @out.puts format("  %<pct>5.1f%%  %<path>s  (%<n>d/%<total>d protected)",
+                           pct: file.ratio * 100, path: file.path, n: protected_n, total: total)
+        end
+      end
+    end
+  end
+end

data/lib/rigor/cli/fused_protection_report.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Rigor
+  class CLI
+    # ADR-70 — aggregates per-file {Protection::MutationScanner::FusedFileResult}
+    # into a project-level **fused** protection report: how many type-visible
+    # breakages were caught by the type checker, how many of the *type-survivors*
+    # were caught by the test suite, and which sites neither axis caught — the
+    # ranked "add a type OR a test here" list.
+    #
+    # Framing (ADR-63 / ADR-62 Criterion A, extended): the payload is the
+    # **attribution** — which protection axis is missing — never raw survival.
+    # An unprotected site is "add protection here", never "your code is broken".
+    FusedFileProtection = Data.define(:path, :type_killed, :test_killed, :unprotected, :ratio)
+    UnprotectedBreakage = Data.define(:method_name, :count, :examples)
+
+    FusedProtectionReport = Data.define(:files, :unprotected, :parse_errors) do
+      def total_type_killed = files.sum(&:type_killed)
+      def total_test_killed = files.sum(&:test_killed)
+      def total_unprotected = files.sum(&:unprotected)
+      def grand_total = total_type_killed + total_test_killed + total_unprotected
+      def protected_total = total_type_killed + total_test_killed
+      def ratio = grand_total.zero? ? 1.0 : protected_total.to_f / grand_total
+
+      def to_h
+        {
+          "mode" => "protection-fused",
+          "type_killed" => total_type_killed,
+          "test_killed" => total_test_killed,
+          "unprotected" => total_unprotected,
+          "protected_ratio" => ratio.round(4),
+          "files" => files.map do |f|
+            { "path" => f.path, "type_killed" => f.type_killed, "test_killed" => f.test_killed,
+              "unprotected" => f.unprotected, "ratio" => f.ratio.round(4) }
+          end,
+          "add_protection_here" => unprotected.map do |m|
+            { "method" => m.method_name, "count" => m.count, "examples" => m.examples }
+          end,
+          "parse_errors" => parse_errors
+        }
+      end
+    end
+
+    class FusedProtectionAccumulator
+      def initialize
+        @files = []
+        @unprotected = Hash.new { |h, k| h[k] = { count: 0, examples: [] } }
+        @parse_errors = []
+      end
+
+      def absorb(file_result)
+        @files << FusedFileProtection.new(
+          path: file_result.path, type_killed: file_result.type_killed,
+          test_killed: file_result.test_killed, unprotected: file_result.unprotected,
+          ratio: file_result.ratio
+        )
+        file_result.sites.each do |site|
+          bucket = @unprotected[site.method_name]
+          bucket[:count] += 1
+          bucket[:examples] << "#{file_result.path}:#{site.line}" if bucket[:examples].size < 3
+        end
+      end
+
+      def record_parse_error(path, errors)
+        @parse_errors << { "path" => path, "errors" => errors.size }
+      end
+
+      def to_report
+        unprotected = @unprotected
+                      .map { |m, v| UnprotectedBreakage.new(method_name: m, count: v[:count], examples: v[:examples]) }
+                      .sort_by { |m| [-m.count, m.method_name] }
+        FusedProtectionReport.new(files: @files, unprotected: unprotected, parse_errors: @parse_errors)
+      end
+    end
+  end
+end

data/lib/rigor/cli/lsp_command.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "command"
+require_relative "options"
 
 require "optionparser"
 
@@ -8,11 +9,8 @@ module Rigor
   class CLI
     # Executes the `rigor lsp` command.
     #
+    # Starts a long-running LSP server over stdio (JSON-RPC).
     # See `docs/design/20260517-language-server.md` for the design.
-    # Slice 1 (this commit) ships the CLI subcommand entry point.
-    # The actual stdio JSON-RPC reader / writer is queued for slice 2;
-    # invoking `rigor lsp` at slice 1 returns immediately after
-    # validating the transport flag.
     class LspCommand < Command
       USAGE = "Usage: rigor lsp [options]"
 
@@ -109,9 +107,7 @@ module Rigor
           opts.on("--log=PATH", "Write LSP wire log + server debug to PATH (default: stderr)") do |value|
             options[:log] = value
           end
-          opts.on("--config=PATH", "Path to the Rigor configuration file") do |value|
-            options[:config] = value
-          end
+          Options.add_config(opts, options)
         end
         parser.parse!(@argv)
         options