hashira 0.6.0 → 0.8.0

data/lib/hashira/cli.rb

@@ -1,24 +1,44 @@
 # frozen_string_literal: true
 
 class Hashira::CLI
-  def self.run(argv)
-    options = Options.parse(argv)
-    usage?(options) ? Usage.public_send(options.mode) : new(options).run
+  MISUSE = 2
+  BROKEN = 70
+
+  def initialize(argv)
+    @argv = argv
+  end
+
+  def status
+    dispatch(Options.parse(@argv))
   rescue Hashira::Error => error
     failure(error)
+  rescue StandardError => error
+    crash(error)
   end
 
-  def self.usage?(options) = Usage::PAGES.include?(options.mode)
+  private
+
+  def dispatch(options) = usage?(options) ? Usage.public_send(options.mode) : timed(options)
 
-  def self.failure(error)
-    warn("hashira: #{error.message}")
-    1
+  def usage?(options) = Usage::PAGES.include?(options.mode)
+
+  def timed(options)
+    started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    pipeline = options.pipeline
+    Run.new(pipeline, options).status.tap do
+      Hashira::Report::Notices.new.finished(pipeline.project.files.size, elapsed(started))
+    end
   end
 
-  def initialize(options)
-    @options = options
-    @pipeline = options.pipeline
+  def elapsed(started) = format("%.1f", Process.clock_gettime(Process::CLOCK_MONOTONIC) - started)
+
+  def failure(error)
+    Kernel.warn("hashira: #{error.message}")
+    MISUSE
   end
 
-  def run = Run.new(@pipeline, @options).status
+  def crash(error)
+    Hashira::Report::Notices.new.crashed(error)
+    BROKEN
+  end
 end

data/lib/hashira/complexity/cognitive_score.rb

@@ -3,37 +3,35 @@
 require "prism"
 
 class Hashira::Complexity::CognitiveScore
-  HANDLERS = {
-    Prism::IfNode => :on_if,
-    Prism::UnlessNode => :on_nester,
-    Prism::WhileNode => :on_nester,
-    Prism::UntilNode => :on_nester,
-    Prism::ForNode => :on_nester,
-    Prism::CaseNode => :on_nester,
-    Prism::CaseMatchNode => :on_nester,
-    Prism::BeginNode => :on_begin,
-    Prism::AndNode => :on_boolean,
-    Prism::OrNode => :on_boolean,
-    Prism::BlockNode => :on_block,
-    Prism::CallNode => :on_call
-  }.freeze
-
-  LABELS = {
-    Prism::UnlessNode => "unless", Prism::WhileNode => "while",
-    Prism::UntilNode => "until", Prism::ForNode => "for",
-    Prism::CaseNode => "case", Prism::CaseMatchNode => "case"
-  }.freeze
-
-  def initialize(def_node)
-    @increments = []
-    @calls = 0
-    @nesting = 0
-    visit(def_node.body)
+  HANDLERS = { Prism::IfNode => :on_if, Prism::BeginNode => :on_begin, Prism::BlockNode => :on_block }
+    .merge(Prism::AndNode => :on_boolean, Prism::OrNode => :on_boolean, Prism::CallNode => :on_call)
+    .merge(Prism::UnlessNode => :on_nester, Prism::WhileNode => :on_nester, Prism::UntilNode => :on_nester)
+    .merge(Prism::ForNode => :on_nester, Prism::CaseNode => :on_nester, Prism::CaseMatchNode => :on_nester)
+    .freeze
+
+  LABELS = { Prism::UnlessNode => "unless", Prism::WhileNode => "while", Prism::UntilNode => "until" }
+    .merge(Prism::ForNode => "for", Prism::CaseNode => "case", Prism::CaseMatchNode => "case").freeze
+
+  def initialize(node)
+    @node = node
+  end
+
+  def increments
+    walked
+    @_increments
   end
 
-  attr_reader :increments, :calls, :nesting
+  def calls
+    walked
+    @_calls
+  end
 
