rigortype 0.3.3 → 0.3.5

data/lib/rigor/cli/effects_explain_renderer.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "renderable"
+
+module Rigor
+  class CLI
+    # Prints what `rigor effects explain` found: for a `reach:` change, the shortest edge path from the
+    # entry point to the origin that introduced the label; for a `methods:` change, the origin itself
+    # (ADR-103 WD7).
+    #
+    #   reach:
+    #     OrdersController#create → OrderService#place → PaymentGateway#charge → Net::HTTP.get [io.net.http]
+    #   methods:
+    #     PaymentGateway#charge [io.net.http] ← catalogue:Net::HTTP.get
+    #
+    # A `methods:` change has no path to walk — the label came from this method's own body — so what
+    # explains it is the origin: the catalogue row or language construct, and which of the two it was.
+    # Origins are line-free by design (a summary must be stable under a line move), so no position is
+    # printed; call sites are per-run data the report carries.
+    class EffectsExplainRenderer
+      include Renderable
+
+      # One printed explanation. `path` is empty for a `methods:` row, whose explanation is the origin.
+      Row = Data.define(:table, :symbol, :label, :path, :origin)
+
+      def initialize(out:)
+        @out = out
+      end
+
+      private
+
+      def render_text(rows)
+        if rows.empty?
+          @out.puts("Nothing to explain.")
+          return
+        end
+
+        rows.group_by(&:table).each do |table, group|
+          @out.puts("#{table}:")
+          group.each { |row| @out.puts("  #{render_row(row)}") }
+        end
+      end
+
+      def render_row(row)
+        return "#{row.path.join(' → ')} [#{row.label}]" unless row.path.empty?
+
+        origin = row.origin ? " ← #{row.origin}" : ""
+        "#{row.symbol} [#{row.label}]#{origin}"
+      end
+
+      def render_json(rows)
+        @out.puts(JSON.pretty_generate(
+                    "paths" => rows.map do |row|
+                      {
+                        "table" => row.table,
+                        "symbol" => row.symbol,
+                        "label" => row.label,
+                        "path" => row.path,
+                        "origin" => row.origin
+                      }
+                    end
+                  ))
+      end
+    end
+  end
+end

