hashira 0.7.0 → 0.9.0

data/lib/hashira/duplication/harvest.rb

@@ -7,19 +7,21 @@ class Hashira::Duplication::Harvest
 
   def initialize(project, trees)
     @project = project
-    @fragments = trees.flat_map { |path, tree| scan(@project.relative(path), tree) }
+    @trees = trees
   end
 
-  attr_reader :fragments
+  def fragments = @_fragments ||= @trees.flat_map { |path, tree| scan(@project.relative(path), tree) }
 
   private
 
-  def scan(rel, tree)
+  def scan(relative, tree)
     nodes = Hashira::Analysis::NodeWalk.collect(tree)
-    windows(rel, nodes) + wholes(nodes).map { Hashira::Duplication::Fragment.new(rel, [it]) }
+    windows(relative, nodes) + wholes(nodes).map { Hashira::Duplication::Fragment.new(relative, [it]) }
   end
 
-  def windows(rel, nodes) = runs(nodes).flat_map { Hashira::Duplication::Sequence.new(rel, it).fragments }
+  def windows(relative, nodes)
+    runs(nodes).flat_map { Hashira::Duplication::Sequence.new(relative, it).fragments }
+  end
 
   def runs(nodes) = nodes.filter_map { it.body if it.is_a?(Prism::StatementsNode) }
 

data/lib/hashira/duplication/index.rb

@@ -6,13 +6,14 @@ class Hashira::Duplication::Index
 
   def initialize(fragments)
     @fragments = fragments
-    @frequency = frequencies(fragments)
   end
 
   def buckets = grouped.values.select { |bucket| bucket.size.between?(2, MAX_BUCKET) }
 
   private
 
+  def frequency = @_frequency ||= frequencies(@fragments)
+
   def frequencies(fragments)
     fragments.each_with_object(Hash.new(0)) { |fragment, counts| tally(counts, fragment) }
   end
@@ -27,5 +28,5 @@ class Hashira::Duplication::Index
 
   def file(index, fragment) = rarest(fragment).each { |type| index[type] << fragment }
 
-  def rarest(fragment) = fragment.types.uniq.min_by(RARE) { @frequency[it] }
+  def rarest(fragment) = fragment.types.uniq.min_by(RARE) { frequency[it] }
 end

data/lib/hashira/duplication/literal.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Duplication::Literal
+  TYPES = [
+    Prism::ArrayNode, Prism::AssocNode, Prism::FalseNode, Prism::FloatNode,
+    Prism::HashNode, Prism::IntegerNode, Prism::KeywordHashNode, Prism::NilNode,
+    Prism::StringNode, Prism::SymbolNode, Prism::TrueNode
+  ].freeze
+
+  def initialize(node)
+    @node = node
+  end
+
+  def literal? = TYPES.include?(@node.class) && parts.all?(&:literal?)
+
+  def literals? = parts.all?(&:literal?)
+
+  private
+
+  def parts = children.map { Hashira::Duplication::Literal.new(it) }
+
+  def children = Array(@node&.compact_child_nodes)
+end

data/lib/hashira/duplication/similarity.rb

@@ -8,7 +8,7 @@ class Hashira::Duplication::Similarity
 
   def ratio
     return 0.0 if @left.empty? || @right.empty?
-    normalized(lcs)
+    normalized(subsequence)
   end
 
   def meets?(threshold) = ceiling >= threshold && ratio >= threshold
@@ -29,7 +29,7 @@ class Hashira::Duplication::Similarity
     true
   end
 
-  def lcs = @left.reduce(blank) { |prev, token| advance(prev, token) }.last
+  def subsequence = @left.reduce(blank) { |prev, token| advance(prev, token) }.last
 
   def blank = Array.new(@right.size + 1, 0)
 

data/lib/hashira/duplication/variance.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "prism"
+
 class Hashira::Duplication::Variance
   LITERALS = %i[integer_node float_node string_node symbol_node].freeze
   VALUED = %i[integer_node float_node].freeze
@@ -27,7 +29,11 @@ class Hashira::Duplication::Variance
 
   def pairs = @canonical.nodes.zip(@other.nodes)
 
