hashira 0.3.0 → 0.5.0

data/lib/hashira/complexity/rollup.rb

@@ -1,22 +1,20 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Complexity
-    class Rollup
-      def initialize(scores)
-        @scores = scores
-      end
-
-      def classes = @scores.group_by { class_name(it.subject) }.map { |name, group| score(name, group) }
+class Hashira::Complexity::Rollup
+  def initialize(scores)
+    @scores = scores
+  end
 
-      private
+  def classes = @scores.group_by { owner(it.subject) }.map { |name, group| score(name, group) }
 
-      def score(name, group)
-        ClassScore.new(name:, cognitive: group.sum(&:cognitive), method_count: group.size,
-                       peak: group.map(&:cognitive).max)
-      end
+  private
 
-      def class_name(subject) = subject.split(/[#.]/, 2).first
-    end
+  def score(name, group)
+    Hashira::Complexity::ClassScore.new(
+      name:, cognitive: group.sum(&:cognitive), method_count: group.size,
+      peak: group.map(&:cognitive).max
+    )
   end
+
+  def owner(subject) = subject.split(/[#.]/, 2).first
 end

data/lib/hashira/complexity/scores.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class Hashira::Complexity::Scores
+  THRESHOLD = 10
+
+  def initialize(project, trees)
+    @project = project
+    @scores = trees.flat_map { |path, tree| harvest(path, tree) }
+  end
+
+  def ranked = @scores.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 flagged = ranked.select { it.cognitive >= THRESHOLD }
+
+  def harvest(path, tree)
+    rel = @project.relative(path)
+    sites(tree).map { |full, node| score(rel, 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] }
+    end
+    found
+  end
+
+  def score(rel, full, node)
+    Hashira::Complexity::MethodScore.new(
+      subject: subject(full, node), file: rel, line: node.location.start_line,
+      **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/coupling/catalog.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Hashira::Coupling::Catalog
+  include Enumerable
+
+  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 prefix = @naming.segments
+
+  def strip(path) = @naming.strip(path)
+
+  def roots = @definitions.roots
+
+  def folders = @definitions.packages
+
+  private
+
+  def entry(node, full, folder)
+    Hashira::Coupling::Definition.new(node:, path: @naming.strip(full), folder:)
+  end
+end

data/lib/hashira/coupling/census.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+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
+  end
+
+  def packaging = @placement.mode
+
+  def types = @roster.types
+
+  def prefix = @catalog.prefix
+
+  def origins = @roster.origins
+
+  def roots = @catalog.roots
+
+  def packages = @roster.packages | @placement.baseline
+
+  def folds = @folding.disclosed
+
+  def strip(segments) = @catalog.strip(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::Coupling::Roster.new(@placement.placed.map { |definition, package| [definition, translate(package)] })
+  end
+
+  def settle
+    @folding = @placement.folding(self)
+    @roster = tally unless @folding.map.empty?
+  end
+
+  def translate(package) = @folding.map.fetch(package, package)
+
+  def scope = Hashira::Coupling::Scope.new(@roster.registry, @catalog, @placement)
+end

data/lib/hashira/coupling/constant_registry.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class Hashira::Coupling::ConstantRegistry
+  AMBIGUOUS = Object.new.freeze
+
+  def initialize
+    @origins = {}
+    @shorthand = {}
+  end
+
+  attr_reader :origins
+
+  def register(path, package)
+    return if path.empty?
+    claim(@origins, path, package)
+    (1...path.length).each { claim(@shorthand, path.drop(it), package) }
+  end
+
+  def package(path)
+    found = anchored(path) || enclosing(path)
+    found unless found == AMBIGUOUS
+  end
+
+  def exact(path) = @origins[path.join("::")]
+
+  def packages = (@origins.values.uniq - [AMBIGUOUS])
+
+  private
+
+  def claim(claims, path, package)
+    key = path.join("::")
+    claims[key] = claims.fetch(key, package) == package ? package : AMBIGUOUS
+  end
+
+  def anchored(path)
+    key = path.join("::")
+    @origins[key] || @shorthand[key]
+  end
+
+  def enclosing(path)
+    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/coupling/cycle_search.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+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
+    unwind([@package]) if cycle?
+  end
+
+  private
+
+  def cycle?
+    while (node = @queue.shift)
+      return true if node == @package
+      visit(node)
+    end
+  end
+
+  def visit(node)
+    @dependencies[node].each do |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]))
+  end
+end

data/lib/hashira/coupling/cycles.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Hashira::Coupling::Cycles
+  def initialize(dependencies, graph)
+    @dependencies = dependencies
+    @graph = graph
+  end
+
+  def through?(package) = !!path(package)
+
+  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/coupling/definition.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Hashira
+  module Coupling
+    Definition =
+      Data.define(:node, :path, :folder) do
+        def name = path.first
+
+        def nested? = path.length > 1
+
+        def klass? = node.is_a?(Prism::ClassNode)
+
+        def singular? = klass? && !nested?
+
+        def superclass = node.superclass
+
+        def counted? = klass? || !Hashira::Analysis::Syntax.direct(node).empty?
+      end
+  end
+end

data/lib/hashira/coupling/definitions.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class Hashira::Coupling::Definitions
+  include Enumerable
+
+  def initialize(project, trees)
+    @project = project
+    @trees = trees
+  end
+
+  def each(&)
+    @trees.each { |file, tree| scan(file, tree, &) }
+  end
+
+  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
+
+  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) { |node, full| yield(node, full, package) }
+  end
+end

data/lib/hashira/coupling/edge.rb

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

data/lib/hashira/coupling/edge_map.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Hashira::Coupling::EdgeMap
+  def initialize(census)
+    @census = census
+    @dependencies = sets
+    @evidence = sets
+    @usage = sets
+  end
+
+  attr_reader :dependencies, :evidence, :usage
+
+  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
+
+  private
+
+  def sets = Hash.new { |hash, key| hash[key] = Set.new }
+
+  def locate(segments, nesting)
+    nesting ? @census.resolve(segments, nesting) : @census.pinpoint(segments)
+  end
+
+  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)
+  end
+end

data/lib/hashira/coupling/folder_placement.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "placement"
+
+class Hashira::Coupling::FolderPlacement < Hashira::Coupling::Placement
+  def mode = :folder
+
+  def placed = catalog.map { [it, it.folder] }
+
+  def baseline = catalog.folders
+
+  def charge(file, _nesting) = project.package(file)
+
+  def skip?(_segments) = false
+
+  def folding(_census) = Hashira::Coupling::NoFolding
+end

data/lib/hashira/coupling/folding.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Coupling::Folding
+  SUFFIXES = %w[Resource Serializer Policy Decorator].freeze
+
+  def initialize(definitions, census, suffixes: [])
+    @definitions = definitions
+    @census = census
+    @suffixes = suffixes
+  end
+
+  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" } }
+  end
+
+  private
+
+  def links = @links ||= named.merge(parents)
+
+  def parents
+    @parents ||= singles.select { |_name, one| one.superclass }.to_h { |name, one| [name, target(one)] }.compact
+  end
+
+  def named
+    singles.keys.filter_map { |name| pair(name, crop(name)) }.to_h
+  end
+
+  def pair(name, stem) = ([name, stem] if stem && @census.packages.include?(stem))
+
+  def crop(name)
+    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) }
+
+  def anchored = @anchored ||= @definitions.select(&:nested?).to_set(&:name)
+
+  def target(one) = @census.pinpoint(Hashira::Analysis::Syntax.segments(one.superclass))
+
+  def settle(name, links)
+    trail = [name]
+    while (target = links[name]) && !trail.include?(target)
+      trail << (name = target)
+    end
+    target ? trail.drop(trail.index(target)).min : name
+  end
+end