data/lib/rigor/cli/effects_renderer.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "renderable"
+
+module Rigor
+  class CLI
+    # Prints an {EffectsReport}. Text is the review surface; JSON is what a bot reads.
+    #
+    # The text form says three things per method and nothing else: what it is proven to do, what a source
+    # Rigor trusts merely *claims* it does (`≤`, the declared lane), and whether the list is complete. The
+    # `…?` suffix is the exhaustiveness bit — "these effects, and possibly more" — and the indented lines
+    # under it are the closed-enum causes behind it. Deliberately not a diagnostic format: no severities,
+    # no positions, no exit-code weight.
+    class EffectsRenderer
+      include Renderable
+
+      def initialize(out:, why: false)
+        @out = out
+        @why = why
+      end
+
+      private
+
+      # The reason block is **collapsed to a count** by default (#434). It was 86.5 % of the bytes of a
+      # 31,191-line Redmine run, and it answers a question a reader asks about one row after reading many
+      # — so `--why` expands it, and the count is what stays on the line that made them curious.
+      def render_text(report)
+        report.rows.each do |row|
+          @out.puts("#{row.key}: [#{row.effects.join(', ')}]#{declared(row)}#{hedge(row)}")
+          next unless @why
+
+          row.causes.each { |cause, detail| @out.puts("    #{cause}#{" (#{detail})" if detail}") }
+          row.attribution.each { |origin, labels| @out.puts("    #{origin} → [#{labels.join(', ')}]") }
+        end
+        render_footer(report.totals)
+      end
+
+      def hedge(row)
+        return "" if row.exhaustive?
+        return " …?" if @why || row.causes.empty?
+
+        " …? (#{row.causes.length} #{row.causes.length == 1 ? 'reason' : 'reasons'}, --why)"
+      end
+
+      # The footer a 31,191-line report never had, and the reason it counts the two lanes apart: a
+      # declared label can never fail a build (ADR-103 § WD17), so a reader who sees one total cannot tell
+      # which half of the report is a policy surface and which half is a record to review the diff of.
+      def render_footer(totals)
+        return if totals.nil?
+
+        @out.puts("──")
+        @out.puts("#{totals.printed} of #{totals.units} units printed#{omitted(totals)}")
+        @out.puts("#{totals.proven} carry a proven label · #{totals.declared} carry a declared (≤) one " \
+                  "· #{totals.exhaustive} are exhaustive")
+      end
+
+      # Two ways a row can be missing, counted apart because `--full` answers only one of them.
+      def omitted(totals)
+        parts = []
+        parts << "#{totals.omitted} omitted (--full)" if totals.omitted.positive?
+        parts << "#{totals.unselected} not selected" if totals.unselected.positive?
+        parts << "#{totals.truncated} cut by --limit" if totals.truncated.positive?
+        parts.empty? ? "" : "; #{parts.join(', ')}"
+      end
+
+      # `≤` is the lane's spelling everywhere in the model — an upper bound, not an observation — so the
+      # report writes it rather than inventing a second word for it.
+      def declared(row)
+        row.declared.empty? ? "" : " ≤ [#{row.declared.join(', ')}]"
+      end
+
+      def render_json(report)
+        payload = {
+          "methods" => report.rows.to_h do |row|
+            [row.key, {
+              "effects" => row.effects,
+              "declared" => row.declared,
+              "exhaustive" => row.exhaustive?,
+              "causes" => row.causes.map { |cause, detail| [cause, detail] },
+              "direct" => row.direct,
+              "attribution" => row.attribution
+            }]
+          end
+        }
+        payload["totals"] = report.totals.to_h.transform_keys(&:to_s) if report.totals
+        @out.puts(JSON.pretty_generate(payload))
+      end
+    end
+  end
+end

data/lib/rigor/cli/effects_report.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Rigor
+  class CLI
+    # The value `EffectsCommand` assembles and `EffectsRenderer` prints — one row per effect unit, already
+    # projected out of {Rigor::Effects::EffectTable} so the renderer never touches an engine value.
+    #
+    # Rows are sorted by key and every collection inside one is sorted, so two runs over the same tree
+    # print byte-identical output whether analysis ran sequentially or across the fork pool.
+    class EffectsReport < Data.define(:rows, :full, :totals)
+      # `totals:` defaults so a caller that builds a report by hand keeps working.
+      def initialize(totals: nil, **rest)
+        super
+      end
+
+      # One method's line in the report.
+      #
+      # `effects` is the transitive proven lane — this method's labels joined with every project method it
+      # reaches. `exhaustive` false reads "these effects, and possibly more", and `causes` says why.
+      # `direct` is what this method's own body contributed, per origin, which is the attributable half a
+      # snapshot records (#381).
+      #
+      # `declared` is the `≤` lane, transitive like `effects`: what a source Rigor trusts but did not
+      # verify *claims* this method reaches — today the project's `effects.attribution:` table (#385). It
+      # is printed apart from `effects` and never folded into it, because the two answer different
+      # questions: one is proven, the other is asserted. A declared label the proven lane already admits
+      # is dropped here, where output is rendered; the table keeps both lanes raw.
+      class Row < Data.define(:key, :effects, :declared, :exhaustive, :causes, :direct, :attribution)
+        # `attribution:` defaults so a caller that builds a row by hand keeps working.
+        def initialize(attribution: {}, **rest)
+          super
+        end
+
+        def exhaustive?
+          exhaustive
+        end
+
+        # The reading `--pure` selects and the default report omits: nothing proven beyond what every
+        # envelope tolerates, nothing claimed, and no "possibly more".
+        def pure?
+          exhaustive && declared.empty? && (effects - TRIVIAL).empty?
+        end
+
+        # `mutate.local` is mutation of objects the frame allocated and never let out, which every
+        # envelope tolerates — so a method proving only it is what `%a{pure}` means here.
+        TRIVIAL = ["mutate.local"].freeze
+        private_constant :TRIVIAL
+
+        def carries_label?(labels)
+          labels.any? { |label| (effects + declared).any? { |own| own == label || own.start_with?("#{label}.") } }
+        end
+      end
+
+      # The counts the footer prints and the JSON payload carries (#434). The two lanes are counted
+      # **separately** and deliberately: a declared label can never fail a build ([ADR-103](../adr/103-effect-labels.md)
+      # § WD17), and on a Rails application it is most of the mass — 709 `io.db.read` plus 644
+      # `io.db.write` on Redmine's 4,234 rows against zero of either proven. A single total tells a reader
+      # how big the report is; the split tells them which half is a policy surface and which half is a
+      # record whose diff they should be reviewing instead.
+      Totals = Data.define(:units, :printed, :omitted, :unselected, :proven, :declared, :exhaustive,
+                           :truncated)
+
+      # Builds a report from an effect table. `full:` keeps the rows the report otherwise omits — an
+      # exhaustive method proving nothing beyond `mutate.local`, which is the reading of `%a{pure}`.
+      #
+      # `scope:` selects which units are **printed** and never which are analysed (#439). A path argument
+      # used to narrow the analysis, and a summary is transitive over whatever was analysed, so the
+      # narrowed run answered `[] …?` for a method the whole-project run answered four labels for — with
+      # nothing distinguishing that from a method which genuinely does nothing. `sources:` is
+      # `Runner#effect_sources`, `{ "Class#m" => [path, …] }`, which is how a key is traced back to the
+      # file it was written in.
+      def self.build(table, full: false, sources: nil, scope: [], label: [], pure: false, limit: nil)
+        roots = normalize_scope(scope)
+        in_scope = table.filter_map do |entry|
+          row_for(entry) if roots.empty? || in_scope?(entry.key, sources, roots)
+        end
+        selected = in_scope.select { |row| keep?(row, full: full, label: label, pure: pure) }
+        new(rows: (limit ? selected.first(limit) : selected).freeze, full: full,
+            totals: totals_for(table, in_scope, selected, limit, query: pure || !label.empty?))
+      end
+
+      # What the default report drops, and why each is a separate question:
+      #
+      # - **`full:`** keeps a row the omission rule would drop. Two shapes qualify: a method proving
+      #   nothing beyond `mutate.local` and claiming nothing (the reading of `%a{pure}`), and a row with
+      #   no label in **either** lane, which is 35–38 % of a real application's rows and says literally
+      #   nothing — it exists only to record that something was unresolved, which the footer counts.
+      # - **`pure:`** is the complement of the first: exactly the rows the default omits for being
+      #   provably harmless, which is the set worth annotating and which nothing could ask for (#457).
+      # - **`label:`** is the question chapter 19 opens with. It matches **either** lane, because "which
+      #   controllers reach the network" is a question about the code and not about which lane knows it;
+      #   the row's own rendering keeps the two apart.
+      def self.keep?(row, full:, label:, pure:)
+        return row.pure? if pure
+        return row.carries_label?(label) unless label.empty?
+        return true if full
+
+        !row.pure? && !(row.effects.empty? && row.declared.empty?)
+      end
+      private_class_method :keep?
+
+      # Two ways a row can be missing, and only one of them `--full` answers: the **omission rule** drops
+      # a row that says nothing, and a **filter** — a path, `--label`, `--pure` — drops one that did not
+      # match. Telling a `--label io.net` reader that 4,678 more are behind `--full` would be false, so
+      # the two are counted apart.
+      def self.totals_for(table, in_scope, selected, limit, query:)
+        omitted = query ? 0 : in_scope.length - selected.length
+        Totals.new(
+          units: table.size, printed: limit ? [selected.length, limit].min : selected.length,
+          omitted: omitted, unselected: table.size - selected.length - omitted,
+          proven: selected.count { |row| !row.effects.empty? },
+          declared: selected.count { |row| !row.declared.empty? },
+          exhaustive: selected.count(&:exhaustive?),
+          truncated: limit ? [selected.length - limit, 0].max : 0
+        )
+      end
+      private_class_method :totals_for
+
+      # A path argument may name a file or a directory, and either may be written relative or absolute —
+      # so both sides are expanded and a directory matches by prefix. Deliberately not the `reach:` glob
+      # syntax: this is the argument a shell just tab-completed, and `rigor effects app/models` meaning
+      # "that directory" is the only reading a reader would guess.
+      def self.normalize_scope(scope)
+        Array(scope).map { |path| File.expand_path(path.to_s.chomp("/")) }.freeze
+      end
+      private_class_method :normalize_scope
+
+      def self.in_scope?(key, sources, roots)
+        paths = sources && sources[key]
+        return false if paths.nil? || paths.empty?
+
+        paths.any? do |path|
+          absolute = File.expand_path(path)
+          roots.any? { |root| absolute == root || absolute.start_with?("#{root}/") }
+        end
+      end
+      private_class_method :in_scope?
+
+      def self.row_for(entry)
+        Row.new(
+          key: entry.key,
+          effects: entry.proven.to_a,
+          declared: entry.rendered_declared.to_a,
+          exhaustive: entry.exhaustive?,
+          causes: entry.causes,
+          direct: entry.direct.bundles.to_h { |origin, labels| [origin.to_s, labels.to_a] }.freeze,
+          # The declared lane's provenance (#434). A *discharging* plugin row leaves no cause line by
+          # design — WD6: a row the engine bundles is trusted, so it does not taint — which is why
+          # `plugin-attribution` appeared zero times in a whole Redmine run while 1,320 rows carried a
+          # `≤` clause. The origins are where the answer actually lives, and this is the direct half; a
+          # label that arrived transitively is `rigor effects explain`'s question.
+          attribution: entry.direct.declared_bundles.to_h { |origin, labels| [origin.to_s, labels.to_a] }
+                            .freeze
+        )
+      end
+      private_class_method :row_for
+
+      def empty?
+        rows.empty?
+      end
+    end
+  end
+end

data/lib/rigor/cli/effects_snapshot_command.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require "did_you_mean"
+require "optionparser"
+
+require_relative "../analysis/runner"
+require_relative "../cache/store"
+require_relative "../configuration"
+require_relative "../effects/discharge"
+require_relative "../effects/entry_points"
+require_relative "../effects/path_finder"
+require_relative "../effects/snapshot"
+require_relative "../effects/snapshot_diff"
+require_relative "command"
+require_relative "effects_diff_renderer"
+require_relative "effects_explain_renderer"
+require_relative "options"
+
+module Rigor
+  class CLI
+    # ADR-103 WD7 — the snapshot verbs of `rigor effects`: `update`, `check`, `diff` and `explain`.
+    #
+    #   rigor effects update                  # write .rigor-effects.yml; commit it
+    #   rigor effects check                   # 0 fresh, 1 drift — the CI gate
+    #   rigor effects diff --baseline PATH    # the same comparison, never gating
+    #   rigor effects explain --symbol KEY    # the shortest edge path behind a reach change
+    #
+    # None of them emits a diagnostic or enters `rigor check`'s stream: drift between two observations by
+    # the same tool is 100 % precise, and whether it *matters* is the reviewer's judgment — which is
+    # exactly what makes it a review artefact rather than a finding
+    # ([ADR-102](../adr/102-unused-code-reachability-report.md)).
+    #
+    # **The verbs take no paths.** The report does (`rigor effects lib/foo.rb`), because a report is a
+    # view; a snapshot is a record of the whole project, and one written over a subset would read as a
+    # project where every other method vanished. The analysed set is always the configured `paths:`.
+    class EffectsSnapshotCommand < Command
+      VERBS = %w[update check diff explain].freeze
+
+      FORMATS = %w[text json].freeze
+      private_constant :FORMATS
+
+      # The verbs that read a committed record, and so accept `--baseline PATH` —
+      # `--baseline <(git show origin/main:.rigor-effects.yml)` is the bot form.
+      COMPARING_VERBS = %w[check diff explain].freeze
+      private_constant :COMPARING_VERBS
+
+      def initialize(argv:, verb:, out: $stdout, err: $stderr)
+        super(argv: argv, out: out, err: err)
+        @verb = verb
+      end
+
+      # @return [Integer] 0 fresh / written, 1 on drift under `check`, 64 on a usage error.
+      def run
+        options = parse_options
+        return usage_error("unsupported format: #{options.fetch(:format)}") unless
+          FORMATS.include?(options[:format])
+        return usage_error("rigor effects #{@verb} takes no paths; it records the configured paths:") unless
+          @argv.empty?
+
+        execute(options)
+      rescue OptionParser::ParseError => e
+        usage_error(e.message)
+      end
+
+      private
+
+      def execute(options)
+        configuration = Configuration.load(options.fetch(:config)).with_effects_enabled
+        current = build_snapshot(configuration, full: options.fetch(:full))
+        return write(configuration, current) if @verb == "update"
+
+        compare(configuration, current, options)
+      end
+
+      # ---- update -------------------------------------------------
+
+      # Always writes — there is no generate / regenerate split, because a snapshot has no "already
+      # exists" hazard: it records observations, so overwriting it is the whole point of running it.
+      def write(configuration, snapshot)
+        path = configuration.effects_snapshot_path
+        File.write(path, snapshot.to_yaml)
+        @err.puts("rigor: wrote #{path} (#{snapshot.methods.size} method(s), #{snapshot.reach.size} reach entr" \
+                  "#{snapshot.reach.size == 1 ? 'y' : 'ies'})")
+        # #436 — the note names what to write, not only what is missing: the same per-project preset
+        # enumeration the unregistered-preset error uses, so the two can never disagree about which
+        # names this project's plugin set makes available.
+        if configuration.effects_snapshot_reach.empty?
+          @err.puts("rigor: note — `effects.snapshot.reach:` is empty, so the snapshot records `methods:` " \
+                    "only — the direct half. Name your entry points to record what they cause: " \
+                    "#{Effects::EntryPoints.availability}. The written file carries the same hint.")
+        end
+        0
+      end
+
+      # ---- check / diff / explain ---------------------------------
+
+      def compare(configuration, current, options)
+        path = options.fetch(:baseline) || configuration.effects_snapshot_path
+        recorded = load_recorded(path)
+        return CLI::EXIT_USAGE if recorded == :error
+
+        discharge = options.fetch(:no_tolerated) ? Effects::Discharge.none : effect_discharge(configuration)
+        diff = Effects::SnapshotDiff.compare(
+          recorded: recorded, current: current,
+          tolerated: options.fetch(:no_tolerated) ? [] : configuration.effects_tolerated,
+          gate: configuration.effects_snapshot_gate,
+          strict_tolerated: options.fetch(:strict_tolerated),
+          undischarged: Effects::Snapshot.undischarged_index(
+            snapshot: current, table: @table, discharge: discharge
+          )
+        )
+        return explain(diff, options) if @verb == "explain"
+
+        EffectsDiffRenderer.new(out: @out, path: path).render(diff, format: options.fetch(:format))
+        @verb == "check" && diff.drift? ? 1 : 0
+      end
+
+      def effect_discharge(configuration)
+        Effects::Discharge.new(configuration.effects_tolerated)
+      end
+
+      # A missing snapshot is drift with a routed message, not an error: it is the state every project is
+      # in before its first `update`, and the fix is one command away.
+      def load_recorded(path)
+        return nil unless File.exist?(path)
+
+        Effects::Snapshot.load(path)
+      rescue Effects::Snapshot::ParseError => e
+        @err.puts("rigor: effect snapshot load failed: #{path}: #{e.message}")
+        :error
+      end
+
+      # ---- explain ------------------------------------------------
+
+      def explain(diff, options)
+        rows = options.fetch(:symbol) ? rows_for_symbol(options.fetch(:symbol)) : rows_for_changes(diff)
+        return CLI::EXIT_USAGE if rows == :unknown
+
+        EffectsExplainRenderer.new(out: @out).render(rows, format: options.fetch(:format))
+        0
+      end
+
+      # A misspelled `--symbol` used to print `Nothing to explain.` and exit 0, which is exactly what a
+      # method with no effects prints — so a typo and a real answer were indistinguishable, and a script
+      # could not tell them apart at all (#435). It is a usage error now, with the nearest key offered:
+      # the key set is right there, and a method key is long enough to get wrong.
+      def rows_for_symbol(symbol)
+        entry = @table[symbol]
+        if entry.nil?
+          @err.puts("rigor: no effect unit named #{symbol}#{suggestion(symbol)}")
+          return :unknown
+        end
+
+        reach_rows(symbol, entry.proven.to_a) + method_rows(symbol, entry.direct.proven.to_a)
+      end
+
+      def suggestion(symbol)
+        nearest = ::DidYouMean::SpellChecker.new(dictionary: @table.keys).correct(symbol).first
+        nearest ? " — did you mean #{nearest}?" : ""
+      end
+
+      # Every label a change introduced, explained once: a `reach:` change gets its shortest edge path, a
+      # `methods:` change gets the origin in the method's own body.
+      def rows_for_changes(diff)
+        diff.events.flat_map do |event|
+          labels = labels_of(event)
+          next [] if labels.empty?
+
+          event.table == "reach" ? reach_rows(event.symbol, labels) : method_rows(event.symbol, labels)
+        end.uniq
+      end
+
+      def labels_of(event)
+        return [event.label] if event.label
+        return [] unless event.category == Effects::SnapshotDiff::SYMBOL_ADDED
+
+        entry = @table[event.symbol]
+        entry ? entry.proven.to_a : []
+      end
+
+      def reach_rows(symbol, labels)
+        labels.filter_map do |label|
+          path = Effects::PathFinder.shortest(@table, symbol: symbol, label: label)
+          next if path.nil?
+
+          EffectsExplainRenderer::Row.new(table: "reach", symbol: symbol, label: label,
+                                          path: path.to_a, origin: path.origin)
+        end
+      end
+
+      def method_rows(symbol, labels)
+        entry = @table[symbol]
+        return [] if entry.nil?
+
+        labels.filter_map do |label|
+          origin = entry.direct.bundles.find { |_origin, set| set.include?(label) }&.first
+          next if origin.nil?
+
+          EffectsExplainRenderer::Row.new(table: "methods", symbol: symbol, label: label,
+                                          path: [].freeze, origin: origin.to_s)
+        end
+      end
+
+      # ---- the run ------------------------------------------------
+
+      # Same run the report takes: collection forced on for this invocation, sequential, and going through
+      # the ADR-45 whole-run result cache like `rigor check` — the diagnostics entry plus the #382 effects
+      # sidecar keyed beside it, so `rigor effects check` after `rigor check` under a configured `effects:`
+      # block is a warm hit plus the fixpoint.
+      def build_snapshot(configuration, full:)
+        runner = Analysis::Runner.new(
+          configuration: configuration,
+          cache_store: Cache::Store.new(root: configuration.cache_path),
+          collect_stats: false,
+          workers: 0
+        )
+        runner.run(configuration.paths)
+        @table = runner.effect_table
+        Effects::Snapshot.build(
+          table: @table, configuration: configuration, sources: runner.effect_sources, full: full,
+          registry: Effects::Registry.for_configuration(configuration,
+                                                        plugin_facts: runner.effect_plugin_facts)
+        )
+      end
+
+      # ---- options ------------------------------------------------
+
+      def parse_options
+        options = { config: nil, format: "text", full: false, baseline: nil, symbol: nil,
+                    strict_tolerated: false, no_tolerated: false }
+        OptionParser.new do |opts|
+          opts.banner = "Usage: rigor effects #{@verb} [options]"
+          Options.add_config(opts, options)
+          add_common_options(opts, options)
+          add_comparison_options(opts, options) if COMPARING_VERBS.include?(@verb)
+          if @verb == "explain"
+            opts.on("--symbol=KEY", "Explain this unit instead of the changed ones") do |value|
+              options[:symbol] = value
+            end
+          end
+        end.parse!(@argv)
+        options
+      end
+
+      # The policy switches are accepted by every verb, `update` included, and there they are deliberately
+      # inert: the record is **undischarged**, so `update --no-tolerated-effects` and `update` write
+      # byte-identical files. A flag that changed the record would make the file a function of policy and
+      # a policy change indistinguishable from a code change.
+      def add_common_options(opts, options)
+        opts.on("--format=FORMAT", "Output format: text (default) or json") { |value| options[:format] = value }
+        opts.on("--full", "Record every method, including the omitted trivial and synthesised ones") do
+          options[:full] = true
+        end
+        opts.on("--strict-tolerated", "Fail the gate on tolerated changes too (check / diff)") do
+          options[:strict_tolerated] = true
+        end
+        opts.on("--no-tolerated-effects", "Judge as if effects.tolerated: were empty (check / diff)") do
+          options[:no_tolerated] = true
+        end
+      end
+
+      def add_comparison_options(opts, options)
+        opts.on("--baseline=PATH", "Compare against PATH instead of effects.snapshot.path") do |value|
+          options[:baseline] = value
+        end
+      end
+
+      def usage_error(message)
+        @err.puts(message)
+        @err.puts("Usage: rigor effects #{@verb} [options]")
+        CLI::EXIT_USAGE
+      end
+    end
+  end
+end