hashira 0.5.1 → 0.7.0

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/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,21 @@ 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, 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, cyc(package)]
+
+  def cyc(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

@@ -81,6 +81,8 @@ module Hashira::Report::Phrases
 
   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)

data/lib/hashira/report/smell_phrases.rb

@@ -19,6 +19,12 @@ module Hashira::Report::Phrases
       "Name the result in a local variable."
   end
 
+  def on_boundary_sprawl(finding)
+    detail = finding.detail
+    "#{detail[:count]} methods across #{detail[:files]} files each pick apart #{finding.package}'s " \
+      "internals. Front the boundary with one adapter the rest can lean on."
+  end
+
   def on_feature_envy(finding)
     detail = finding.detail
     names = detail[:names]

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/boundary_sprawl.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class Hashira::Smells::BoundarySprawl
+  KIND = "boundary_sprawl"
+
+  METHOD_FLOOR = 12
+
+  FILE_FLOOR = 3
+
+  SHOWN = 4
+
+  def initialize(subjects, ownership)
+    @subjects = subjects
+    @ownership = ownership
+  end
+
+  def findings
+    reaches.filter_map { |root, contexts| finding(root, contexts) }
+  end
+
+  private
+
+  def reaches
+    @subjects.each_with_object({}) do |subject, map|
+      Hashira::Smells::Foreign.new(subject, @ownership).reaches.each { (map[it] ||= []) << subject }
+    end
+  end
+
+  def finding(root, contexts)
+    files = contexts.map(&:file).uniq
+    build(root, contexts, files) if wide?(contexts.size, files.size)
+  end
+
+  def wide?(methods, files) = methods >= METHOD_FLOOR && files >= FILE_FLOOR
+
+  def build(root, contexts, files)
+    Hashira::Analysis::Finding.new(
+      kind: KIND, package: root,
+      detail: { count: contexts.size, files: files.size },
+      evidence: contexts.first(SHOWN).map(&:site)
+    )
+  end
+end

data/lib/hashira/smells/census.rb

@@ -6,8 +6,11 @@ class Hashira::Smells::Census
   def initialize(project, trees)
     @project = project
     @trees = trees
+    @ownership = Hashira::Smells::Ownership.new(trees.values)
   end
 
+  attr_reader :ownership
+
   def types = @trees.flat_map { |path, tree| harvest(@project.relative(path), tree) }
 
   private
@@ -26,7 +29,7 @@ class Hashira::Smells::Census
 
   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:)
+      Hashira::Smells::MethodContext.new(owner: name, node: def_node, file:, section:, ownership: @ownership)
     end
   end
 end

data/lib/hashira/smells/contexts.rb

@@ -32,7 +32,7 @@ module Hashira
     end
 
     MethodContext =
-      Data.define(:owner, :node, :file, :section) do
+      Data.define(:owner, :node, :file, :section, :ownership) do
         def subject = "#{owner}#{singleton? ? "." : "#"}#{node.name}"
 
         def line = node.location.start_line

data/lib/hashira/smells/feature_envy.rb

@@ -9,7 +9,9 @@ class Hashira::Smells::FeatureEnvy < Hashira::Smells::Check
 
   def refs = @refs ||= Hashira::Smells::Refs.new(subject.node)
 
-  def envied = @envied ||= refs.envious
+  def envied = @envied ||= refs.envious.reject { foreign.dismiss?(it) }
+
+  def foreign = @foreign ||= Hashira::Smells::Foreign.new(subject, subject.ownership)
 
   def detail = { site:, names: envied }
 

