hashira 0.4.0 → 0.5.0

data/lib/hashira/complexity/{analyzer.rb → scores.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Hashira::Complexity::Analyzer
+class Hashira::Complexity::Scores
   THRESHOLD = 10
 
   def initialize(project, trees)
@@ -8,7 +8,7 @@ class Hashira::Complexity::Analyzer
     @scores = trees.flat_map { |path, tree| harvest(path, tree) }
   end
 
-  def methods = @scores.sort_by { -it.cognitive }
+  def ranked = @scores.sort_by { -it.cognitive }
 
   def classes = Hashira::Complexity::Rollup.new(@scores).classes.sort_by { -it.cognitive }
 
@@ -16,7 +16,7 @@ class Hashira::Complexity::Analyzer
 
   private
 
-  def flagged = methods.select { it.cognitive >= THRESHOLD }
+  def flagged = ranked.select { it.cognitive >= THRESHOLD }
 
   def harvest(path, tree)
     rel = @project.relative(path)
@@ -32,12 +32,13 @@ class Hashira::Complexity::Analyzer
   end
 
   def score(rel, full, node)
-    score = Hashira::Complexity::CognitiveScore.new(node)
     Hashira::Complexity::MethodScore.new(
       subject: subject(full, node), file: rel, line: node.location.start_line,
-      cognitive: score.total, calls: score.calls, increments: score.increments
+      **tallies(Hashira::Complexity::CognitiveScore.new(node))
     )
   end
 
+  def tallies(score) = { cognitive: score.total, calls: score.calls, increments: score.increments }
+
   def subject(full, node) = "#{full.join("::")}#{node.receiver ? "." : "#"}#{node.name}"
 end

data/lib/hashira/coupling/audiences.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+class Hashira::Coupling::Audiences
+  MIN = 2
+
+  Part = Data.define(:users, :constants, :shared)
+
+  def initialize(usage)
+    @usage = usage
+  end
+
+  def split? = parts.size >= 2
+
+  def parts = @parts ||= [common, *slices].compact.select { it.constants.size >= MIN }
+
+  private
+
+  def clients = @clients ||= @usage.keys.sort
+
+  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|
+      @usage[client].each { seen[it] << client }
+    end
+  end
+
+  def common
+    return if shared.empty?
+    Part.new(users: clients.select { @usage[it].intersect?(shared) }, constants: shared.sort, shared: true)
+  end
+
+  def slices
+    groups.sort_by(&:first).map { |members| Part.new(users: members, constants: pooled(members).sort, shared: false) }
+  end
+
+  def pooled(members) = members.reduce(Set.new) { |pool, client| pool | residue(client) }
+
+  def residue(client) = @usage[client] - shared
+
+  def groups
+    clients.reduce([]) do |formed, client|
+      linked, apart = formed.partition { |members| joined?(members, client) }
+      apart + [linked.flatten + [client]]
+    end
+  end
+
+  def joined?(members, client) = members.any? { residue(it).intersect?(residue(client)) }
+end

data/lib/hashira/{analysis → coupling}/catalog.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-class Hashira::Analysis::Catalog
+class Hashira::Coupling::Catalog
   include Enumerable
 
   def initialize(definitions)
     @definitions = definitions
-    @naming = Hashira::Analysis::Naming.new(definitions)
+    @naming = Hashira::Coupling::Naming.new(definitions)
     @entries = definitions.map { |node, full, folder| entry(node, full, folder) }
   end
 
@@ -22,6 +22,6 @@ class Hashira::Analysis::Catalog
   private
 
   def entry(node, full, folder)
-    Hashira::Analysis::Definition.new(node:, path: @naming.strip(full), folder:)
+    Hashira::Coupling::Definition.new(node:, path: @naming.strip(full), folder:)
   end
 end

data/lib/hashira/{analysis → coupling}/census.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-class Hashira::Analysis::Census
+class Hashira::Coupling::Census
   def initialize(project, trees, packaging: :folder)
-    @catalog = Hashira::Analysis::Catalog.new(Hashira::Analysis::Definitions.new(project, trees))
-    @placement = Hashira::Analysis::Placement.build(packaging, project, @catalog)
-    @folding = Hashira::Analysis::NoFolding
+    @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
   end
@@ -23,16 +23,25 @@ class Hashira::Analysis::Census
 
   def folds = @folding.disclosed
 
-  def resolve(segments, nesting = []) = resolver.resolve(segments, nesting)
+  def strip(segments) = @catalog.strip(segments)
 
-  def pinpoint(segments) = resolver.pinpoint(segments)
+  def holder(segments)
+    path = strip(segments)
+    (path.length.downto(1).map { path.first(it) }.find { type?(it) } || path).join("::")
+  end
+
+  def resolve(segments, nesting = []) = scope.resolve(segments, nesting)
+
+  def pinpoint(segments) = scope.pinpoint(segments)
 
   def charge(file, nesting) = translate(@placement.charge(file, nesting))
 
   private
 
+  def type?(segments) = @roster.origins.key?(segments.join("::"))
+
   def tally
-    Hashira::Analysis::Roster.new(@placement.placed.map { |definition, package| [definition, translate(package)] })
+    Hashira::Coupling::Roster.new(@placement.placed.map { |definition, package| [definition, translate(package)] })
   end
 
   def settle
@@ -42,5 +51,5 @@ class Hashira::Analysis::Census
 
   def translate(package) = @folding.map.fetch(package, package)
 
-  def resolver = Hashira::Analysis::Resolver.new(@roster.registry, @catalog, @placement)
+  def scope = Hashira::Coupling::Scope.new(@roster.registry, @catalog, @placement)
 end

data/lib/hashira/{analysis → coupling}/constant_registry.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Hashira::Analysis::ConstantRegistry
+class Hashira::Coupling::ConstantRegistry
   AMBIGUOUS = Object.new.freeze
 
   def initialize
@@ -38,6 +38,10 @@ class Hashira::Analysis::ConstantRegistry
   end
 
   def enclosing(path)
-    (path.length - 1).downto(1).filter_map { @origins[path.first(it).join("::")] }.first
+    prefixes(path).filter_map { @origins[it] }.first
+  end
+
+  def prefixes(path)
+    (path.length - 1).downto(1).map { path.first(it).join("::") }
   end
 end

data/lib/hashira/coupling/cycle_findings.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "rule"
+
+class Hashira::Coupling::CycleFindings < Hashira::Coupling::Rule
+  KIND = "cycle"
+
+  def list
+    loops.map { entry(it) }
+  end
+
+  private
+
+  def loops
+    cycles = graph.cycles
+    graph.packages.select { cycles.through?(it) }.sort.map { cycles.path(it) }.uniq { it[..-2].sort }
+  end
+
+  def entry(path)
+    finding(package: path.first, cycle: path, evidence: evidence(path), detail: detail(graph.cycles.weakest(path)))
+  end
+
+  def detail(weak)
+    from, to = weak
+    { weak:, weight: graph.weight(from, to) }
+  end
+
+  def evidence(path)
+    path.each_cons(2).flat_map { |from, to| graph.evidence(from, to).to_a.first(2) }
+  end
+end

data/lib/hashira/{analysis → coupling}/cycle_search.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Hashira::Analysis::CycleSearch
+class Hashira::Coupling::CycleSearch
   def initialize(dependencies, package)
     @dependencies = dependencies
     @package = package

data/lib/hashira/{analysis → coupling}/cycles.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Hashira::Analysis::Cycles
+class Hashira::Coupling::Cycles
   def initialize(dependencies, graph)
     @dependencies = dependencies
     @graph = graph
@@ -8,7 +8,7 @@ class Hashira::Analysis::Cycles
 
   def through?(package) = !!path(package)
 
-  def path(package) = Hashira::Analysis::CycleSearch.new(@dependencies, package).path
+  def path(package) = Hashira::Coupling::CycleSearch.new(@dependencies, package).path
 
   def weakest(trail) = trail.each_cons(2).min_by { |from, to| @graph.weight(from, to) }
 end

data/lib/hashira/{analysis → coupling}/definition.rb

@@ -3,7 +3,7 @@
 require "prism"
 
 module Hashira
-  module Analysis
+  module Coupling
     Definition =
       Data.define(:node, :path, :folder) do
         def name = path.first

data/lib/hashira/{analysis → coupling}/definitions.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Hashira::Analysis::Definitions
+class Hashira::Coupling::Definitions
   include Enumerable
 
   def initialize(project, trees)

data/lib/hashira/{analysis → coupling}/edge.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Hashira
-  module Analysis
+  module Coupling
     Edge =
       Data.define(:from, :to) do
         def to_s = "#{from} -> #{to}"

data/lib/hashira/{analysis → coupling}/edge_map.rb

@@ -1,19 +1,18 @@
 # frozen_string_literal: true
 
-class Hashira::Analysis::EdgeMap
-  def initialize(project, census)
-    @project = project
+class Hashira::Coupling::EdgeMap
+  def initialize(census)
     @census = census
     @dependencies = sets
     @evidence = sets
+    @usage = sets
   end
 
-  attr_reader :dependencies, :evidence
+  attr_reader :dependencies, :evidence, :usage
 
-  def record(file, tree)
-    source = @project.relative(file)
-    Hashira::Analysis::References.sightings(tree, @census.roots).each do |segments, line, nesting, home|
-      note(@census.charge(file, home), locate(segments, nesting), "#{source}:#{line}: #{segments.join("::")}")
+  def record(source, file, tree)
+    Hashira::Coupling::References.sightings(tree, @census.roots).each do |segments, line, nesting, home|
+      note(@census.charge(file, home), locate(segments, nesting), segments, "#{source}:#{line}")
     end
   end
 
@@ -25,9 +24,10 @@ class Hashira::Analysis::EdgeMap
     nesting ? @census.resolve(segments, nesting) : @census.pinpoint(segments)
   end
 
-  def note(from, to, sighting)
+  def note(from, to, segments, site)
     return unless to && to != from
     @dependencies[from] << to
-    @evidence[[from, to]] << sighting
+    @evidence[[from, to]] << "#{site}: #{segments.join("::")}"
+    @usage[[from, to]] << @census.holder(segments)
   end
 end

data/lib/hashira/{analysis → coupling}/folder_placement.rb

@@ -2,7 +2,7 @@
 
 require_relative "placement"
 
-class Hashira::Analysis::FolderPlacement < Hashira::Analysis::Placement
+class Hashira::Coupling::FolderPlacement < Hashira::Coupling::Placement
   def mode = :folder
 
   def placed = catalog.map { [it, it.folder] }
@@ -13,5 +13,5 @@ class Hashira::Analysis::FolderPlacement < Hashira::Analysis::Placement
 
   def skip?(_segments) = false
 
-  def folding(_census) = Hashira::Analysis::NoFolding
+  def folding(_census) = Hashira::Coupling::NoFolding
 end

data/lib/hashira/{analysis → coupling}/folding.rb

@@ -2,7 +2,7 @@
 
 require "prism"
 
-class Hashira::Analysis::Folding
+class Hashira::Coupling::Folding
   SUFFIXES = %w[Resource Serializer Policy Decorator].freeze
 
   def initialize(definitions, census, suffixes: [])
@@ -32,10 +32,12 @@ class Hashira::Analysis::Folding
   def pair(name, stem) = ([name, stem] if stem && @census.packages.include?(stem))
 
   def crop(name)
-    suffix = @suffixes.find { name.end_with?(it) && name != it }
+    suffix = @suffixes.find { trims?(name, it) }
     suffix && name.delete_suffix(suffix)
   end
 
+  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 lone = @definitions.select(&:singular?).reject { anchored.include?(it.name) }

data/lib/hashira/{analysis → coupling}/graph.rb

@@ -1,14 +1,17 @@
 # frozen_string_literal: true
 
-class Hashira::Analysis::Graph
+class Hashira::Coupling::Graph
   def initialize(project, trees, census)
     @census = census
-    @map = Hashira::Analysis::EdgeMap.new(project, census)
-    trees.each { |file, tree| @map.record(file, tree) }
-    @cycles = Hashira::Analysis::Cycles.new(@map.dependencies, self)
+    @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
+  attr_reader :cycles, :trees
+
+  def charge(file) = @census.charge(file, [])
 
   def packages = (@census.packages | @map.dependencies.keys)
 
@@ -21,7 +24,7 @@ class Hashira::Analysis::Graph
   def incoming(package) = packages.select { dependencies[it].include?(package) }.sort
 
   def edges
-    dependencies.sort.flat_map { |from, tos| tos.sort.map { Hashira::Analysis::Edge.new(from:, to: it) } }
+    dependencies.sort.flat_map { |from, tos| tos.sort.map { Hashira::Coupling::Edge.new(from:, to: it) } }
   end
 
   def weighted
@@ -33,8 +36,15 @@ class Hashira::Analysis::Graph
 
   def evidence(from, to) = @map.evidence[[from, to]]
 
+  def usage(package) = incoming(package).to_h { [it, @map.usage[[it, package]]] }
+
+  def constants(edge)
+    from, to = edge.deconstruct
+    @map.usage[[from, to]].sort
+  end
+
   def metric(package)
-    Hashira::Analysis::Metric.new(
+    Hashira::Coupling::Metric.new(
       types: @census.types[package],
       afferent: incoming(package).size,
       efferent: dependencies[package].size
@@ -43,7 +53,7 @@ class Hashira::Analysis::Graph
 
   def metrics = packages.to_h { [it, metric(it)] }
 
-  def violations = Hashira::Analysis::SdpCheck.new(dependencies, metrics).violations
+  def violations = Hashira::Coupling::SdpCheck.new(dependencies, metrics).violations
 
   def weight(from, to) = evidence(from, to).size
 

data/lib/hashira/{analysis → coupling}/metric.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Hashira
-  module Analysis
+  module Coupling
     Metric =
       Data.define(:types, :afferent, :efferent) do
         def instability

data/lib/hashira/coupling/mixed_audience_findings.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "rule"
+
+class Hashira::Coupling::MixedAudienceFindings < Hashira::Coupling::Rule
+  KIND = "mixed_audience"
+
+  def list
+    graph.packages.sort.filter_map { verdict(it) }
+  end
+
+  private
+
+  def verdict(package)
+    audiences = Hashira::Coupling::Audiences.new(graph.usage(package))
+    detail(package, audiences.parts) if audiences.split?
+  end
+
+  def detail(package, parts)
+    finding(
+      package:, evidence: parts.flat_map do
+        sightings(package, it).first(2)
+      end, detail: { parts: parts.map(&:to_h) }
+    )
+  end
+
+  def sightings(package, part)
+    part.users.flat_map { |client| graph.evidence(client, package).to_a.select { mentions?(it, part.constants) } }
+  end
+
+  def mentions?(line, constants) = constants.any? { line.end_with?(": #{it}", "::#{it}") }
+end

data/lib/hashira/{analysis → coupling}/namespace_placement.rb

@@ -2,7 +2,7 @@
 
 require_relative "placement"
 
-class Hashira::Analysis::NamespacePlacement < Hashira::Analysis::Placement
+class Hashira::Coupling::NamespacePlacement < Hashira::Coupling::Placement
   RAILS_BASES =
     %w[ApplicationRecord ApplicationController ApplicationJob ApplicationMailer
       ApplicationHelper ApplicationCable ApplicationResource ApplicationSerializer
@@ -20,9 +20,9 @@ class Hashira::Analysis::NamespacePlacement < Hashira::Analysis::Placement
 
   def skip?(segments) = project.rails? && RAILS_BASES.include?(segments.first)
 
-  def folding(census) = Hashira::Analysis::Folding.new(catalog, census, suffixes: suffixes)
+  def folding(census) = Hashira::Coupling::Folding.new(catalog, census, suffixes: suffixes)
 
   private
 
-  def suffixes = project.rails? ? Hashira::Analysis::Folding::SUFFIXES : []
+  def suffixes = project.rails? ? Hashira::Coupling::Folding::SUFFIXES : []
 end

data/lib/hashira/{analysis → coupling}/namespace_prefix.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Hashira
-  module Analysis
+  module Coupling
     module NamespacePrefix
       module_function
 

data/lib/hashira/{analysis → coupling}/naming.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-class Hashira::Analysis::Naming
+class Hashira::Coupling::Naming
   def initialize(definitions)
-    @segments = Hashira::Analysis::NamespacePrefix.infer(definitions)
+    @segments = Hashira::Coupling::NamespacePrefix.infer(definitions)
   end
 
   attr_reader :segments

data/lib/hashira/{analysis → coupling}/no_folding.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Hashira
-  module Analysis
+  module Coupling
     module NoFolding
       module_function
 

data/lib/hashira/{analysis → coupling}/placement.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-class Hashira::Analysis::Placement
+class Hashira::Coupling::Placement
   def self.build(packaging, project, catalog)
     {
-      folder: Hashira::Analysis::FolderPlacement,
-      namespace: Hashira::Analysis::NamespacePlacement
+      folder: Hashira::Coupling::FolderPlacement,
+      namespace: Hashira::Coupling::NamespacePlacement
     }.fetch(packaging).new(project, catalog)
   end
 

data/lib/hashira/coupling/references.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+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 sightings(tree)
+    collect(tree)
+    @found
+  end
+
+  private
+
+  def nesting = @scopes.last
+
+  def collect(node, home = nesting)
+    return unless 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]
+  end
+
+  def syntax = Hashira::Analysis::Syntax
+
+  def constant?(node) = node.is_a?(Prism::ConstantPathNode) || node.is_a?(Prism::ConstantReadNode)
+
+  def definition?(node) = node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)
+
+  def enter(node)
+    opened = nesting + [anchor(node)]
+    collect(node.superclass, opened) if node.is_a?(Prism::ClassNode)
+    inside(opened) { collect(node.body) }
+  end
+
+  def anchor(node) = syntax.anchor(nesting, syntax.segments(node.constant_path), @roots)
+
+  def inside(scope)
+    @scopes << scope
+    yield
+    @scopes.pop
+  end
+end

data/lib/hashira/coupling/report.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "cycle_findings"
+require_relative "mixed_audience_findings"
+require_relative "roll_call_findings"
+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
+
+  def initialize(project, trees, packaging:)
+    @project = project
+    @graph = Hashira::Coupling::Graph.new(project, trees, census(trees, packaging))
+  end
+
+  attr_reader :graph
+
+  def findings = RULES.flat_map { it.new(@project, @graph).list }
+
+  private
+
+  def census(trees, packaging) = Hashira::Coupling::Census.new(@project, trees, packaging:)
+end

data/lib/hashira/coupling/roll_call.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class Hashira::Coupling::RollCall
+  MIN_WORDS = 3
+
+  MIN_FILES = 3
+
+  MIN_PACKAGES = 2
+
+  Roll = Data.define(:words, :files, :packages)
+
+  def initialize(lists, homes)
+    @lists = lists
+    @homes = homes
+  end
+
+  def rolls = maximal(candidates.filter_map { entry(it) }).sort_by(&:words)
+
+  private
+
+  def files = @files ||= @lists.keys.sort
+
+  def candidates
+    files.combination(2).map { |one, two| @lists[one] & @lists[two] }.select { it.size >= MIN_WORDS }.uniq
+  end
+
+  def entry(words)
+    holders = files.select { @lists[it] >= words }
+    spread = holders.map { @homes[it] }.uniq.sort
+    return unless holders.size >= MIN_FILES && spread.size >= MIN_PACKAGES
+    Roll.new(words: words.sort, files: holders, packages: spread)
+  end
+
+  def maximal(rolls)
+    rolls.reject { |roll| swallowed?(roll, rolls) }
+  end
+
+  def swallowed?(roll, rolls) = rolls.any? { swallows?(it, roll) }
+
+  def swallows?(big, small)
+    mine = big.words
+    theirs = small.words
+    mine != theirs && (theirs - mine).empty?
+  end
+end