hashira 0.6.0 → 0.8.0

data/lib/hashira/project.rb

@@ -3,54 +3,69 @@
 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
-    raise(Hashira::Error, "no lib/ directory here — pass the source directory explicitly") if Dir["lib/*/"].empty?
-    ["lib"]
+  def directories = @_directories ||= resolved
+
+  def rails? = directories.any? { config?(File.expand_path(it)) }
+
+  def files = directories.flat_map { Dir["#{it}/**/*.rb"] }.sort
+
+  def package(path)
+    first, rest = relative(path).delete_suffix(".rb").split("/", 2)
+    return ROOT_PACKAGE unless rest || folder?(path, first)
+    contested.include?(first) ? "#{parent(path)}/#{first}" : first
+  end
+
+  def relative(path) = path.delete_prefix("#{parent(path)}/")
+
+  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
-  private_class_method :defaults
 
-  def self.descend(directory)
+  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 self.sole(directory)
+  def sole(directory)
     subdirectories = Dir["#{directory}/*/"]
     subdirectories.size == 1 ? subdirectories.first.delete_suffix("/") : nil
   end
-  private_class_method :descend, :sole
 
-  def initialize(directories)
+  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
     missing = directories.reject { Dir.exist?(it) }
     raise(Hashira::Error, "no such directory: #{missing.join(", ")}") unless missing.empty?
-    @directories = directories.map { it.delete_suffix("/") }
-    @rails = @directories.any? { config?(File.expand_path(it)) }
   end
 
-  attr_reader :directories
-
-  def rails? = @rails
-
-  def files = @directories.flat_map { Dir["#{it}/**/*.rb"] }.sort
-
-  def package(path)
-    first, rest = relative(path).delete_suffix(".rb").split("/", 2)
-    return ROOT_PACKAGE unless rest || folder?(path, first)
-    contested.include?(first) ? "#{parent(path)}/#{first}" : first
+  def distinct(directories)
+    pairs = directories.map { [it, File.realpath(it)] }.uniq(&:last)
+    pairs.filter_map { |dir, path| dir unless nested?(path, pairs) }
   end
 
-  def relative(path) = path.delete_prefix("#{parent(path)}/")
-
-  def label = @directories.join(", ")
-
-  def root = ROOT_PACKAGE
-
-  private
+  def nested?(path, pairs) = pairs.any? { path.start_with?("#{it.last}/") }
 
   def config?(directory)
     ["config/application.rb", "../config/application.rb"].any? { File.exist?(File.expand_path(it, directory)) }
@@ -59,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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+class Hashira::Report::Columns
+  CAP = 48
+  HEAD = 23
+  GAP = "  "
+  NUMBER = /\A-?\d+(?:\.\d+)?\z/
+
+  def initialize(headers, rows, io: $stdout)
+    @raw = [headers, *rows]
+    @io = io
+  end
+
+  def print
+    @io.puts(header)
+    @io.puts(rule)
+    body
+  end
+
+  def body = rows.each { @io.puts(line(it)) }
+
+  def header = line(headers)
+
+  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)
+    width = widths[column]
+    numeric[column] ? cell.rjust(width) : cell.ljust(width)
+  end
+
+  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 counted?(column) = rows.all? { NUMBER.match?(it[column]) }
+
+  def down(column) = [headers[column], *rows.map { it[column] }]
+
+  def clip(cell)
+    text = cell.to_s
+    return text if text.length <= CAP
+    "#{text[0, HEAD]}…#{text[(HEAD + 1 - CAP)..]}"
+  end
+end

data/lib/hashira/report/complexity_table.rb

@@ -2,35 +2,31 @@
 
 class Hashira::Report::ComplexityTable
   TOP = 10
-  METHOD_ROW = "%-44s %4s %6s  %s"
-  CLASS_ROW = "%-32s %5s %8s %6s"
+  METHOD_HEADERS = %w[method Cog Calls Loc].freeze
+  CLASS_HEADERS = %w[class Cog Methods Peak].freeze
   METHOD_TITLE = "Cognitive complexity — worst methods (Cog = how hard to read, Calls = message sends)"
   CLASS_TITLE = "Per-class rollup (Cog total survives extract-method; Peak is the worst method it hides)"
 
-  def initialize(complexity, io: $stdout)
+  def initialize(complexity, top: TOP, io: $stdout)
     @complexity = complexity
+    @top = top
     @io = io
   end
 
   def print
-    section(@complexity.ranked, METHOD_ROW, %w[method Cog Calls Loc], METHOD_TITLE)
-    section(@complexity.classes, CLASS_ROW, %w[class Cog Methods Peak], CLASS_TITLE)
+    section(@complexity.ranked, METHOD_HEADERS, METHOD_TITLE)
+    section(@complexity.classes, CLASS_HEADERS, CLASS_TITLE)
   end
 
   private
 