data/lib/hashira/smells/foreign.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Smells::Foreign
+  TYPE_TESTS = %i[is_a? kind_of? instance_of?].freeze
+
+  KEYED_READS = %i[[] fetch values_at dig key?].freeze
+
+  KEYS = [Prism::StringNode, Prism::SymbolNode].freeze
+
+  LITERALS = [Prism::HashNode, Prism::KeywordHashNode, Prism::ArrayNode, Prism::StringNode].freeze
+
+  STATE = [
+    Prism::InstanceVariableReadNode, Prism::InstanceVariableWriteNode,
+    Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableAndWriteNode,
+    Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableTargetNode
+  ].freeze
+
+  def initialize(subject, ownership)
+    node = subject.node
+    @body = Hashira::Smells::Scope.inside(node)
+    @tail = tail(node)
+    @ownership = ownership
+  end
+
+  def dismiss?(name)
+    convert? || fenced?(name) || wire?(name) || built?(name) ||
+      derived?(name) || rescued?(name)
+  end
+
+  def reaches
+    tests { true }.reject { @ownership.owned?(it) }.map(&:first).uniq
+  end
+
+  private
+
+  def convert?
+    @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 fenced?(name)
+    tested = tests { it == name }
+    tested.any? && tested.none? { @ownership.owned?(it) }
+  end
+
+  def wire?(name)
+    calls = @body.grep(Prism::CallNode).select { |call| local?(call.receiver) { it == name } }
+    calls.any? && calls.all? { keyed?(it) } && reassignments(name).none?
+  end
+
+  def built?(name)
+    writes(name).any? { LITERALS.include?(it.value.class) }
+  end
+
+  def derived?(name)
+    writes(name).any? { spawned?(it.value) }
+  end
+
+  def rescued?(name)
+    snares(name).any? { alien?(it.exceptions) }
+  end
+
+  def keyed?(call)
+    names = call.arguments&.arguments
+    KEYED_READS.include?(call.name) && names&.any? &&
+      names.all? { KEYS.include?(it.class) }
+  end
+
+  def writes(name) = among(Prism::LocalVariableWriteNode, name)
+
+  def reassignments(name) = among(Prism::LocalVariableOperatorWriteNode, name)
+
+  def among(kind, name)
+    @body.grep(kind).select { it.name == name }
+  end
+
+  def snares(name)
+    @body.grep(Prism::RescueNode).select { it.reference&.name == name }
+  end
+
+  def alien?(exceptions)
+    exceptions.map { Hashira::Analysis::Syntax.segments(it) }.none? { @ownership.owned?(it) }
+  end
+
+  def spawned?(value)
+    value.is_a?(Prism::CallNode) && stranger?(value.receiver)
+  end
+
+  def stranger?(node)
+    case node
+    when Prism::LocalVariableReadNode then fenced?(node.name)
+    when Prism::ConstantReadNode, Prism::ConstantPathNode then unowned?(node)
+    else false
+    end
+  end
+
+  def unowned?(node)
+    !@ownership.owned?(Hashira::Analysis::Syntax.segments(node))
+  end
+
+  def tests(&)
+    (probes(&) + arms(&)).map { Hashira::Analysis::Syntax.segments(it) }.reject(&:empty?) + lookups(&)
+  end
+
+  def probes(&)
+    @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)
+  end
+
+  def lookups(&)
+    @body.grep(Prism::CallNode).select { it.name == :[] && sorts?(key(it), &) }.flat_map { @ownership.keys(Hashira::Analysis::Syntax.segments(it.receiver)) }
+  end
+
+  def sorts?(argument, &)
+    argument.is_a?(Prism::CallNode) && argument.name == :class &&
+      local?(argument.receiver, &)
+  end
+
+  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/ownership.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class Hashira::Smells::Ownership
+  def initialize(trees)
+    @suffixes = Set.new
+    @tables = {}
+    trees.each { survey(it) }
+  end
+
+  def owned?(segments) = @suffixes.include?(segments.join("::"))
+
+  def keys(segments) = @tables.fetch(segments.join("::"), [])
+
+  private
+
+  def survey(tree)
+    Hashira::Analysis::TypeWalk.each(tree) do |node, full|
+      absorb(full)
+      Hashira::Analysis::Syntax.constants(node).each { record(full, it) }
+    end
+  end
+
+  def record(full, constant)
+    path = full + [constant.name.to_s]
+    absorb(path)
+    chart(path, thaw(constant.value))
+  end
+
+  def absorb(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 }
+  end
+
+  def thaw(value)
+    frozen?(value) ? value.receiver : value
+  end
+
+  def frozen?(value) = value.is_a?(Prism::CallNode) && value.name == :freeze
+
+  def spine(element)
+    return unless element.is_a?(Prism::AssocNode)
+    segments = Hashira::Analysis::Syntax.segments(element.key)
+    segments unless segments.empty?
+  end
+
+  def suffixes(path)
+    path.each_index.map { path.drop(it).join("::") }
+  end
+end

data/lib/hashira/smells/report.rb

@@ -1,14 +1,17 @@
 # frozen_string_literal: true
 
+require_relative "boundary_sprawl"
 require_relative "check"
 require_relative "control_parameter"
 require_relative "data_clump"
 require_relative "duplicate_method_call"
 require_relative "feature_envy"
+require_relative "foreign"
 require_relative "instance_variable_assumption"
 require_relative "manual_dispatch"
 require_relative "module_initialize"
 require_relative "nil_check"
+require_relative "ownership"
 require_relative "repeated_conditional"
 require_relative "too_many_instance_variables"
 require_relative "utility_function"
@@ -21,13 +24,18 @@ class Hashira::Smells::Report
   PROBES = CHECKS.reject(&:judge?).freeze
 
   def initialize(project, trees)
-    @types = Hashira::Smells::Census.new(project, trees).types
+    @census = Hashira::Smells::Census.new(project, trees)
+    @types = @census.types
   end
 
-  def findings = @findings ||= sniff(@types, JUDGES) + sniff(@types.flat_map(&:defs), PROBES)
+  def findings = @findings ||= sniff(@types, JUDGES) + sniff(methods, PROBES) + sprawl
 
   private
 
+  def methods = @types.flat_map(&:defs)
+
+  def sprawl = Hashira::Smells::BoundarySprawl.new(methods, @census.ownership).findings
+
   def sniff(subjects, checks) = subjects.flat_map { |subject| verdicts(subject, checks) }
 
   def verdicts(subject, checks) = checks.filter_map { |check| check.new(subject).finding }

data/lib/hashira/trees.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Trees
+  def initialize(project)
+    @unparsed = []
+    @all = project.files.to_h { [it, parse(it)] }
+  end
+
+  attr_reader :all, :unparsed
+
+  private
+
+  def parse(path)
+    result = Prism.parse_file(path)
+    @unparsed << path if result.failure?
+    result.value
+  rescue SystemCallError => error
+    raise(Hashira::Error, "cannot read #{path} (#{error.message})")
+  end
+end