-  def named = @named ||= pairs.select { |left, _| NAMED.include?(left.type) }
+  def named = @_named ||= pairs.select { |left, _| NAMED.include?(left.type) && !inner?(left) }
+
+  def inner?(node) = nested.any? { it.equal?(node) }
+
+  def nested = @_nested ||= @canonical.nodes.grep(Prism::ConstantPathNode).filter_map(&:parent)
 
   def differing = pairs.select { |pair| varies?(*pair) }.map(&:first)
 

data/lib/hashira/error.rb

@@ -1,7 +1,4 @@
 # frozen_string_literal: true
 
 class Hashira::Error < StandardError
-  def self.unknown(flag, value, choices)
-    new("unknown #{flag} #{value.inspect} (use: #{choices.join(", ")})")
-  end
 end

data/lib/hashira/focus.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Hashira::Focus
+  SITE = /\A(?<path>[^\s:]+\.rb):/
+
+  def initialize(project, paths)
+    @project = project
+    @paths = paths
+  end
+
+  def narrowing? = !@paths.empty?
+
+  def narrow(findings)
+    return findings unless narrowing?
+    findings.select { named?(it) }
+  end
+
+  private
+
+  def wanted = @_wanted ||= @paths.select { covered?(it) }.map { @project.relative(it) }
+
+  def covered?(path) = @project.directories.any? { path.start_with?("#{it}/") }
+
+  def named?(finding) = sites(finding).any? { wanted.include?(it) }
+
+  def sites(finding) = quotes(finding).filter_map { SITE.match(it)&.[](:path) }
+
+  def quotes(finding) = [finding.package, finding.detail.to_h[:site], *finding.evidence].compact
+end

data/lib/hashira/git_log.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class Hashira::GitLog
+  LOG = %w[log --no-renames --name-only --format=].freeze
+
+  def initialize(directory)
+    @directory = directory
+  end
+
+  def counts = output.split("\n").map(&:strip).reject(&:empty?).tally
+
+  private
+
+  def output
+    IO.popen(["git", "-C", @directory, *LOG], err: File::NULL, &:read)
+  rescue SystemCallError
+    ""
+  end
+end

data/lib/hashira/hotspots/file_cost.rb

@@ -12,7 +12,7 @@ module Hashira
 
         def heat = [churn, CHURN_FLOOR].max
 
-        def to_h = { file:, cognitive:, duplication:, churn:, cost:, rank: }
+        def to_h = super.merge(cost:, rank:)
 
         def cells = [file, cognitive, duplication, churn, rank]
       end

data/lib/hashira/hotspots/rollup.rb

@@ -23,9 +23,9 @@ class Hashira::Hotspots::Rollup
 
   def clusters = @duplication ? @duplication.clusters : []
 
-  def cognitive = @cognitive ||= bucketed(scores.map { [it.file, it.cognitive] })
+  def cognitive = @_cognitive ||= bucketed(scores.map { [it.file, it.cognitive] })
 
-  def duplicated = @duplicated ||= bucketed(clusters.flat_map(&:masses))
+  def duplicated = @_duplicated ||= bucketed(clusters.flat_map(&:masses))
 
   def bucketed(charges) = charges.each_with_object(Hash.new(0)) { |(file, cost), total| total[file] += cost }
 end

data/lib/hashira/pipeline.rb

@@ -10,50 +10,58 @@ class Hashira::Pipeline
   STRUCTURAL = Hashira::Coupling::Report::RULES.map { it::KIND }.freeze
 
   SMELLS = (
-    Hashira::Smells::Report::CHECKS.map(&:kind) + [Hashira::Smells::BoundarySprawl::KIND]
+    Hashira::Smells::Report::CHECKS.map { Hashira::Smells::Kind.new(it).to_s } + [Hashira::Smells::BoundarySprawl::KIND]
   ).sort.freeze
 
-  def initialize(project, enabled: ANALYZERS, packaging: :auto)
+  def initialize(project, enabled: ANALYZERS, packaging: :auto, only: [])
     @project = project
     @enabled = enabled
-    @parsed = Hashira::Trees.new(project)
-    @coupling = Hashira::Coupling::Report.new(project, @parsed.all, packaging: settle(packaging))
+    @packaging = packaging
+    @only = only
   end
 
   attr_reader :project
 
-  def unparsed = @parsed.unparsed
+  def unparsed = parsed.unparsed
 
-  def graph = @coupling.graph
+  def graph = coupling.graph
 
-  def complexity = @complexity ||= analyzed(:complexity, Hashira::Complexity::Scores)
+  def complexity = @_complexity ||= analyzed(:complexity, Hashira::Complexity::Scores)
 