-  def total = @increments.sum(&:cost)
+  def nesting
+    walked
+    @_nesting
+  end
+
+  def total = increments.sum(&:cost)
 
   def visit(node)
     return unless node
@@ -41,28 +39,41 @@ class Hashira::Complexity::CognitiveScore
   end
 
   def add(node, cost, label)
-    @increments << Hashira::Complexity::Increment.new(line: node.location.start_line, cost:, label:)
+    @_increments << Hashira::Complexity::Increment.new(line: node.location.start_line, cost:, label:)
   end
 
   def deeper
-    @nesting += 1
+    @_nesting += 1
     yield
-    @nesting -= 1
+    @_nesting -= 1
   end
 
   private
 
+  def walked
+    return if @_walked
+    @_walked = true
+    blank
+    visit(@node.body)
+  end
+
+  def blank
+    @_increments = []
+    @_calls = 0
+    @_nesting = 0
+  end
+
   def descend(node) = node.compact_child_nodes.each { visit(it) }
 
   def on_call(node)
-    @calls += 1
+    @_calls += 1
     descend(node)
   end
 
   def on_block(node) = deeper { descend(node) }
 
   def on_nester(node)
-    add(node, 1 + @nesting, LABELS.fetch(node.class))
+    add(node, 1 + @_nesting, LABELS.fetch(node.class))
     deeper { descend(node) }
   end
 

data/lib/hashira/complexity/method_finding.rb

@@ -3,6 +3,8 @@
 class Hashira::Complexity::MethodFinding
   KIND = "complexity"
 
+  Effort = Data.define(:cognitive, :calls, :site, :dominant)
+
   def initialize(score)
     @score = score
   end
@@ -14,16 +16,16 @@ class Hashira::Complexity::MethodFinding
   private
 
   def detail
-    { cognitive: @score.cognitive, calls: @score.calls, site: "#{@score.file}:#{@score.line}", dominant: }
+    Effort.new(cognitive: @score.cognitive, calls: @score.calls, site: "#{@score.file}:#{@score.line}", dominant:)
   end
 
   def evidence
-    @score.increments.group_by(&:label).map { |label, incs| lines(label, incs) }
+    @score.increments.group_by(&:label).map { |label, increments| lines(label, increments) }
   end
 
-  def lines(label, incs)
-    lines = incs.map(&:line).uniq
-    "#{label} +#{incs.sum(&:cost)} (line#{"s" if lines.size > 1} #{lines.join(", ")})"
+  def lines(label, increments)
+    lines = increments.map(&:line).uniq
+    "#{label} +#{increments.sum(&:cost)} (line#{"s" if lines.size > 1} #{lines.join(", ")})"
   end
 
   def dominant

data/lib/hashira/complexity/method_score.rb

@@ -6,7 +6,7 @@ module Hashira
 
     MethodScore =
       Data.define(:subject, :file, :line, :cognitive, :calls, :increments) do
-        def to_h = { subject:, file:, line:, cognitive:, calls: }
+        def to_h = super.except(:increments)
 
         def cells = [subject, cognitive, calls, "#{file}:#{line}"]
       end

data/lib/hashira/complexity/scores.rb

@@ -5,35 +5,37 @@ class Hashira::Complexity::Scores
 
   def initialize(project, trees)
     @project = project
-    @scores = trees.flat_map { |path, tree| harvest(path, tree) }
+    @trees = trees
   end
 
-  def ranked = @scores.sort_by { -it.cognitive }
+  def ranked = scores.sort_by { -it.cognitive }
 
-  def classes = Hashira::Complexity::Rollup.new(@scores).classes.sort_by { -it.cognitive }
+  def classes = Hashira::Complexity::Rollup.new(scores).classes.sort_by { -it.cognitive }
 
   def findings = flagged.map { Hashira::Complexity::MethodFinding.new(it).to_finding }
 
   private
 
+  def scores = @_scores ||= @trees.flat_map { |path, tree| harvest(path, tree) }
+
   def flagged = ranked.select { it.cognitive >= THRESHOLD }
 
   def harvest(path, tree)