-  def section(scores, row_format, columns, title)
-    heading(row_format, columns, title)
-    ranked(scores).each { @io.puts(format(row_format, *it.cells)) }
-    @io.puts
-  end
-
-  def heading(row_format, columns, title)
-    header = format(row_format, *columns)
+  def section(scores, headers, title)
+    rows = ranked(scores)
+    return if rows.empty?
     @io.puts("#{title}:\n\n")
-    @io.puts(header)
-    @io.puts("-" * header.length)
+    Hashira::Report::Columns.new(headers, rows.map(&:cells), io: @io).print
+    @io.puts
   end
 
-  def ranked(scores) = scores.select { it.cognitive.positive? }.first(TOP)
+  def ranked(scores) = scores.select { it.cognitive.positive? }.first(@top)
 end

data/lib/hashira/report/dependency_map.rb

@@ -9,6 +9,7 @@ class Hashira::Report::DependencyMap
   def print
     @io.puts("Dependencies (DependsUpon(refs) -> | <- UsedBy):")
     @graph.packages.sort.each { @io.puts(row(it)) }
+    @io.puts
   end
 
   private

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

@@ -2,32 +2,24 @@
 
 class Hashira::Report::HotspotTable
   TOP = 10
-  ROW = "%-46s %5s %5s %6s %7s"
+  HEADERS = %w[file Cog Dup Churn Rank].freeze
 
-  def initialize(hotspots, io: $stdout)
+  def initialize(hotspots, top: TOP, io: $stdout)
     @hotspots = hotspots
+    @top = top
     @io = io
   end
 
   def print
     return if ranked.empty?
-    heading
-    rows
+    @io.puts("Hotspots — cost × churn (where refactoring pays the most):\n\n")
+    Hashira::Report::Columns.new(HEADERS, ranked.map(&:cells), io: @io).print
     legend
   end
 
   private
 
-  def ranked = @ranked ||= @hotspots.files.first(TOP)
-
-  def rows = ranked.each { @io.puts(format(ROW, *it.cells)) }
-
-  def heading
-    @io.puts("Hotspots — cost × churn (where refactoring pays the most):\n\n")
-    header = format(ROW, *%w[file Cog Dup Churn Rank])
-    @io.puts(header)
-    @io.puts("-" * header.length)
-  end
+  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

@@ -8,14 +8,22 @@ class Hashira::Report::Json
     @io = io
   end
 
+  SCHEMA = 1
+
   def print
-    @io.puts(JSON.pretty_generate(payload))
+    @io.puts(@view.compact ? JSON.generate(payload) : JSON.pretty_generate(payload))
     0
   end
 
   private
 
-  def payload = base.merge(coupling).merge(sections.compact)
+  def payload = about.merge(base).merge(coupling).merge(sections.compact)
+
+  def about
+    project = @view.project
+    { 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

@@ -1,47 +1,46 @@
 # frozen_string_literal: true
 
 class Hashira::Report::MetricsTable
-  def initialize(graph, io: $stdout)
+  TOP = 25
+
+  def initialize(graph, top: TOP, io: $stdout)
     @graph = graph
+    @top = top
     @io = io
   end
 
-  LIMIT = 25
+  HEADERS = %w[package TC Ca Ce I Cyc].freeze
 
   def print
-    heading
-    kept.each { |package, metric| @io.puts(row(package, metric)) }
+    Hashira::Report::Columns.new(HEADERS, kept.map { |package, metric| row(package, metric) }, io: @io).print
     note unless spared.empty?
+    more unless over.zero?
     legend
   end
 
   private
 
-  def ranked = @graph.metrics.sort_by { |_package, metric| metric.instability }
+  def ranked = @graph.metrics.sort_by { |_package, metric| metric.order }
 
-  def split = @split ||= (ranked.size > LIMIT ? ranked.partition { |_package, metric| !leaf?(metric) } : [ranked, []])
+  def split = @_split ||= (ranked.size > @top ? ranked.partition { |_package, metric| !leaf?(metric) } : [ranked, []])
 
-  def kept = split.first
+  def kept = split.first.first(@top)
 
   def spared = split.last
 
+  def over = split.first.size - kept.size
+
   def leaf?(metric) = metric.types <= 1 && metric.efferent.zero? && metric.afferent <= 1
 
-  def note
-    @io.puts("  + #{spared.size} single-type leaf packages (TC ≤ 1, Ca ≤ 1, Ce = 0) — hidden for brevity")
-  end
+  def note = @io.puts("  + #{leaves} (TC ≤ 1, Ca ≤ 1, Ce = 0) — hidden for brevity")
 
-  def heading
-    @io.puts(format("%-12s %3s %3s %3s %5s  %-3s", *%w[package TC Ca Ce I Cyc]))
-    @io.puts("-" * 40)
-  end
+  def leaves = Hashira::Report::Phrases.count(spared.size, "single-type leaf package")
 
-  def row(package, metric)
-    format(
-      "%-12s %3d %3d %3d %5.2f  %-3s", package, *metric.to_h.values,
-      (@graph.cycles.through?(package) ? "YES" : "-")
-    )
-  end
+  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, cycle(package)]
+
+  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/notices.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class Hashira::Report::Notices
+  ISSUES = "https://github.com/giacope/hashira/issues"
+
+  def initialize(io: $stderr)
+    @io = io
+  end
+
+  def scanning(files) = interactive { @io.puts("hashira: reading #{files} files…") }
+
+  def finished(files, seconds) = interactive { @io.puts("hashira: #{files} files in #{seconds}s") }
+
+  def rails
+    @io.puts("hashira: this looks like a Rails root — `hashira app` reads the application, not just lib/")
+  end
+
+  def churn(label)
+    @io.puts("hashira: no git history for #{label} — hotspots are ranked by cost alone")
+  end
+
+  def crashed(error)
+    @io.puts("hashira: internal error — #{error.class}: #{error.message}")
+    @io.puts("  at #{error.backtrace.first}")
+    @io.puts("  this is a bug in hashira — please report it at #{ISSUES}")
+  end
+
+  def unparsed(count, sample)
+    @io.puts("hashira: #{count} of the files did not parse — #{sample}")
+  end
+
+  private
+
+  def interactive
+    yield if @io.tty?
+  end
+end

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,18 +74,20 @@ 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)
 
