hashira 0.7.0 → 0.8.0

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/smells/census.rb

@@ -6,10 +6,9 @@ class Hashira::Smells::Census
   def initialize(project, trees)
     @project = project
     @trees = trees
-    @ownership = Hashira::Smells::Ownership.new(trees.values)
   end
 
-  attr_reader :ownership
+  def ownership = @_ownership ||= Hashira::Smells::Ownership.new(@trees.values)
 
   def types = @trees.flat_map { |path, tree| harvest(@project.relative(path), tree) }
 
@@ -28,8 +27,8 @@ class Hashira::Smells::Census
   def kind(node) = node.is_a?(Prism::ModuleNode) ? :module : :class
 
   def defs(name, node, file)
-    Hashira::Smells::Visibility.new(node).entries.map do |def_node, section|
-      Hashira::Smells::MethodContext.new(owner: name, node: def_node, file:, section:, ownership: @ownership)
+    Hashira::Smells::Visibility.new(node).entries.map do |definition, section|
+      Hashira::Smells::MethodContext.new(owner: name, node: definition, file:, section:, ownership:)
     end
   end
 end

data/lib/hashira/smells/check.rb

@@ -1,10 +1,6 @@
 # frozen_string_literal: true
 
 class Hashira::Smells::Check
-  def self.kind = name.split("::").last.gsub(/(?<=[a-z])(?=[A-Z])/, "_").downcase
-
-  def self.judge? = false
-
   def initialize(subject)
     @subject = subject
   end
@@ -18,7 +14,7 @@ class Hashira::Smells::Check
 
   attr_reader :subject
 
-  def kind = self.class.kind
+  def kind = Hashira::Smells::Kind.new(self.class).to_s
 
   def label = subject.subject
 

data/lib/hashira/smells/contexts.rb

@@ -9,12 +9,12 @@ module Hashira
 
       module_function
 
-      def names(def_node) = parts(def_node).flat_map { expand(it) }
+      def names(definition) = parts(definition).flat_map { expand(it) }
 
-      def arguments(def_node) = parts(def_node).grep_v(Prism::BlockParameterNode).flat_map { expand(it) }
+      def arguments(definition) = parts(definition).grep_v(Prism::BlockParameterNode).flat_map { expand(it) }
 
-      def parts(def_node)
-        node = def_node.parameters
+      def parts(definition)
+        node = definition.parameters
         return [] unless node
         node.requireds + node.optionals + node.posts + node.keywords +
           [node.rest, node.keyword_rest, node.block].compact

data/lib/hashira/smells/control_parameter.rb

@@ -5,7 +5,7 @@ class Hashira::Smells::ControlParameter < Hashira::Smells::Check
 
   def smelly? = culprits.any?
 
-  def culprits = @culprits ||= subject.parameters.filter_map { |name| culprit(name) }
+  def culprits = @_culprits ||= subject.parameters.filter_map { |name| culprit(name) }
 
   def culprit(name)
     lines = spots(name).uniq

data/lib/hashira/smells/data_clump.rb

@@ -5,15 +5,13 @@ class Hashira::Smells::DataClump < Hashira::Smells::Check
 
   MIN_SIZE = 2
 
-  def self.judge? = true
-
   private
 
   def smelly? = clumps.any?
 
-  def candidates = @candidates ||= subject.owned.map { [it, it.arguments.sort] }
+  def candidates = @_candidates ||= subject.owned.map { [it, it.arguments.sort] }
 
-  def clumps = @clumps ||= shared.map { |clump| [clump, holders(clump)] }
+  def clumps = @_clumps ||= shared.map { |clump| [clump, holders(clump)] }
 
   def shared = candidates.combination(MAX_COPIES + 1).filter_map { |group| clump(group) }.uniq
 

data/lib/hashira/smells/duplicate_method_call.rb

@@ -9,14 +9,14 @@ class Hashira::Smells::DuplicateMethodCall < Hashira::Smells::Check
 
   def smelly? = repeats.any?
 
-  def calls = @calls ||= Hashira::Smells::Scope.inside(subject.node).grep(Prism::CallNode)
+  def calls = @_calls ||= Hashira::Smells::Scope.inside(subject.node).grep(Prism::CallNode)
 
   def plain?(node)
     !node.receiver && !node.arguments && !node.block.is_a?(Prism::BlockArgumentNode)
   end
 
   def repeats
-    @repeats ||= usual.reject { |_handle, nodes| whole.value?(nodes) }.merge(whole)
+    @_repeats ||= usual.reject { |_handle, nodes| whole.value?(nodes) }.merge(whole)
   end
 
   def usual