-  def duplication = @duplication ||= analyzed(:duplication, Hashira::Duplication::Clones, churn)
+  def duplication = @_duplication ||= analyzed(:duplication, Hashira::Duplication::Clones, churn)
 
-  def smells = @smells ||= analyzed(:smells, Hashira::Smells::Report)
+  def smells = @_smells ||= analyzed(:smells, Hashira::Smells::Report)
 
   def hotspots
-    @hotspots ||= Hashira::Hotspots::Rollup.new(complexity, duplication, churn) if complexity || duplication
+    @_hotspots ||= Hashira::Hotspots::Rollup.new(complexity, duplication, churn) if complexity || duplication
   end
 
-  def churn = @churn ||= Hashira::Churn.scan(@project.directories.first)
+  def churn = @_churn ||= Hashira::Churn.build(@project.directories.first)
 
   def enabled?(analyzer) = @enabled.include?(analyzer)
 
   def analyzed(name, kind, *extra)
-    kind.new(@project, @parsed.all, *extra) if enabled?(name)
+    kind.new(@project, parsed.all, *extra) if enabled?(name)
   end
 
-  def findings = structural + listed(complexity) + listed(duplication) + listed(smells)
+  def findings = focus.narrow(structural + listed(complexity) + listed(duplication) + listed(smells))
+
+  def focus = @_focus ||= Hashira::Focus.new(@project, @only)
 
   private
 
+  def parsed = @_parsed ||= Hashira::Trees.new(@project)
+
+  def coupling
+    @_coupling ||= Hashira::Coupling::Report.new(@project, parsed.all, packaging: settle(@packaging))
+  end
+
   def settle(packaging)
     return packaging unless packaging == :auto
     @project.rails? ? :namespace : :folder
   end
 
-  def structural = enabled?(:coupling) ? @coupling.findings : []
+  def structural = enabled?(:coupling) ? coupling.findings : []
 
   def listed(analyzer) = analyzer ? analyzer.findings : []
 end

data/lib/hashira/project.rb

@@ -3,40 +3,15 @@
 class Hashira::Project
   ROOT_PACKAGE = "(root)"
 
-  def self.detect(directories)
-    new((directories.empty? ? defaults : directories).map { descend(it.delete_suffix("/")) })
+  def initialize(requested)
+    @requested = requested
   end
 
-  def self.defaults
-    return ["lib"] if Dir["lib/*/"].any? || Dir["lib/*.rb"].any?
-    raise(Hashira::Error, "no lib/ directory here — pass the source directory explicitly")
-  end
-  private_class_method :defaults
-
-  def self.descend(directory)
-    child = sole(directory)
-    return directory unless child && Dir["#{child}/*/"].any? && (Dir["#{directory}/*.rb"] - ["#{child}.rb"]).empty?
-    descend(child)
-  end
+  def directories = @_directories ||= resolved
 
-  def self.sole(directory)
-    subdirectories = Dir["#{directory}/*/"]
-    subdirectories.size == 1 ? subdirectories.first.delete_suffix("/") : nil
-  end
-  private_class_method :descend, :sole
-
-  def initialize(directories)
-    vet(directories)
-    @directories = distinct(directories.map { it.delete_suffix("/") })
-    raise(Hashira::Error, "no Ruby files under #{label}") if files.empty?
-    @rails = @directories.any? { config?(File.expand_path(it)) }
-  end
-
-  attr_reader :directories
+  def rails? = directories.any? { config?(File.expand_path(it)) }
 
-  def rails? = @rails
-
-  def files = @directories.flat_map { Dir["#{it}/**/*.rb"] }.sort
+  def files = directories.flat_map { Dir["#{it}/**/*.rb"] }.sort
 
   def package(path)
     first, rest = relative(path).delete_suffix(".rb").split("/", 2)
@@ -46,12 +21,38 @@ class Hashira::Project
 
   def relative(path) = path.delete_prefix("#{parent(path)}/")
 
-  def label = @directories.join(", ")
+  def label = directories.join(", ")
 
   def root = ROOT_PACKAGE
 
   private
 
