ibex 0.2.0 → 0.4.0

data/lib/ibex/impact/propagation.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require_relative "graph"
+
+module Ibex
+  module Impact
+    # One shortest witness for a symbol reached by dependency propagation.
+    class Node
+      attr_reader :symbol #: Integer
+      attr_reader :distance #: Integer
+      attr_reader :witness #: Array[Edge]
+      attr_reader :kind #: Symbol
+      attr_reader :component #: Array[Integer]
+
+      # @rbs (symbol: Integer, distance: Integer, witness: Array[Edge], kind: Symbol, component: Array[Integer]) -> void
+      def initialize(symbol:, distance:, witness:, kind:, component:)
+        @symbol = symbol
+        @distance = distance
+        @witness = witness.freeze
+        @kind = kind
+        @component = component.freeze
+        freeze
+      end
+    end
+
+    # Performs deterministic forward propagation over a dependency graph.
+    class Propagation
+      # @rbs @graph: Graph
+      # @rbs (Graph graph) -> void
+      def initialize(graph)
+        @graph = graph
+      end
+
+      # @rbs (Array[Integer] seeds, Symbol kind, ?max_depth: Integer?) -> Hash[Integer, Node]
+      def propagate(seeds, kind = :all, max_depth: nil)
+        validate_depth(max_depth)
+        selected = normalize_seeds(seeds)
+        adjacency = @graph.adjacency(kind)
+        components = Analysis::Digraph.send(:strongly_connected_components, adjacency)
+        component_for = component_index(components, adjacency.length)
+        component_edges = component_adjacency(adjacency, component_for, components.length)
+        component_nodes = traverse_components(selected, component_for, component_edges, max_depth)
+        witnesses = symbol_witnesses(selected, adjacency, kind)
+        build_nodes(component_nodes, components, kind, witnesses)
+      end
+
+      alias call propagate
+
+      private
+
+      # @rbs (Integer?) -> void
+      def validate_depth(max_depth)
+        return if max_depth.nil? || (max_depth.is_a?(Integer) && max_depth >= 0)
+
+        raise ArgumentError, "impact depth must be a non-negative integer"
+      end
+
+      # @rbs (Array[Integer]) -> Array[Integer]
+      def normalize_seeds(seeds)
+        seeds.uniq.sort.each do |id|
+          unless @graph.grammar.symbol_by_id(id)
+            raise ArgumentError,
+                  "impact seed #{id.inspect} is not a grammar symbol"
+          end
+        end
+      end
+
+      # @rbs (Array[Array[Integer]], Integer) -> Array[Integer]
+      def component_index(components, size)
+        result = Array.new(size, 0) #: Array[Integer]
+        components.each_with_index { |members, id| members.each { |member| result[member] = id } }
+        result
+      end
+
+      # @rbs (Array[Array[Integer]], Array[Integer], Integer) -> Array[Array[Integer]]
+      def component_adjacency(adjacency, component_for, component_count)
+        result = Array.new(component_count) { [] } #: Array[Array[Integer]]
+        adjacency.each_with_index do |successors, source|
+          source_component = component_for.fetch(source)
+          successors.each do |target|
+            target_component = component_for.fetch(target)
+            next if source_component == target_component
+
+            result[source_component] << target_component
+          end
+        end
+        result.each do |successors|
+          successors.uniq!
+          successors.sort!
+        end
+        result
+      end
+
+      # @rbs (Array[Integer], Array[Integer], Array[Array[Integer]], Integer?) -> Hash[Integer, Integer]
+      def traverse_components(seeds, component_for, component_edges, max_depth)
+        queue = seeds.uniq.sort.map do |seed|
+          [component_for.fetch(seed), 0]
+        end #: Array[[Integer, Integer]]
+        result = {} #: Hash[Integer, Integer]
+        until queue.empty?
+          component, distance = queue.shift
+          next if result.key?(component)
+          next if max_depth && distance > max_depth
+
+          result[component] = distance
+          component_edges.fetch(component).each do |target|
+            queue << [target, distance + 1]
+          end
+        end
+        result
+      end
+
+      # @rbs (Array[Integer], Array[Array[Integer]], Symbol) -> Hash[Integer, Array[Edge]]
+      def symbol_witnesses(seeds, adjacency, kind)
+        edges = @graph.edges(kind).group_by { |edge| [edge.source, edge.target] }
+        queue = seeds.uniq.sort.map { |seed| [seed, []] } #: Array[[Integer, Array[Edge]]]
+        result = {} #: Hash[Integer, Array[Edge]]
+        until queue.empty?
+          symbol, witness = queue.shift
+          next if result.key?(symbol)
+
+          result[symbol] = witness
+          adjacency.fetch(symbol).each do |target|
+            edge = edges.fetch([symbol, target]).fetch(0)
+            queue << [target, witness + [edge]]
+          end
+        end
+        result
+      end
+
+      # @rbs (Hash[Integer, Integer], Array[Array[Integer]], Symbol, Hash[Integer, Array[Edge]]) -> Hash[Integer, Node]
+      def build_nodes(component_nodes, components, kind, witnesses)
+        result = {} #: Hash[Integer, Node]
+        component_nodes.each do |component, distance|
+          members = components.fetch(component).sort
+          members.each do |symbol|
+            result[symbol] = Node.new(
+              symbol: symbol, distance: distance, witness: witnesses.fetch(symbol), kind: kind, component: members
+            )
+          end
+        end
+        result.sort.to_h
+      end
+    end
+  end
+end

