hashira 0.7.0 → 0.8.0

data/lib/hashira/cli/options.rb

@@ -1,25 +1,23 @@
 # frozen_string_literal: true
 
 class Hashira::CLI
-  PAGE = { directories: [], baseline: "", fail_on: [], skip: [], packaging: :auto, top: nil, compact: nil }.freeze
-
   Options =
-    Data.define(:directories, :mode, :baseline, :fail_on, :skip, :packaging, :top, :compact) do
+    Data.define(:directories, :mode, :baseline, :fail_on, :skip, :only, :packaging, :top, :compact) do
       def self.parse(argv) = CommandLine.new(argv).options
 
-      def self.page(mode) = new(**PAGE, mode:)
-
-      def initialize(**attributes)
-        super
-        Needs.check(self)
+      def self.build(mode)
+        new(
+          directories: [], baseline: "", fail_on: [], skip: [], only: [],
+          packaging: :auto, top: nil, compact: nil, mode:
+        )
       end
 
       def pipeline
-        chosen = Hashira::Project.detect(directories)
+        chosen = Hashira::Project.new(directories)
         told = Hashira::Report::Notices.new
         told.scanning(chosen.files.size)
         told.rails if directories.empty? && File.exist?("config/application.rb")
-        Hashira::Pipeline.new(chosen, enabled: analyzers, packaging:)
+        Hashira::Pipeline.new(chosen, enabled: analyzers, packaging:, only:)
       end
 
       def analyzers = Hashira::Pipeline::ANALYZERS - skip

data/lib/hashira/cli/package_by.rb

@@ -9,6 +9,6 @@ module Hashira::CLI::PackageBy
     return :auto if value.empty?
     choice = value.to_sym
     return choice if CHOICES.include?(choice)
-    raise(Hashira::Error.unknown("--package-by", value, CHOICES))
+    raise(Hashira::CLI::Choice.unknown("--package-by", value, CHOICES))
   end
 end

data/lib/hashira/cli/run.rb

@@ -1,26 +1,27 @@
 # frozen_string_literal: true
 
 class Hashira::CLI::Run
-  MODES = { update: :update, ratchet: :check, fail_on: :guard, json: :json, dot: :diagram, mermaid: :diagram }.freeze
-
   def initialize(pipeline, options)
     @pipeline = pipeline
     @options = options
   end
 
+  MODES = { update: :update, ratchet: :check, fail_on: :guard }
+    .merge(json: :json, dot: :diagram, mermaid: :diagram).freeze
+
   def status = __send__(MODES.fetch(@options.mode, :text))
 
   private
 
   def graph = @pipeline.graph
 
-  def findings = @findings ||= accepted.screen(@pipeline.findings)
+  def findings = @_findings ||= accepted.screen(@pipeline.findings)
 
   def accepted
     path = @options.baseline
-    stop = Hashira::CI::Baseline.trouble(path)
+    stop = Hashira::CI::Baseline.new(path).trouble
     raise(Hashira::Error, stop) if stop
-    Hashira::CI::Accepted.load(path)
+    Hashira::CI::Accepted.build(path)
   end
 
   def update
@@ -32,7 +33,7 @@ class Hashira::CLI::Run
   def check
     stop = ratchet.blocker
     raise(Hashira::Error, stop) if stop
-    ratchet.check
+    ratchet.check(@pipeline.focus)
   end
 
   def guard = gate.check
@@ -55,10 +56,10 @@ class Hashira::CLI::Run
     told.unparsed(broken.size, broken.first(3).join(", ")) unless broken.empty?
   end
 
-  def ratchet = @ratchet ||= Hashira::CI::Ratchet.new(graph, findings.all, baseline)
+  def ratchet = @_ratchet ||= Hashira::CI::Ratchet.new(graph, findings.all, baseline)
 
   def baseline
-    Hashira::CI::Baseline.load(@options.baseline, analyzers: @options.analyzers, targets:)
+    Hashira::CI::Baseline.new(@options.baseline, analyzers: @options.analyzers, targets:)
   end
 
   def targets = @pipeline.project.directories

data/lib/hashira/cli.rb

@@ -4,40 +4,41 @@ class Hashira::CLI
   MISUSE = 2
   BROKEN = 70
 
-  def self.run(argv)
-    dispatch(Options.parse(argv))
+  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.dispatch(options) = usage?(options) ? Usage.public_send(options.mode) : new(options).run
+  private
+
+  def dispatch(options) = usage?(options) ? Usage.public_send(options.mode) : timed(options)
+
+  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 self.usage?(options) = Usage::PAGES.include?(options.mode)
+  def elapsed(started) = format("%.1f", Process.clock_gettime(Process::CLOCK_MONOTONIC) - started)
 
-  def self.failure(error)
+  def failure(error)
     Kernel.warn("hashira: #{error.message}")
     MISUSE
   end
 
-  def self.crash(error)
+  def crash(error)
     Hashira::Report::Notices.new.crashed(error)
     BROKEN
   end
-
-  def initialize(options)
-    @started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    @options = options
-    @notices = Hashira::Report::Notices.new
-    @pipeline = options.pipeline
-  end
-
-  def run
-    Run.new(@pipeline, @options).status.tap { @notices.finished(@pipeline.project.files.size, elapsed) }
-  end
-
-  private
-
-  def elapsed = format("%.1f", Process.clock_gettime(Process::CLOCK_MONOTONIC) - @started)
 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))