@@ -25,7 +25,7 @@ class Hashira::Smells::DuplicateMethodCall < Hashira::Smells::Check
   end
 
   def whole
-    @whole ||=
+    @_whole ||=
       calls.select { it.block.is_a?(Prism::BlockNode) }
         .group_by { it.slice.gsub(/\s+/, " ") }.select { |_handle, group| group.size > LIMIT }
   end

data/lib/hashira/smells/feature_envy.rb

@@ -7,11 +7,11 @@ class Hashira::Smells::FeatureEnvy < Hashira::Smells::Check
     !subject.singleton? && !subject.mixin? && refs.ego.positive? && envied.any?
   end
 
-  def refs = @refs ||= Hashira::Smells::Refs.new(subject.node)
+  def refs = @_refs ||= Hashira::Smells::Refs.new(subject.node)
 
-  def envied = @envied ||= refs.envious.reject { foreign.dismiss?(it) }
+  def envied = @_envied ||= refs.envious.reject { foreign.dismiss?(it) }
 
-  def foreign = @foreign ||= Hashira::Smells::Foreign.new(subject, subject.ownership)
+  def foreign = @_foreign ||= Hashira::Smells::Foreign.new(subject, subject.ownership)
 
   def detail = { site:, names: envied }
 

data/lib/hashira/smells/foreign.rb

@@ -18,9 +18,7 @@ class Hashira::Smells::Foreign
   ].freeze
 
   def initialize(subject, ownership)
-    node = subject.node
-    @body = Hashira::Smells::Scope.inside(node)
-    @tail = tail(node)
+    @subject = subject
     @ownership = ownership
   end
 
@@ -35,12 +33,16 @@ class Hashira::Smells::Foreign
 
   private
 
+  def body = @_body ||= Hashira::Smells::Scope.inside(@subject.node)
+
+  def tail = @_tail ||= Hashira::Analysis::Syntax.statements(@subject.node).compact.last
+
   def convert?
-    @tail.is_a?(Prism::CallNode) && @tail.name == :new &&
-      Hashira::Analysis::Syntax.segments(@tail.receiver).any? && stateless?
+    tail.is_a?(Prism::CallNode) && tail.name == :new &&
+      Hashira::Analysis::Syntax.segments(tail.receiver).any? && stateless?
   end
 
-  def stateless? = @body.none? { STATE.include?(it.class) }
+  def stateless? = body.none? { STATE.include?(it.class) }
 
   def fenced?(name)
     tested = tests { it == name }
@@ -48,7 +50,7 @@ class Hashira::Smells::Foreign
   end
 
   def wire?(name)
-    calls = @body.grep(Prism::CallNode).select { |call| local?(call.receiver) { it == name } }
+    calls = body.grep(Prism::CallNode).select { |call| local?(call.receiver) { it == name } }
     calls.any? && calls.all? { keyed?(it) } && reassignments(name).none?
   end
 
@@ -75,11 +77,11 @@ class Hashira::Smells::Foreign
   def reassignments(name) = among(Prism::LocalVariableOperatorWriteNode, name)
 
   def among(kind, name)
-    @body.grep(kind).select { it.name == name }
+    body.grep(kind).select { it.name == name }
   end
 
   def snares(name)
-    @body.grep(Prism::RescueNode).select { it.reference&.name == name }
+    body.grep(Prism::RescueNode).select { it.reference&.name == name }
   end
 
   def alien?(exceptions)
@@ -107,15 +109,15 @@ class Hashira::Smells::Foreign
   end
 
   def probes(&)
-    @body.grep(Prism::CallNode).select { TYPE_TESTS.include?(it.name) && local?(it.receiver, &) }.filter_map { key(it) }
+    body.grep(Prism::CallNode).select { TYPE_TESTS.include?(it.name) && local?(it.receiver, &) }.filter_map { key(it) }
   end
 
   def arms(&)
-    @body.grep(Prism::CaseNode).select { local?(it.predicate, &) }.flat_map(&:conditions).flat_map(&:conditions)
+    body.grep(Prism::CaseNode).select { local?(it.predicate, &) }.flat_map(&:conditions).flat_map(&:conditions)
   end
 
   def lookups(&)
-    @body.grep(Prism::CallNode).select { it.name == :[] && sorts?(key(it), &) }.flat_map { @ownership.keys(Hashira::Analysis::Syntax.segments(it.receiver)) }
+    body.grep(Prism::CallNode).select { it.name == :[] && sorts?(key(it), &) }.flat_map { @ownership.keys(Hashira::Analysis::Syntax.segments(it.receiver)) }
   end
 
   def sorts?(argument, &)