data/lib/hashira/coupling/graph.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class Hashira::Coupling::Graph
+  def initialize(project, trees, census)
+    @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
+
+  def charge(file) = @census.charge(file, [])
+
+  def packages = (@census.packages | @map.dependencies.keys)
+
+  def packaging = @census.packaging
+
+  def folds = @census.folds
+
+  def outgoing(package) = dependencies[package].to_a.sort
+
+  def incoming(package) = packages.select { dependencies[it].include?(package) }.sort
+
+  def edges
+    dependencies.sort.flat_map { |from, tos| tos.sort.map { Hashira::Coupling::Edge.new(from:, to: it) } }
+  end
+
+  def weighted
+    edges.map do |edge|
+      from, to = edge.deconstruct
+      [from, to, weight(from, to)]
+    end
+  end
+
+  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::Coupling::Metric.new(
+      types: @census.types[package],
+      afferent: incoming(package).size,
+      efferent: dependencies[package].size
+    )
+  end
+
+  def metrics = packages.to_h { [it, metric(it)] }
+
+  def violations = Hashira::Coupling::SdpCheck.new(dependencies, metrics).violations
+
+  def weight(from, to) = evidence(from, to).size
+
+  private
+
+  def dependencies = @map.dependencies
+end

data/lib/hashira/coupling/metric.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Coupling
+    Metric =
+      Data.define(:types, :afferent, :efferent) do
+        def instability
+          total = efferent + afferent
+          total.zero? ? 0.0 : efferent.fdiv(total)
+        end
+
+        def to_h = { tc: types, ca: afferent, ce: efferent, i: instability }
+      end
+  end
+end

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/coupling/namespace_placement.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "placement"
+
+class Hashira::Coupling::NamespacePlacement < Hashira::Coupling::Placement
+  RAILS_BASES =
+    %w[ApplicationRecord ApplicationController ApplicationJob ApplicationMailer
+      ApplicationHelper ApplicationCable ApplicationResource ApplicationSerializer
+      ApplicationPolicy ApplicationDecorator].freeze
+
+  def mode = :namespace
+
+  def placed = catalog.map { [it, it.name] }
+
+  def baseline = []
+
+  def charge(_file, nesting)
+    nesting.reverse_each.filter_map { catalog.strip(it).first }.first || project.root
+  end
+
+  def skip?(segments) = project.rails? && RAILS_BASES.include?(segments.first)
+
+  def folding(census) = Hashira::Coupling::Folding.new(catalog, census, suffixes: suffixes)
+
+  private
+
+  def suffixes = project.rails? ? Hashira::Coupling::Folding::SUFFIXES : []
+end