hashira 0.7.0 → 0.9.0

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

@@ -14,16 +14,10 @@ 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) }
-  end
+  def roots = @_roots ||= Hashira::Analysis::TypeWalk.roots(@trees)
 
   private
 
-  def survey(tree, set)
-    Hashira::Analysis::TypeWalk.each(tree) { |_node, full| set << full }
-  end
-
   def scan(file, tree)
     package = @project.package(file)
     Hashira::Analysis::TypeWalk.each(tree, roots: roots) do |node, full|

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

@@ -13,7 +13,9 @@ module Hashira
 
         def order = [isolated? ? 1 : 0, instability]
 
-        def to_h = { tc: types, ca: afferent, ce: efferent, i: (instability unless isolated?) }
+        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

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

data/lib/hashira/coupling/report.rb

@@ -3,26 +3,24 @@
 require_relative "cycle_findings"
 require_relative "mixed_audience_findings"
 require_relative "roll_call_findings"
+require_relative "rule"
 require_relative "sdp_violation_findings"
 require_relative "wide_edge_findings"
 
 class Hashira::Coupling::Report
-  RULES = [
-    Hashira::Coupling::CycleFindings, Hashira::Coupling::SdpViolationFindings,
-    Hashira::Coupling::MixedAudienceFindings, Hashira::Coupling::WideEdgeFindings,
-    Hashira::Coupling::RollCallFindings
-  ].freeze
+  RULES = Hashira::Coupling::Rule.subclasses.sort_by(&:name).freeze
 
   def initialize(project, trees, packaging:)
     @project = project
-    @graph = Hashira::Coupling::Graph.new(project, trees, census(trees, packaging))
+    @trees = trees
+    @packaging = packaging
   end
 
-  attr_reader :graph
+  def graph = @_graph ||= Hashira::Coupling::Graph.new(@project, @trees, census)
 
-  def findings = RULES.flat_map { it.new(@project, @graph).list }
+  def findings = RULES.flat_map { it.new(@project, graph).list }
 
   private
 
-  def census(trees, packaging) = Hashira::Coupling::Census.new(@project, trees, packaging:)
+  def census = Hashira::Coupling::Census.new(@project, @trees, packaging: @packaging)
 end

data/lib/hashira/coupling/roll_call.rb

@@ -18,7 +18,7 @@ class Hashira::Coupling::RollCall
 
   private
 
-  def files = @files ||= @lists.keys.sort
+  def files = @_files ||= @lists.keys.sort
 
   def candidates
     files.combination(2).map { |one, two| @lists[one] & @lists[two] }.select { it.size >= MIN_WORDS }.uniq

data/lib/hashira/coupling/roll_call_findings.rb

@@ -12,7 +12,7 @@ class Hashira::Coupling::RollCallFindings < Hashira::Coupling::Rule
   def rolls = Hashira::Coupling::RollCall.new(lists, homes).rolls
 
   def sightings
-    @sightings ||=
+    @_sightings ||=
       graph.trees.filter_map do |file, tree|
         words = Hashira::Coupling::Words.list(tree)
         [project.relative(file), graph.charge(file), words] unless words.empty?

data/lib/hashira/coupling/roster.rb

@@ -2,28 +2,53 @@
 
 class Hashira::Coupling::Roster
   def initialize(placed)
-    @registry = Hashira::Coupling::ConstantRegistry.new
-    @types = Hash.new(0)
-    @typed = Set.new
-    counted = Set.new
-    placed.each { |definition, package| admit(definition, package, counted) }
+    @placed = placed
+  end
+
+  def registry
+    admitted
+    @_registry
   end
 
-  attr_reader :registry, :types
+  def types
+    admitted
+    @_types
+  end
 
-  def origins = @registry.origins
+  def origins = registry.origins
 
-  def type?(path) = @typed.include?(path)
+  def type?(path)
+    admitted
+    @_typed.include?(path)
+  end
 
-  def packages = @types.keys | @registry.packages
+  def packages = types.keys | registry.packages
 
   private
 
+  def admitted
+    return if @_admitted
+    @_admitted = true
+    blank
+    fill
+  end
+
+  def blank
+    @_registry = Hashira::Coupling::ConstantRegistry.new
+    @_types = Hash.new(0)
+    @_typed = Set.new
+  end
+
+  def fill
+    counted = Set.new
+    @placed.each { |definition, package| admit(definition, package, counted) }
+  end
+
   def admit(definition, package, counted)
     return unless package
     path = definition.path
-    @registry.register(path, package)
-    @typed << path if definition.type?
-    @types[package] += 1 if definition.counted? && counted.add?(path)
+    @_registry.register(path, package)
+    @_typed << path if definition.type?
+    @_types[package] += 1 if definition.counted? && counted.add?(path)
   end
 end

data/lib/hashira/coupling/rule.rb

@@ -10,7 +10,7 @@ class Hashira::Coupling::Rule
 
   attr_reader :project, :graph
 
-  def metrics = @metrics ||= graph.metrics
+  def metrics = @_metrics ||= graph.metrics
 
   def finding(**attributes)
     Hashira::Analysis::Finding.new(kind: self.class::KIND, cycle: nil, **attributes)

data/lib/hashira/coupling/sdp_violation_findings.rb

@@ -5,6 +5,8 @@ require_relative "rule"
 class Hashira::Coupling::SdpViolationFindings < Hashira::Coupling::Rule
   KIND = "sdp_violation"
 
+  Imbalance = Data.define(:from, :to, :from_instability, :to_instability)
+
   def list
     ranked.map { |from, to| violation(from, to) }
   end
@@ -18,7 +20,7 @@ class Hashira::Coupling::SdpViolationFindings < Hashira::Coupling::Rule
   end
 
   def detail(from, to)