data/lib/ibex/impact/report.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "digest"
+require_relative "../ir/serialize"
+
+module Ibex
+  module Impact
+    # Builds the deterministic public impact-v1 document.
+    class Report
+      # @rbs @mode: String
+      # @rbs @algorithm: String
+      # @rbs @grammar: IR::Grammar
+      # @rbs @before: IR::Automaton?
+      # @rbs @after: IR::Automaton?
+      # @rbs @seeds: Array[Hash[Symbol, Object?]]
+      # @rbs @nodes: Hash[Integer, Node]
+      # @rbs @symbol_kinds: Hash[Integer, Array[String]]
+      # @rbs @set_changes: Hash[String, Hash[Symbol, Object?]]
+      # @rbs @metadata_names: Array[String]
+      # @rbs @automaton: Hash[Symbol, Object?]
+      # @rbs @actions: Array[Hash[Symbol, Object?]]
+      # @rbs @coverage: Hash[Symbol, Object?]
+      # @rbs @minimum: String
+      # @rbs @warnings: Array[String]
+      # @rbs (mode: String, algorithm: String, grammar: IR::Grammar, before: IR::Automaton?, after: IR::Automaton?,
+      #   seeds: Array[Hash[Symbol, Object?]], nodes: Hash[Integer, Node], symbol_kinds: Hash[Integer, Array[String]],
+      #   set_changes: Hash[String, Hash[Symbol, Object?]], automaton: Hash[Symbol, Object?],
+      #   actions: Array[Hash[Symbol, Object?]], coverage: Hash[Symbol, Object?], ?metadata_names: Array[String],
+      #   ?minimum: String,
+      #   ?warnings: Array[String]) -> void
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(mode:, algorithm:, grammar:, before:, after:, seeds:, nodes:, symbol_kinds:, set_changes:,
+                     automaton:,
+                     actions:, coverage:, metadata_names: [], minimum: "info", warnings: [])
+        @mode = mode
+        @algorithm = algorithm
+        @grammar = grammar
+        @before = before
+        @after = after
+        @seeds = seeds
+        @nodes = nodes
+        @symbol_kinds = symbol_kinds
+        @set_changes = set_changes
+        @metadata_names = metadata_names.uniq.sort
+        @automaton = automaton #: Hash[Symbol, Object?]
+        @actions = actions #: Array[Hash[Symbol, Object?]]
+        @coverage = coverage #: Hash[Symbol, Object?]
+        @minimum = minimum
+        @warnings = warnings
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      # @rbs (?minimum: String) -> Hash[Symbol, Object?]
+      def to_h(minimum: @minimum)
+        symbols = symbol_documents(minimum)
+        action_records = action_documents(minimum)
+        {
+          ibex_report: "impact", schema_version: 1, mode: @mode, algorithm: @algorithm,
+          grammar_digest: { before: stable_grammar_digest(@before), after: stable_grammar_digest(@after) },
+          seeds: @seeds.map { |seed| seed.slice(:symbol, :origin, :nullable_boundary) },
+          symbols: symbols, automaton: @automaton, actions: action_records,
+          coverage: coverage_document, warnings: stable_warnings,
+          totals: totals(symbols, action_records, @automaton)
+        }
+      end
+
+      private
+
+      # @rbs (String minimum) -> Array[Hash[Symbol, Object?]]
+      def symbol_documents(minimum)
+        names = (@nodes.keys.filter_map { |id| @grammar.symbol_by_id(id)&.name } + @set_changes.keys + @metadata_names)
+                .uniq.sort
+        documents = names.filter_map { |name| symbol_document(name) }
+        documents.select { |document| Severity::RANK.fetch(severity_of(document)) >= Severity::RANK.fetch(minimum) }
+      end
+
+      # @rbs (String) -> Hash[Symbol, Object?]?
+      def symbol_document(name)
+        id = @grammar.symbol(name)&.id
+        node = id && @nodes[id]
+        return unless reportable_symbol?(name)
+
+        kinds = symbol_kinds_for(name, id)
+        kinds = ["reference"] if kinds.empty? && node
+        severity = document_severity(name, kinds)
+        {
+          symbol: name, severity: severity, kinds: kinds, distance: node&.distance || 0,
+          component: component_names(node, name),
+          sets: @set_changes.fetch(name, { first: empty_change, follow: empty_change, nullable: nil }),
+          witness: witness_documents(node&.witness || [])
+        }
+      end
+
+      # @rbs (String) -> bool
+      def reportable_symbol?(name)
+        !!(@grammar.symbol(name) || @set_changes.key?(name) || @metadata_names.include?(name))
+      end
+
+      # @rbs (String, Integer?) -> Array[String]
+      def symbol_kinds_for(name, id)
+        kinds = id ? (@symbol_kinds[id] || []).dup : [] #: Array[String]
+        kinds << "metadata" if @metadata_names.include?(name)
+        kinds.concat(change_kinds(name))
+        kinds.uniq.sort
+      end
+
+      # @rbs (String) -> Array[String]
+      def change_kinds(name)
+        change = @set_changes[name]
+        return [] unless change
+
+        kinds = [] #: Array[String]
+        first = change.fetch(:first, empty_change)
+        follow = change.fetch(:follow, empty_change)
+        kinds << "first" unless first.fetch(:added).empty? && first.fetch(:removed).empty?
+        kinds << "follow" unless follow.fetch(:added).empty? && follow.fetch(:removed).empty?
+        kinds << "nullable" if change.fetch(:nullable, nil)
+        kinds
+      end
+
+      # @rbs (String, Array[String]) -> String
+      def document_severity(name, kinds)
+        level = kinds.reduce("info") { |current, kind| Severity.max(current, kind_severity(kind)) }
+        action_severity(name, level)
+      end
+
+      # @rbs (Node?, String) -> Array[String]
+      def component_names(node, name)
+        return [name] unless node
+
+        node.component.sort.map { |member| @grammar.symbol_by_id(member)&.name }.compact.sort
+      end
+
+      # @rbs (String kind) -> String
+      def kind_severity(kind)
+        return "high" if %w[first follow nullable action_arity].include?(kind)
+        return "medium" if %w[reference precedence].include?(kind)
+        return "low" if kind == "metadata"
+
+        "info"
+      end
+
+      # @rbs (String name, String current) -> String
+      def action_severity(name, current)
+        findings = @actions.select { |action| action_production(action).start_with?("#{name} ->") }
+        findings.reduce(current) { |level, finding| Severity.max(level, severity_of(finding)) }
+      end
+
+      # @rbs (Hash[Symbol, Object?] record) -> String
+      def severity_of(record)
+        record.fetch(:severity) #: String
+      end
+
+      # @rbs () -> Hash[Symbol, Array[String]]
+      def empty_change
+        { added: [], removed: [] }
+      end
+
+      # @rbs (Array[Edge]) -> Array[Hash[Symbol, Object?]]
+      def witness_documents(witness)
+        witness.map do |edge|
+          production = edge.production && @grammar.productions[edge.production]
+          location = production&.origin&.fetch(:loc, nil) #: IR::location?
+          {
+            from: symbol_name(edge.source), to: symbol_name(edge.target), production: production_shape(production),
+            loc: stable_location(location)
+          }
+        end
+      end
+
+      # @rbs (Integer) -> String
+      def symbol_name(id)
+        @grammar.symbol_by_id(id)&.name || id.to_s
+      end
+
+      # @rbs (IR::Production?) -> String?
+      def production_shape(production)
+        return unless production
+
+        lhs = symbol_name(production.lhs)
+        rhs = production.rhs.map { |id| symbol_name(id) }
+        "#{lhs} -> #{rhs.join(' ')}"
+      end
+
+      # @rbs (Array[Hash[Symbol, Object?]], Array[Hash[Symbol, Object?]],
+      #   Hash[Symbol, Object?]) -> Hash[Symbol, Integer]
+      def totals(symbols, actions, automaton)
+        counts = Severity::LEVELS.to_h { |level| [level.to_sym, 0] }
+        symbols.each { |item| counts[item.fetch(:severity).to_s.to_sym] += 1 }
+        actions.each { |item| counts[item.fetch(:severity).to_s.to_sym] += 1 }
+        conflicts = automaton.dig(:conflicts, :added) || [] #: Array[Hash[Symbol, Object?]]
+        counts[:critical] += conflicts.length
+        unreachable = automaton.fetch(:unreachable, []) #: Array[Integer]
+        counts[:critical] += unreachable.length
+        unreachable_nonterminals = automaton.fetch(:unreachable_nonterminals, []) #: Array[String]
+        counts[:critical] += unreachable_nonterminals.length
+        counts
+      end
+
+      # @rbs (String minimum) -> Array[Hash[Symbol, Object?]]
+      def action_documents(minimum)
+        documents = @actions.sort_by { |action| action_production(action) }.map do |action|
+          production = action_production(action)
+          severity = action.fetch(:severity) #: String
+          reason = action.fetch(:reason) #: String
+          context_length = action.fetch(:context_length) #: Hash[Symbol, Integer]
+          location = action.fetch(:loc, nil) #: IR::location?
+          {
+            production: production, severity: severity, reason: reason,
+            context_length: context_length, loc: stable_location(location)
+          }
+        end
+        documents.select { |action| Severity::RANK.fetch(severity_of(action)) >= Severity::RANK.fetch(minimum) }
+      end
+
+      # @rbs (Hash[Symbol, Object?] action) -> String
+      def action_production(action)
+        action.fetch(:production) #: String
+      end
+
+      # @rbs () -> Hash[Symbol, Object?]
+      def coverage_document
+        empty_reports = [] #: Array[Hash[Symbol, Object?]]
+        reports = @coverage.fetch(:reports, empty_reports) #: Array[Hash[Symbol, Object?]]
+        status = @coverage.fetch(:status) #: String
+        { status: status,
+          reports: reports.sort_by { |report| coverage_report_path(report) }.map do |report|
+            productions = report.fetch(:productions) #: Array[Integer]
+            { path: stable_path(coverage_report_path(report)), productions: productions.sort }
+          end }
+      end
+
+      # @rbs (Hash[Symbol, Object?] report) -> String
+      def coverage_report_path(report)
+        report.fetch(:path) #: String
+      end
+
+      # @rbs () -> Array[String]
+      def stable_warnings
+        empty_reports = [] #: Array[Hash[Symbol, Object?]]
+        paths = @coverage.fetch(:reports, empty_reports).map { |report| coverage_report_path(report) }
+        @warnings.map do |warning|
+          paths.reduce(warning) { |current, path| current.gsub(path, stable_path(path)) }
+        end.sort.uniq
+      end
+
+      # @rbs (IR::location?) -> Hash[Symbol, Integer]?
+      def stable_location(location)
+        return unless location
+
+        { line: location[:line], column: location[:column] }
+      end
+
+      # @rbs (IR::Automaton?) -> String?
+      def stable_grammar_digest(automaton)
+        return unless automaton
+
+        serialized = IR::Serialize.dump(automaton.grammar)
+        canonical = serialized.gsub(/"file":\s*"[^"]*"/, '"file": "<source>"')
+        canonical = canonical.gsub(/"root":\s*"[^"]*"/, '"root": null')
+        "sha256:#{Digest::SHA256.hexdigest(canonical)}"
+      end
+
+      # @rbs (String) -> String
+      def stable_path(path)
+        return path unless path.start_with?(File::SEPARATOR)
+
+        File.basename(path)
+      end
+    end
+  end
+end