+  def resolved
+    chosen = (@requested.empty? ? defaults : @requested).map { descend(it.delete_suffix("/")) }
+    vet(chosen)
+    survivors = distinct(chosen)
+    raise(Hashira::Error, "no Ruby files under #{survivors.join(", ")}") if bare?(survivors)
+    survivors
+  end
+
+  def bare?(survivors) = survivors.flat_map { Dir["#{it}/**/*.rb"] }.empty?
+
+  def defaults
+    return ["lib"] if Dir["lib/*/"].any? || Dir["lib/*.rb"].any?
+    raise(Hashira::Error, "no lib/ directory here — pass the source directory explicitly")
+  end
+
+  def descend(directory)
+    child = sole(directory)
+    return directory unless child && Dir["#{child}/*/"].any? && (Dir["#{directory}/*.rb"] - ["#{child}.rb"]).empty?
+    descend(child)
+  end
+
+  def sole(directory)
+    subdirectories = Dir["#{directory}/*/"]
+    subdirectories.size == 1 ? subdirectories.first.delete_suffix("/") : nil
+  end
+
   def vet(directories)
     file = directories.find { File.file?(it) }
     raise(Hashira::Error, "#{file} is a file — hashira takes directories (try: hashira #{File.dirname(file)})") if file
@@ -73,13 +74,13 @@ class Hashira::Project
   def folder?(path, name) = Dir.exist?("#{parent(path)}/#{name}")
 
   def contested
-    @contested ||=
-      @directories.flat_map { |directory| Dir["#{directory}/*/"].map { File.basename(it) } }
+    @_contested ||=
+      directories.flat_map { |directory| Dir["#{directory}/*/"].map { File.basename(it) } }
         .tally.filter_map { |name, count| name if count > 1 }
   end
 
   def parent(path)
-    @directories.find { path.start_with?("#{it}/") } ||
+    directories.find { path.start_with?("#{it}/") } ||
       raise(Hashira::Error, "#{path} is outside the analyzed directories")
   end
 end

data/lib/hashira/report/columns.rb

@@ -7,7 +7,7 @@ class Hashira::Report::Columns
   NUMBER = /\A-?\d+(?:\.\d+)?\z/
 
   def initialize(headers, rows, io: $stdout)
-    @headers, *@rows = [headers, *rows].map { |cells| cells.map { clip(it) } }
+    @raw = [headers, *rows]
     @io = io
   end
 
@@ -17,14 +17,20 @@ class Hashira::Report::Columns
     body
   end
 
-  def body = @rows.each { @io.puts(line(it)) }
+  def body = rows.each { @io.puts(line(it)) }
 
-  def header = line(@headers)
+  def header = line(headers)
 
-  def rule = "-" * [header, *@rows.map { line(it) }].map(&:length).max
+  def rule = "-" * [header, *rows.map { line(it) }].map(&:length).max
 
   private
 
+  def clipped = @_clipped ||= @raw.map { |cells| cells.map { clip(it) } }
+
+  def headers = clipped.first
+
+  def rows = clipped.drop(1)
+
   def line(cells) = cells.map.with_index { |cell, column| pad(cell, column) }.join(GAP).rstrip
 
   def pad(cell, column)
@@ -32,13 +38,13 @@ class Hashira::Report::Columns
     numeric[column] ? cell.rjust(width) : cell.ljust(width)
   end
 
-  def widths = @widths ||= @headers.each_index.map { |column| down(column).map(&:length).max }
+  def widths = @_widths ||= headers.each_index.map { |column| down(column).map(&:length).max }
 
-  def numeric = @numeric ||= @headers.each_index.map { |column| @rows.any? && counted?(column) }
+  def numeric = @_numeric ||= headers.each_index.map { |column| rows.any? && counted?(column) }
 
-  def counted?(column) = @rows.all? { NUMBER.match?(it[column]) }
+  def counted?(column) = rows.all? { NUMBER.match?(it[column]) }
 
-  def down(column) = [@headers[column], *@rows.map { it[column] }]
+  def down(column) = [headers[column], *rows.map { it[column] }]
 
   def clip(cell)
     text = cell.to_s

data/lib/hashira/report/graph_payload.rb

@@ -17,7 +17,7 @@ class Hashira::Report::GraphPayload
 
   def edges
     @graph.weighted.map do |from, to, weight|
-      { from:, to:, weight:, refs: @graph.evidence(from, to).to_a.sort }
+      { from:, to:, weight: }.merge(refs: @graph.evidence(from, to).to_a.sort)
     end
   end
 end

data/lib/hashira/report/hotspot_table.rb