@@ -126,6 +128,4 @@ class Hashira::Smells::Foreign
   def local?(node, &) = node.is_a?(Prism::LocalVariableReadNode) && yield(node.name)
 
   def key(call) = call.arguments&.arguments&.first
-
-  def tail(def_node) = Hashira::Analysis::Syntax.statements(def_node).compact.last
 end

data/lib/hashira/smells/instance_variable_assumption.rb

@@ -26,13 +26,13 @@ class Hashira::Smells::InstanceVariableAssumption < Hashira::Smells::Check
     end
   end
 
-  def self.judge? = true
-
   private
 
   def smelly? = subject.kind == :class && assumed.any?
 
-  def assumed = @assumed ||= (read - prepared).uniq.sort
+  def assumed = @_assumed ||= (read - prepared).uniq.sort.reject { cache?(it) }
+
+  def cache?(name) = name.start_with?("@_")
 
   def read = subject.owned.flat_map { Harvest.reads(it.node) }
 

data/lib/hashira/smells/kind.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Hashira::Smells::Kind
+  def initialize(check)
+    @check = check
+  end
+
+  def to_s = @check.name.split("::").last.gsub(/(?<=[a-z])(?=[A-Z])/, "_").downcase
+end

data/lib/hashira/smells/manual_dispatch.rb

@@ -8,7 +8,7 @@ class Hashira::Smells::ManualDispatch < Hashira::Smells::Check
   def smelly? = sightings.any?
 
   def sightings
-    @sightings ||= Hashira::Smells::Scope.inside(subject.node)
+    @_sightings ||= Hashira::Smells::Scope.inside(subject.node)
       .select { it.is_a?(Prism::CallNode) && it.name == :respond_to? }
   end
 

data/lib/hashira/smells/module_initialize.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 class Hashira::Smells::ModuleInitialize < Hashira::Smells::Check
-  def self.judge? = true
-
   private
 
   def smelly? = subject.kind == :module && flagged

data/lib/hashira/smells/nil_check.rb

@@ -9,7 +9,7 @@ class Hashira::Smells::NilCheck < Hashira::Smells::Check
 
   def smelly? = checks.any?
 
-  def checks = @checks ||= Hashira::Smells::Scope.inside(subject.node).select { check?(it) }
+  def checks = @_checks ||= Hashira::Smells::Scope.inside(subject.node).select { check?(it) }
 
   def check?(node)
     case node

data/lib/hashira/smells/ownership.rb

@@ -2,17 +2,29 @@
 
 class Hashira::Smells::Ownership
   def initialize(trees)
-    @suffixes = Set.new
-    @tables = {}
-    trees.each { survey(it) }
+    @trees = trees
   end
 
-  def owned?(segments) = @suffixes.include?(segments.join("::"))
+  def owned?(segments)
+    surveyed
+    @_suffixes.include?(segments.join("::"))
+  end
 
-  def keys(segments) = @tables.fetch(segments.join("::"), [])
+  def keys(segments)
+    surveyed
+    @_tables.fetch(segments.join("::"), [])
+  end
 
   private
 
+  def surveyed
+    return if @_surveyed
+    @_surveyed = true
+    @_suffixes = Set.new
+    @_tables = {}
+    @trees.each { survey(it) }
+  end
+
   def survey(tree)
     Hashira::Analysis::TypeWalk.each(tree) do |node, full|
       absorb(full)
@@ -27,14 +39,14 @@ class Hashira::Smells::Ownership
   end
 
   def absorb(path)
-    @suffixes.merge(suffixes(path))
+    @_suffixes.merge(suffixes(path))
   end
 
   def chart(path, value)
     return unless value.is_a?(Prism::HashNode)
     keys = value.elements.map { spine(it) }
     return if keys.empty? || keys.any?(&:nil?)
-    suffixes(path).each { @tables[it] = keys }
+    suffixes(path).each { @_tables[it] = keys }
   end
 
   def thaw(value)

data/lib/hashira/smells/param_check.rb

@@ -22,13 +22,13 @@ class Hashira::Smells::ParamCheck
   private
 
   def nested
-    @nested ||= Hashira::Smells::Conditions.nested(branches).map { self.class.new(it, @name) }
+    @_nested ||= Hashira::Smells::Conditions.nested(branches).map { self.class.new(it, @name) }
   end
 
   def branches = Hashira::Smells::Conditions.branches(@node)
 
   def predicate
-    @predicate ||= spread(Hashira::Smells::Conditions.condition(@node))
+    @_predicate ||= spread(Hashira::Smells::Conditions.condition(@node))
   end
 
   def spread(condition) = condition ? Hashira::Analysis::NodeWalk.collect(condition) : []