-    rel = @project.relative(path)
-    sites(tree).map { |full, node| score(rel, full, node) }
+    relative = @project.relative(path)
+    sites(tree).map { |full, node| score(relative, full, node) }
   end
 
   def sites(tree)
     found = []
-    Hashira::Analysis::TypeWalk.each(tree) do |type_node, full|
-      Hashira::Analysis::Syntax.direct(type_node).each { found << [full, it] }
+    Hashira::Analysis::TypeWalk.each(tree) do |type, full|
+      Hashira::Analysis::Syntax.direct(type).each { found << [full, it] }
     end
     found
   end
 
-  def score(rel, full, node)
+  def score(relative, full, node)
     Hashira::Complexity::MethodScore.new(
-      subject: subject(full, node), file: rel, line: node.location.start_line,
+      subject: subject(full, node), file: relative, line: node.location.start_line,
       **tallies(Hashira::Complexity::CognitiveScore.new(node))
     )
   end

data/lib/hashira/coupling/audiences.rb

@@ -11,13 +11,13 @@ class Hashira::Coupling::Audiences
 
   def split? = parts.size >= 2
 
-  def parts = @parts ||= [common, *slices].compact.select { it.constants.size >= MIN }
+  def parts = @_parts ||= [common, *slices].compact.select { it.constants.size >= MIN }
 
   private
 
-  def clients = @clients ||= @usage.keys.sort
+  def clients = @_clients ||= @usage.keys.sort
 
-  def shared = @shared ||= tally.select { |_constant, users| users.size * 2 > clients.size }.keys.to_set
+  def shared = @_shared ||= tally.select { |_constant, users| users.size * 2 > clients.size }.keys.to_set
 
   def tally
     clients.each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |client, seen|

data/lib/hashira/coupling/catalog.rb

@@ -5,15 +5,13 @@ class Hashira::Coupling::Catalog
 
   def initialize(definitions)
     @definitions = definitions
-    @naming = Hashira::Coupling::Naming.new(definitions)
-    @entries = definitions.map { |node, full, folder| entry(node, full, folder) }
   end
 
-  def each(&) = @entries.each(&)
+  def each(&) = entries.each(&)
 
-  def prefix = @naming.segments
+  def prefix = naming.segments
 
-  def strip(path) = @naming.strip(path)
+  def strip(path) = naming.strip(path)
 
   def roots = @definitions.roots
 
@@ -21,7 +19,11 @@ class Hashira::Coupling::Catalog
 
   private
 
+  def naming = @_naming ||= Hashira::Coupling::Naming.new(@definitions)
+
+  def entries = @_entries ||= @definitions.map { |node, full, folder| entry(node, full, folder) }
+
   def entry(node, full, folder)
-    Hashira::Coupling::Definition.new(node:, path: @naming.strip(full), folder:)
+    Hashira::Coupling::Definition.new(node:, path: naming.strip(full), folder:)
   end
 end

data/lib/hashira/coupling/census.rb

@@ -2,28 +2,26 @@
 
 class Hashira::Coupling::Census
   def initialize(project, trees, packaging: :folder)
-    @catalog = Hashira::Coupling::Catalog.new(Hashira::Coupling::Definitions.new(project, trees))
-    @placement = Hashira::Coupling::Placement.build(packaging, project, @catalog)
-    @folding = Hashira::Coupling::NoFolding
-    @roster = tally
-    settle
+    @project = project
+    @trees = trees
+    @packaging = packaging
   end
 
-  def packaging = @placement.mode
+  def packaging = placement.mode
 
-  def types = @roster.types
+  def types = roster.types
 
-  def prefix = @catalog.prefix
+  def prefix = catalog.prefix
 
-  def origins = @roster.origins
+  def origins = roster.origins
 
-  def roots = @catalog.roots
+  def roots = catalog.roots
 
-  def packages = @roster.packages | @placement.baseline
+  def packages = roster.packages | placement.baseline
 