@@ -19,7 +19,7 @@ class Hashira::Report::HotspotTable
 
   private
 
-  def ranked = @ranked ||= @hotspots.files.first(@top)
+  def ranked = @_ranked ||= @hotspots.files.first(@top)
 
   def legend
     @io.puts("\nLegend: Cog cognitive complexity, Dup mass of the clones the file carries,")

data/lib/hashira/report/json.rb

@@ -21,7 +21,8 @@ class Hashira::Report::Json
 
   def about
     project = @view.project
-    { version: SCHEMA, packaging: @view.graph&.packaging, targets: project.directories, files: project.files.size }
+    { version: SCHEMA, packaging: @view.graph&.packaging, targets: project.directories }
+      .merge(files: project.files.size)
   end
 
   def base = { findings: @view.findings.all.map { rendered(it) }, accepted: accepted }

data/lib/hashira/report/metrics_table.rb

@@ -22,7 +22,7 @@ class Hashira::Report::MetricsTable
 
   def ranked = @graph.metrics.sort_by { |_package, metric| metric.order }
 
-  def split = @split ||= (ranked.size > @top ? ranked.partition { |_package, metric| !leaf?(metric) } : [ranked, []])
+  def split = @_split ||= (ranked.size > @top ? ranked.partition { |_package, metric| !leaf?(metric) } : [ranked, []])
 
   def kept = split.first.first(@top)
 
@@ -38,9 +38,9 @@ class Hashira::Report::MetricsTable
 
   def more = @io.puts("  … and #{over} more — raise the cap with --top, or read them all with --json")
 
-  def row(package, metric) = [package, *metric.cells, cyc(package)]
+  def row(package, metric) = [package, *metric.cells, cycle(package)]
 
-  def cyc(package) = @graph.cycles.through?(package) ? "YES" : "-"
+  def cycle(package) = @graph.cycles.through?(package) ? "YES" : "-"
 
   def legend
     @io.puts("\nLegend: TC total types, Ca afferent (incoming), Ce efferent (outgoing),")

data/lib/hashira/report/phrases.rb

@@ -1,28 +1,33 @@
 # frozen_string_literal: true
 
 module Hashira::Report::Phrases
+  FLATTEN = "flatten the branching — guard clauses, early returns, or polymorphism."
+
+  LOOP_BODY = "extract the loop body into its own method."
+
   COMPLEXITY_ADVICE = {
-    "if" => "flatten the branching — guard clauses, early returns, or polymorphism.",
-    "elsif" => "replace the elsif ladder with a lookup or polymorphic dispatch.",
-    "else" => "flatten the branching — guard clauses, early returns, or polymorphism.",
+    "if" => FLATTEN, "else" => FLATTEN,
+    "elsif" => "replace the elsif ladder with a lookup or polymorphic dispatch."
+  }.merge(
     "case" => "a case this size often wants polymorphism or a dispatch table.",
     "boolean" => "name the compound condition in a predicate method.",
-    "rescue" => "narrow the rescue, or lift error handling to the caller.",
-    "while" => "extract the loop body into its own method.",
-    "until" => "extract the loop body into its own method.",
-    "for" => "extract the loop body into its own method.",
+    "rescue" => "narrow the rescue, or lift error handling to the caller."
+  ).merge(
+    "while" => LOOP_BODY, "until" => LOOP_BODY, "for" => LOOP_BODY
+  ).merge(
     "unless" => "invert to a guard clause or a named predicate.",
     "ternary" => "extract the nested ternary into a named method."
-  }.freeze
+  ).freeze
 
   DUPLICATION_ADVICE = {
     identical: "byte-for-byte identical — extract a shared method and call it from each site.",
     literal: "differs only in literal values — extract a method, pass them as arguments.",
-    message: "differs only in the receiver or message — extract a method taking the receiver.",
+    message: "differs only in the receiver or message — extract a method taking the receiver."
+  }.merge(
     constant: "differs only in a constant — extract a method and parameterize it.",
     structure: "the control flow differs — extract the common core, but verify by hand (lower confidence).",
     mixed: "extract the shared shape and pass what differs as parameters."
-  }.freeze
+  ).freeze
 
   module_function
 
@@ -38,9 +43,9 @@ module Hashira::Report::Phrases
 
   def on_sdp_violation(finding)
     detail = finding.detail