data/lib/ibex/impact/seeds.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  module Impact
+    # Converts command-line symbols and Diff rule ids into analysis seeds.
+    class Seeds
+      # @rbs @grammar: IR::Grammar
+      # @rbs @sets: Analysis::Sets
+      # @rbs @records: Array[Hash[Symbol, Object?]]
+      # @rbs @ids: Array[Integer]
+      attr_reader :ids #: Array[Integer]
+      attr_reader :records #: Array[Hash[Symbol, Object?]]
+
+      # @rbs (IR::Grammar grammar, Array[String] names, ?origin: String) -> void
+      def initialize(grammar, names, origin: "symbol")
+        @grammar = grammar
+        @sets = Analysis::Sets.new(grammar)
+        @records = names.flat_map { |name| resolve(name, origin) }.sort_by { |record| seed_symbol(record) }
+        @ids = @records.map { |record| seed_id(record) }.uniq.freeze
+        @records = @records.freeze
+        freeze
+      end
+
+      # @rbs (IR::Grammar grammar, Hash[Symbol, Object?] diff, ?origin: String) -> Seeds
+      def self.from_diff(grammar, diff, origin: "diff")
+        rules = diff.fetch(:rules) #: Hash[Symbol, Object?]
+        names = %i[added removed changed].flat_map do |section|
+          records = rules.fetch(section) #: Array[Hash[Symbol, Object?]]
+          records.map { |record| record.fetch(:id).to_s }
+        end.uniq.sort
+        new(grammar, names, origin: origin)
+      end
+
+      private
+
+      # @rbs (Hash[Symbol, Object?] record) -> String
+      def seed_symbol(record)
+        record.fetch(:symbol) #: String
+      end
+
+      # @rbs (Hash[Symbol, Object?] record) -> Integer
+      def seed_id(record)
+        record.fetch(:id) #: Integer
+      end
+
+      # @rbs (String name, String origin) -> Array[Hash[Symbol, Object?]]
+      def resolve(name, origin)
+        definition = @grammar.symbol(name)
+        raise Ibex::Error, "(impact):1:1: unknown symbol #{name}" unless definition
+        raise Ibex::Error, "(impact):1:1: impact seed #{name} is not a nonterminal" unless definition.nonterminal?
+
+        [{ symbol: definition.name, id: definition.id, origin: origin,
+           nullable_boundary: nullable_boundary?(definition.id) }]
+      end
+
+      # @rbs (Integer) -> bool
+      def nullable_boundary?(id)
+        return true if @sets.nullable?(id)
+
+        @grammar.productions.any? do |production|
+          production.rhs.include?(id) && production.rhs.any? do |symbol_id|
+            @grammar.symbol_by_id(symbol_id)&.nonterminal? && @sets.nullable?(symbol_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ibex/impact/severity.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "json"
+require "optparse"
+
+module Ibex
+  module Impact
+    # Stores only conflict identities so a baseline is stable across state ids.
+    class Baseline
+      # @rbs (String path) -> void
+      def initialize(path)
+        @path = path
+      end
+
+      # @rbs () -> Array[String]
+      def conflicts
+        return [] unless File.file?(@path)
+
+        value = JSON.parse(File.binread(@path))
+        validate_document(value)
+        conflicts = value.fetch("conflicts") #: Array[untyped]
+        unless conflicts.all? { |identity| identity.is_a?(String) && !identity.empty? }
+          raise Ibex::Error, "#{@path}:1:1: invalid impact baseline: conflicts must contain non-empty strings"
+        end
+
+        conflicts.sort.uniq
+      rescue JSON::ParserError => e
+        raise Ibex::Error, "#{@path}:1:1: invalid impact baseline: #{e.message}"
+      end
+
+      # @rbs (Object?) -> void
+      def validate_document(value)
+        unless value.is_a?(Hash) && value.keys.sort == %w[conflicts schema_version]
+          raise Ibex::Error, "#{@path}:1:1: invalid impact baseline: expected schema_version and conflicts"
+        end
+        unless value.fetch("conflicts").is_a?(Array)
+          raise Ibex::Error, "#{@path}:1:1: invalid impact baseline: conflicts must be an array"
+        end
+        return if value.fetch("schema_version") == 1
+
+        raise Ibex::Error, "#{@path}:1:1: unsupported impact baseline schema"
+      end
+
+      # @rbs (Array[String] identities) -> void
+      def write(identities)
+        File.write(@path, "#{JSON.pretty_generate({ 'schema_version' => 1, 'conflicts' => identities.sort.uniq })}\n")
+      end
+    end
+
+    # Severity ranking and CI gate evaluation for impact findings.
+    module Severity
+      LEVELS = %w[info low medium high critical].freeze #: Array[String]
+      FAIL_ON = %w[
+        new_conflict nullable_change first_change follow_change action_arity unreachable
+      ].freeze #: Array[String]
+      RANK = LEVELS.each_with_index.to_h.freeze #: Hash[String, Integer]
+      GATE_TO_KIND = {
+        "nullable_change" => "nullable", "first_change" => "first", "follow_change" => "follow"
+      }.freeze #: Hash[String, String]
+
+      module_function
+
+      # @rbs (String left, String right) -> String
+      def max(left, right)
+        RANK.fetch(left) >= RANK.fetch(right) ? left : right
+      end
+
+      # @rbs (Hash[String, Array[String]], Array[Hash[Symbol, String]]) -> Hash[String, String]
+      def symbols(changes, actions)
+        levels = Hash.new("info") #: Hash[String, String]
+        changes.each do |name, kinds|
+          kinds.each do |kind|
+            level = level_for_kind(kind)
+            levels[name] = max(levels[name], level)
+          end
+        end
+        actions.each do |finding|
+          name = finding.fetch(:production).split(" -> ").first
+          levels[name] = max(levels[name], finding.fetch(:severity))
+        end
+        levels
+      end
+
+      # @rbs (String) -> String
+      def level_for_kind(kind)
+        return "high" if %w[first follow nullable].include?(kind)
+        return "medium" if %w[reference precedence].include?(kind)
+
+        "low"
+      end
+
+      # @rbs (Hash[Symbol, Object?] report, Array[String] gates) -> bool
+      def fails?(report, gates)
+        return false if gates.empty?
+
+        return true if conflict_gate?(report, gates)
+        return true if unreachable_gate?(report, gates)
+        return true if action_gate?(report, gates)
+
+        symbol_records = report.fetch(:symbols, []) #: Array[Hash[Symbol, Object?]]
+        gates.any? do |gate|
+          kind = GATE_TO_KIND[gate]
+          kind && symbol_records.any? { |item| item[:kinds].is_a?(Array) && item[:kinds].include?(kind) }
+        end
+      end
+
+      # @rbs (Hash[Symbol, Object?], Array[String]) -> bool
+      def conflict_gate?(report, gates)
+        gates.include?("new_conflict") && report.dig(:automaton, :conflicts, :added)&.any?
+      end
+
+      # @rbs (Hash[Symbol, Object?], Array[String]) -> bool
+      def unreachable_gate?(report, gates)
+        return false unless gates.include?("unreachable")
+
+        states = report.dig(:automaton, :unreachable) || []
+        nonterminals = report.dig(:automaton, :unreachable_nonterminals) || []
+        states.any? || nonterminals.any?
+      end
+
+      # @rbs (Hash[Symbol, Object?], Array[String]) -> bool
+      def action_gate?(report, gates)
+        return false unless gates.include?("action_arity")
+
+        action_records = report.fetch(:actions, []) #: Array[Hash[Symbol, Object?]]
+        action_records.any? { |item| item[:severity] == "high" }
+      end
+
+      # @rbs (Array[String] gates) -> Array[String]
+      def validate_gates(gates)
+        unknown = gates - FAIL_ON
+        raise OptionParser::InvalidArgument, "unknown --fail-on value #{unknown.first.inspect}" unless unknown.empty?
+
+        gates.uniq
+      end
+    end
+  end
+end

data/lib/ibex/impact.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require_relative "impact/graph"
+require_relative "impact/propagation"
+require_relative "impact/seeds"
+require_relative "impact/automaton_impact"
+require_relative "impact/action_impact"
+require_relative "impact/coverage_impact"
+require_relative "impact/severity"
+require_relative "impact/report"
+
+module Ibex
+  module Impact
+  end
+end