+  def count(number, noun) = "#{number} #{number == 1 ? noun : "#{noun}s"}"
+
   def clause(part) = "#{part[:users].join(", ")} #{verb(part)} #{part[:constants].join(", ")}"
 
   def verb(part)
@@ -93,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/text.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 class Hashira::Report::Text
+  FINDINGS = 25
+
   def initialize(view, io: $stdout)
     @view = view
     @io = io
@@ -19,31 +21,37 @@ class Hashira::Report::Text
   def coupling
     graph = @view.graph
     header(graph)
-    Hashira::Report::MetricsTable.new(graph, io: @io).print
+    table(Hashira::Report::MetricsTable, graph)
     Hashira::Report::DependencyMap.new(graph, io: @io).print
     folded(graph.folds)
   end
 
   def folded(folds)
     return if folds.empty?
-    @io.puts("\nFolded (single-type classes joined to their base or domain):")
+    @io.puts("Folded (single-type classes joined to their base or domain):")
     folds.each { @io.puts("  #{it[:from]} -> #{it[:to]} (#{it[:via]})") }
+    @io.puts
   end
 
-  def complexity = Hashira::Report::ComplexityTable.new(@view.complexity, io: @io).print
+  def table(kind, subject) = kind.new(subject, top: @view.top || kind::TOP, io: @io).print
+
+  def complexity = table(Hashira::Report::ComplexityTable, @view.complexity)
 
-  def hotspots = Hashira::Report::HotspotTable.new(@view.hotspots, io: @io).print
+  def hotspots = table(Hashira::Report::HotspotTable, @view.hotspots)
 
   def header(graph)
     packages = graph.packages.size
-    @io.puts(banner(packages))
+    @io.puts(banner(graph.packaging, packages))
     caveat if packages == 1
   end
 
-  def banner(packages)
-    "Package (layer) metrics for #{@view.project.label}  (#{packages} packages, #{total} files)\n\n"
+  def banner(grouping, packages)
+    "Package (#{grouping}) metrics for #{@view.project.label}  " \
+      "(#{count(packages, "package")}, #{count(total, "file")})\n\n"
   end
 
+  def count(number, noun) = Hashira::Report::Phrases.count(number, noun)
+
   def total = @view.project.files.size
 
   def caveat
@@ -55,7 +63,7 @@ class Hashira::Report::Text
 
   def findings
     all = @view.findings.all
-    @io.puts("\nFindings (#{all.size}):")
+    @io.puts("Findings (#{all.size}):")
     list(all)
     accepted
     @io.puts("\n  Full evidence + machine format: hashira --json") unless all.empty?
@@ -63,7 +71,14 @@ class Hashira::Report::Text
 
   def list(all)
     return @io.puts("  none ✓ — structure is healthy") if all.empty?
-    all.each { Hashira::Report::FindingLines.new(it, indent: "  ", io: @io).emit }
+    shown = all.first(@view.top || FINDINGS)
+    shown.each { Hashira::Report::FindingLines.new(it, indent: "  ", io: @io).emit }
+    elided(all.size - shown.size)
+  end
+
+  def elided(rest)
+    return if rest.zero?
+    @io.puts("  … and #{rest} more — raise the cap with --top, or read them all with --json")
   end
 
   def accepted

data/lib/hashira/report/view.rb

@@ -2,6 +2,9 @@
 
 module Hashira
   module Report
-    View = Data.define(:project, :graph, :complexity, :duplication, :hotspots, :findings)
+    View =
+      Data.define(:project, :graph, :complexity, :duplication, :hotspots, :findings, :top, :compact) do
+        def initialize(top: nil, compact: nil, **) = super
+      end
   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