-    from, to = detail.values_at(:from, :to)
-    "#{from} (I=#{score(detail[:from_instability])}) depends on the LESS stable #{to} " \
-      "(I=#{score(detail[:to_instability])}) — churn in #{to} will force churn in #{from}. " \
+    from, to = detail.deconstruct
+    "#{from} (I=#{score(detail.from_instability)}) depends on the LESS stable #{to} " \
+      "(I=#{score(detail.to_instability)}) — churn in #{to} will force churn in #{from}. " \
       "Invert the edge or extract the stable part of #{to} that #{from} needs."
   end
 
@@ -69,14 +74,14 @@ module Hashira::Report::Phrases
 
   def on_complexity(finding)
     detail = finding.detail
-    "#{finding.package} — cognitive #{detail[:cognitive]}, #{detail[:calls]} calls " \
-      "(#{detail[:site]}). #{COMPLEXITY_ADVICE.fetch(detail[:dominant])}"
+    "#{finding.package} — cognitive #{detail.cognitive}, #{detail.calls} calls " \
+      "(#{detail.site}). #{COMPLEXITY_ADVICE.fetch(detail.dominant)}"
   end
 
   def on_duplication(finding)
     detail = finding.detail
-    "#{detail[:size]} similar fragments (mass #{detail[:mass]}) — " \
-      "#{DUPLICATION_ADVICE.fetch(detail[:kind])}#{footnote(detail)}"
+    "#{detail.size} similar fragments (mass #{detail.mass}) — " \
+      "#{DUPLICATION_ADVICE.fetch(detail.kind)}#{footnote(detail)}"
   end
 
   def score(value) = format("%.2f", value)
@@ -95,6 +100,6 @@ module Hashira::Report::Phrases
   end
 
   def footnote(detail)
-    detail[:hot] ? " Both sites change often — fix one, miss the other." : ""
+    detail.hot ? " Both sites change often — fix one, miss the other." : ""
   end
 end

data/lib/hashira/report/smell_phrases.rb

@@ -33,8 +33,8 @@ module Hashira::Report::Phrases
   end
 
   def on_instance_variable_assumption(finding)
-    "#{finding.package} reads instance variables never set in initialize (#{finding.detail[:site]}). " \
-      "Assign them in initialize, or pass the data explicitly."
+    "#{finding.package} reads instance variables nothing in the class assigns (#{finding.detail[:site]}). " \
+      "Assign them where the object is built, or pass the data explicitly."
   end
 
   def on_manual_dispatch(finding)

data/lib/hashira/smells/branches.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Smells::Branches
+  def initialize(root)
+    @root = root
+  end
+
+  def together?(nodes) = nodes.combination(2).any? { |left, right| meet?(trail(left), trail(right)) }
+
+  private
+
+  def meet?(left, right) = shared(left, right).none? { parted?(*it) }
+
+  def shared(left, right) = left.zip(right).select(&:last)
+
+  def parted?(here, there) = here.first.equal?(there.first) && here.last != there.last
+
+  def trail(node) = trails.fetch(node)
+
+  def trails
+    return @_trails if @_trails
+    @_trails = {}.compare_by_identity
+    chart(@root, [])
+    @_trails
+  end
+
+  def chart(node, trail)
+    @_trails[node] = trail
+    node.compact_child_nodes.each { chart(it, trail + taken(node, it)) }
+  end
+
+  def taken(node, child)
+    return arm_for(node, child) if node.is_a?(Prism::BeginNode)
+    arm = arms(node).index { it.equal?(child) }
+    arm ? [[node, arm]] : []
+  end
+
+  def arm_for(node, child)
+    rescued = node.rescue_clause
+    return [] unless [node.statements, rescued, node.else_clause].any? { it.equal?(child) }
+    [[node, rescued.equal?(child) ? 1 : 0]]
+  end
+
+  def arms(node) = (clauses(node) || conditions(node)).compact
+
+  def clauses(node)
+    case node
+    when Prism::IfNode, Prism::RescueNode then [node.statements, node.subsequent]
+    when Prism::UnlessNode then [node.statements, node.else_clause]
+    when Prism::RescueModifierNode then [node.expression, node.rescue_expression]
+    end
+  end
+
+  def conditions(node)
+    case node
+    when Prism::CaseNode, Prism::CaseMatchNode then node.conditions + [node.else_clause]
+    else []
+    end
+  end
+end