-  def folds = @folding.disclosed
+  def folds = folding.disclosed
 
-  def strip(segments) = @catalog.strip(segments)
+  def strip(segments) = catalog.strip(segments)
 
   def holder(segments)
     path = strip(segments)
@@ -34,22 +32,44 @@ class Hashira::Coupling::Census
 
   def pinpoint(segments) = scope.pinpoint(segments)
 
-  def charge(file, nesting) = translate(@placement.charge(file, nesting))
+  def charge(file, nesting) = translate(placement.charge(file, nesting))
 
   private
 
-  def type?(segments) = @roster.type?(segments)
+  def catalog = @_catalog ||= Hashira::Coupling::Catalog.new(Hashira::Coupling::Definitions.new(@project, @trees))
 
-  def tally
-    Hashira::Coupling::Roster.new(@placement.placed.map { |definition, package| [definition, translate(package)] })
+  def placement = @_placement ||= Hashira::Coupling::Placement.build(@packaging, @project, catalog)
+
+  def roster
+    settled
+    @_roster
+  end
+
+  def folding
+    settled
+    @_folding
+  end
+
+  def settled
+    return if @_settled
+    @_settled = true
+    @_folding = Hashira::Coupling::NoFolding
+    @_roster = tally
+    refold
+  end
+
+  def refold
+    @_folding = placement.folding(self)
+    @_roster = tally unless @_folding.map.empty?
   end
 
-  def settle
-    @folding = @placement.folding(self)
-    @roster = tally unless @folding.map.empty?
+  def type?(segments) = roster.type?(segments)
+
+  def tally
+    Hashira::Coupling::Roster.new(placement.placed.map { |definition, package| [definition, translate(package)] })
   end
 
-  def translate(package) = @folding.map.fetch(package, package)
+  def translate(package) = folding.map.fetch(package, package)
 
-  def scope = Hashira::Coupling::Scope.new(@roster.registry, @catalog, @placement)
+  def scope = Hashira::Coupling::Scope.new(roster.registry, catalog, placement)
 end

data/lib/hashira/coupling/cycle_search.rb

@@ -4,8 +4,6 @@ class Hashira::Coupling::CycleSearch
   def initialize(dependencies, package)
     @dependencies = dependencies
     @package = package
-    @predecessor = {}
-    @queue = dependencies[package].to_a.each { @predecessor[it] = package }
   end
 
   def path
@@ -14,8 +12,14 @@ class Hashira::Coupling::CycleSearch
 
   private
 
+  def prepare
+    @_predecessor = {}
+    @_queue = @dependencies[@package].to_a.each { @_predecessor[it] = @package }
+  end
+
   def cycle?
-    while (node = @queue.shift)
+    prepare
+    while (node = @_queue.shift)
       return true if node == @package
       visit(node)
     end
@@ -23,15 +27,15 @@ class Hashira::Coupling::CycleSearch
 
   def visit(node)
     @dependencies[node].each do |neighbor|
-      next if @predecessor.key?(neighbor)
-      @predecessor[neighbor] = node
-      @queue << neighbor
+      next if @_predecessor.key?(neighbor)
+      @_predecessor[neighbor] = node
+      @_queue << neighbor
     end
   end
 
   def unwind(path)
     first = path.first
     return path if first == @package && path.size > 1
-    unwind(path.unshift(@predecessor[first]))
+    unwind(path.unshift(@_predecessor[first]))
   end
 end

data/lib/hashira/coupling/definitions.rb

@@ -15,7 +15,7 @@ class Hashira::Coupling::Definitions
   def packages = @trees.keys.map { @project.package(it) }.uniq
 
   def roots
-    @roots ||= @trees.each_value.with_object(Set.new) { |tree, set| survey(tree, set) }
+    @_roots ||= @trees.each_value.with_object(Set.new) { |tree, set| survey(tree, set) }
   end
 
   private

data/lib/hashira/coupling/edge_map.rb