-    { from:, to:, from_instability: instability(from), to_instability: instability(to) }
+    Imbalance.new(from:, to:, from_instability: instability(from), to_instability: instability(to))
   end
 
   def instability(package) = metrics[package].instability

data/lib/hashira/duplication/clones.rb

@@ -7,7 +7,7 @@ class Hashira::Duplication::Clones
     @churn = churn
   end
 
-  def clusters = @clusters ||= Hashira::Duplication::Clusters.new(fragments).sorted
+  def clusters = @_clusters ||= Hashira::Duplication::Clusters.new(fragments).sorted
 
   def findings = clusters.map { |cluster| Hashira::Duplication::DuplicationFinding.new(cluster, @churn).to_finding }
 

data/lib/hashira/duplication/clusters.rb

@@ -7,20 +7,23 @@ class Hashira::Duplication::Clusters
   PAIR = 2
   PENALTY_PER_RECURRENCE = 2
 
-  def initialize(fragments)
-    @fragments = fragments.select { |fragment| fragment.mass >= PREFILTER }
-    @sets = Hashira::Duplication::UnionFind.new
+  def initialize(all)
+    @all = all
   end
 
   def sorted
-    @fragments.group_by(&:types).each_value { |group| chain(group) }
-    Hashira::Duplication::NearMiss.new(@fragments).pairs.each { |left, right| @sets.union(left, right) }
+    fragments.group_by(&:types).each_value { |group| chain(group) }
+    Hashira::Duplication::NearMiss.new(fragments).pairs.each { |left, right| sets.union(left, right) }
     Hashira::Duplication::Maximal.new(sized).reduced.sort_by { -it.mass }
   end
 
   private
 
-  def chain(group) = group.each_cons(2) { |left, right| @sets.union(left, right) }
+  def fragments = @_fragments ||= @all.select { |fragment| fragment.mass >= PREFILTER }.reject(&:schema?)
+
+  def sets = @_sets ||= Hashira::Duplication::UnionFind.new
+
+  def chain(group) = group.each_cons(2) { |left, right| sets.union(left, right) }
 
   def sized = built.filter_map { admitted(it) }
 
@@ -30,7 +33,7 @@ class Hashira::Duplication::Clusters
 
   def core(cluster) = Hashira::Duplication::Grouping.new(cluster.identical).cluster
 
-  def built = @sets.clusters.filter_map { |group| Hashira::Duplication::Grouping.new(group).cluster }
+  def built = sets.clusters.filter_map { |group| Hashira::Duplication::Grouping.new(group).cluster }
 
   def floor(cluster) = base(cluster) + penalty(cluster)
 

data/lib/hashira/duplication/delta.rb

@@ -11,10 +11,7 @@ class Hashira::Duplication::Delta
   end
 
   def to_h
-    {
-      mass: @cluster.mass, sites: @cluster.size, kind:,
-      locations: @cluster.sites.sort_by(&:rank).map(&:range)
-    }
+    { mass: @cluster.mass, sites: @cluster.size, kind: }.merge(locations: @cluster.sites.sort_by(&:rank).map(&:range))
   end
 
   private

data/lib/hashira/duplication/duplication_finding.rb

@@ -3,6 +3,8 @@
 class Hashira::Duplication::DuplicationFinding
   KIND = "duplication"
 
+  Overlap = Data.define(:size, :mass, :kind, :hot)
+
   def initialize(cluster, churn)
     @cluster = cluster
     @churn = churn
@@ -16,10 +18,10 @@ class Hashira::Duplication::DuplicationFinding
   private
 
   def detail
-    {
+    Overlap.new(
       size: @cluster.size, mass: @cluster.mass,
       kind: Hashira::Duplication::Delta.new(@cluster).kind, hot: @churn.hot?(@cluster.sites)
-    }
+    )
   end
 
   def evidence = @cluster.sites.sort_by(&:rank).map(&:range)

data/lib/hashira/duplication/fragment.rb

@@ -1,10 +1,17 @@
 # frozen_string_literal: true
 
 require "digest"
+require "prism"
 
 class Hashira::Duplication::Fragment
   DIGEST_LENGTH = 12
 
+  SCHEMA = %i[
+    class_node module_node statements_node arguments_node assoc_node
+    array_node hash_node keyword_hash_node constant_read_node constant_path_node
+    symbol_node string_node integer_node float_node true_node false_node nil_node
+  ].freeze
+
   def initialize(file, roots)
     @file = file
     @roots = roots
@@ -12,7 +19,7 @@ class Hashira::Duplication::Fragment
 
   attr_reader :file
 
-  def types = @types ||= nodes.map(&:type)
+  def types = @_types ||= nodes.map(&:type)
 
   def digest = Digest::SHA256.hexdigest(shape).slice(0, DIGEST_LENGTH)
 
@@ -20,6 +27,8 @@ class Hashira::Duplication::Fragment
 
   def mass = types.size
 
+  def schema? = nodes.all? { directive?(it) }
+
   def line = @roots.first.location.start_line
 
   def finish = @roots.last.location.end_line
@@ -34,5 +43,14 @@ class Hashira::Duplication::Fragment
 
   def touches?(others) = others.any? { overlaps?(it) }
 
-  def nodes = @nodes ||= @roots.flat_map { Hashira::Analysis::NodeWalk.collect(it) }
+  def nodes = @_nodes ||= @roots.flat_map { Hashira::Analysis::NodeWalk.collect(it) }
+
+  private
+
+  def directive?(node)
+    return SCHEMA.include?(node.type) unless node.is_a?(Prism::CallNode)
+    !node.receiver && !node.block && literals?(node.arguments)
+  end
+
+  def literals?(arguments) = Hashira::Duplication::Literal.new(arguments).literals?
 end