@@ -3,15 +3,16 @@
 class Hashira::Coupling::EdgeMap
   def initialize(census)
     @census = census
-    @dependencies = sets
-    @evidence = sets
-    @usage = sets
   end
 
-  attr_reader :dependencies, :evidence, :usage
+  def dependencies = @_dependencies ||= sets
+
+  def evidence = @_evidence ||= sets
+
+  def usage = @_usage ||= sets
 
   def record(source, file, tree)
-    Hashira::Coupling::References.sightings(tree, @census.roots).each do |segments, line, nesting, home|
+    Hashira::Coupling::References.new(@census.roots).sightings(tree).each do |segments, line, nesting, home|
       note(@census.charge(file, home), locate(segments, nesting), segments, "#{source}:#{line}")
     end
   end
@@ -26,8 +27,8 @@ class Hashira::Coupling::EdgeMap
 
   def note(from, to, segments, site)
     return unless to && to != from
-    @dependencies[from] << to
-    @evidence[[from, to]] << "#{site}: #{segments.join("::")}"
-    @usage[[from, to]] << @census.holder(segments)
+    dependencies[from] << to
+    evidence[[from, to]] << "#{site}: #{segments.join("::")}"
+    usage[[from, to]] << @census.holder(segments)
   end
 end

data/lib/hashira/coupling/folding.rb

@@ -11,7 +11,7 @@ class Hashira::Coupling::Folding
     @suffixes = suffixes
   end
 
-  def map = @map ||= links.keys.to_h { [it, settle(it, links)] }.reject { |from, to| from == to }
+  def map = @_map ||= links.keys.to_h { [it, settle(it, links)] }.reject { |from, to| from == to }
 
   def disclosed
     map.map { |from, to| { from:, to:, via: parents.key?(from) ? "base" : "suffix" } }
@@ -19,10 +19,10 @@ class Hashira::Coupling::Folding
 
   private
 
-  def links = @links ||= named.merge(parents)
+  def links = @_links ||= named.merge(parents)
 
   def parents
-    @parents ||= singles.select { |_name, one| one.superclass }.to_h { |name, one| [name, target(one)] }.compact
+    @_parents ||= singles.select { |_name, one| one.superclass }.to_h { |name, one| [name, target(one)] }.compact
   end
 
   def named
@@ -38,11 +38,11 @@ class Hashira::Coupling::Folding
 
   def trims?(name, suffix) = name.end_with?(suffix) && name != suffix
 
-  def singles = @singles ||= lone.group_by(&:name).transform_values { it.find(&:superclass) || it.last }
+  def singles = @_singles ||= lone.group_by(&:name).transform_values { it.find(&:superclass) || it.last }
 
   def lone = @definitions.select(&:singular?).reject { anchored.include?(it.name) }
 
-  def anchored = @anchored ||= @definitions.select(&:nested?).to_set(&:name)
+  def anchored = @_anchored ||= @definitions.select(&:nested?).to_set(&:name)
 
   def target(one) = @census.pinpoint(Hashira::Analysis::Syntax.segments(one.superclass))
 

data/lib/hashira/coupling/graph.rb

@@ -2,18 +2,18 @@
 
 class Hashira::Coupling::Graph
   def initialize(project, trees, census)
+    @project = project
     @census = census
     @trees = trees
-    @map = Hashira::Coupling::EdgeMap.new(census)
-    trees.each { |file, tree| @map.record(project.relative(file), file, tree) }
-    @cycles = Hashira::Coupling::Cycles.new(@map.dependencies, self)
   end
 
-  attr_reader :cycles, :trees
+  attr_reader :trees
+
+  def cycles = @_cycles ||= Hashira::Coupling::Cycles.new(map.dependencies, self)
 
   def charge(file) = @census.charge(file, [])
 
-  def packages = (@census.packages | @map.dependencies.keys)
+  def packages = (@census.packages | dependencies.keys)
 
   def packaging = @census.packaging
 
@@ -34,13 +34,13 @@ class Hashira::Coupling::Graph
     end
   end
 
-  def evidence(from, to) = @map.evidence[[from, to]]
+  def evidence(from, to) = map.evidence[[from, to]]
 
-  def usage(package) = incoming(package).to_h { [it, @map.usage[[it, package]]] }
+  def usage(package) = incoming(package).to_h { [it, map.usage[[it, package]]] }
 
   def constants(edge)
     from, to = edge.deconstruct
-    @map.usage[[from, to]].sort
+    map.usage[[from, to]].sort
   end
 
   def metric(package)
@@ -59,5 +59,12 @@ class Hashira::Coupling::Graph
 
   private
 
-  def dependencies = @map.dependencies
+  def map
+    @_map ||=
+      Hashira::Coupling::EdgeMap.new(@census).tap do |edges|
+        @trees.each { |file, tree| edges.record(@project.relative(file), file, tree) }
+      end
+  end
+
+  def dependencies = map.dependencies
 end

data/lib/hashira/coupling/metric.rb

@@ -9,7 +9,15 @@ module Hashira
           total.zero? ? 0.0 : efferent.fdiv(total)
         end
 
-        def to_h = { tc: types, ca: afferent, ce: efferent, i: instability }
+        def isolated? = (efferent + afferent).zero?
+
+        def order = [isolated? ? 1 : 0, instability]
+
+        def to_h = counts.merge(i: (instability unless isolated?))
+
+        def counts = { tc: types, ca: afferent, ce: efferent }
+
+        def cells = [types, afferent, efferent, isolated? ? "—" : format("%.2f", instability)]
       end
   end
 end

data/lib/hashira/coupling/naming.rb

@@ -2,13 +2,13 @@
 
 class Hashira::Coupling::Naming
   def initialize(definitions)
-    @segments = Hashira::Coupling::NamespacePrefix.infer(definitions)
+    @definitions = definitions
   end
 
-  attr_reader :segments
+  def segments = @_segments ||= Hashira::Coupling::NamespacePrefix.infer(@definitions)
 
   def strip(path)
-    return [] if @segments.first(path.length) == path
-    path.drop(@segments.length.downto(0).find { path.first(it) == @segments.last(it) })
+    return [] if segments.first(path.length) == path
+    path.drop(segments.length.downto(0).find { path.first(it) == segments.last(it) })
   end
 end

data/lib/hashira/coupling/references.rb

@@ -3,34 +3,34 @@
 require "prism"
 
 class Hashira::Coupling::References
-  def self.list(tree) = new.sightings(tree).map(&:first)
-
-  def self.sightings(tree, roots = nil) = new(roots).sightings(tree)
-
   def initialize(roots = nil)
     @roots = roots
-    @found = []
-    @scopes = [[]]
   end
 
+  def list(tree) = sightings(tree).map(&:first)
+
   def sightings(tree)
     collect(tree)
-    @found
+    found
   end
 
   private
 
-  def nesting = @scopes.last
+  def found = @_found ||= []
+
+  def scopes = @_scopes ||= [[]]
+
+  def nesting = scopes.last
 
   def collect(node, home = nesting)
     return unless node
-    return @found << sighting(node, home) if constant?(node)
+    return found << sighting(node, home) if constant?(node)
     return enter(node) if definition?(node)
     node.compact_child_nodes.each { collect(it, home) }
   end
 
   def sighting(node, home)
-    [syntax.segments(node), node.location.start_line, syntax.cbase?(node) ? nil : nesting, home]
+    [syntax.segments(node), node.location.start_line, syntax.rooted?(node) ? nil : nesting, home]
   end
 
   def syntax = Hashira::Analysis::Syntax
@@ -48,8 +48,8 @@ class Hashira::Coupling::References
   def anchor(node) = syntax.anchor(nesting, syntax.segments(node.constant_path), @roots)
 
   def inside(scope)
-    @scopes << scope
+    scopes << scope
     yield
-    @scopes.pop
+    scopes.pop
   end
 end