hashira 0.2.0 → 0.4.0

data/lib/hashira/analysis/edge_map.rb

@@ -1,36 +1,33 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Analysis
-    class EdgeMap
-      def initialize(project, census)
-        @project = project
-        @census = census
-        @dependencies = empty_sets
-        @evidence = empty_sets
-      end
+class Hashira::Analysis::EdgeMap
+  def initialize(project, census)
+    @project = project
+    @census = census
+    @dependencies = sets
+    @evidence = sets
+  end
 
-      attr_reader :dependencies, :evidence
+  attr_reader :dependencies, :evidence
 
-      def record(file, tree)
-        from = @project.package_for(file)
-        source = @project.relative(file)
-        References.each_sighting(tree).each do |segments, line|
-          record_reference(from, source, segments, line)
-        end
-      end
+  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("::")}")
+    end
+  end
 
-      private
+  private
 
-      def empty_sets = Hash.new { |hash, key| hash[key] = Set.new }
+  def sets = Hash.new { |hash, key| hash[key] = Set.new }
 
-      def record_reference(from, source, segments, line)
-        to = @census.resolve(segments)
-        return unless to && to != from
+  def locate(segments, nesting)
+    nesting ? @census.resolve(segments, nesting) : @census.pinpoint(segments)
+  end
 
-        @dependencies[from] << to
-        @evidence[[from, to]] << "#{source}:#{line}: #{segments.join("::")}"
-      end
-    end
+  def note(from, to, sighting)
+    return unless to && to != from
+    @dependencies[from] << to
+    @evidence[[from, to]] << sighting
   end
 end

data/lib/hashira/analysis/finding.rb

@@ -2,14 +2,15 @@
 
 module Hashira
   module Analysis
-    Finding = Data.define(:kind, :package, :message, :evidence, :cycle, :digest) do
-      def initialize(cycle: nil, digest: nil, **rest) = super
+    Finding =
+      Data.define(:kind, :package, :message, :evidence, :cycle, :digest) do
+        def initialize(cycle: nil, digest: nil, **rest) = super
 
-      def signature = "#{kind}:#{identity}"
+        def signature = "#{kind}:#{identity}"
 
-      def identity = digest || package
+        def identity = digest || package
 
-      def to_h = super.compact
-    end
+        def to_h = super.compact
+      end
   end
 end

data/lib/hashira/analysis/folder_placement.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "placement"
+
+class Hashira::Analysis::FolderPlacement < Hashira::Analysis::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::Analysis::NoFolding
+end

data/lib/hashira/analysis/folding.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Analysis::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 { name.end_with?(it) && name != it }
+    suffix && name.delete_suffix(suffix)
+  end
+
+  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/analysis/graph.rb

@@ -1,56 +1,53 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Analysis
-    class Graph
-      def initialize(project, trees, census)
-        @census = census
-        @edge_map = EdgeMap.new(project, census)
-        trees.each { |file, tree| @edge_map.record(file, tree) }
-      end
+class Hashira::Analysis::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)
+  end
 
-      def packages = @census.packages
+  attr_reader :cycles
 
-      def dependencies_of(package) = dependencies[package].to_a.sort
+  def packages = (@census.packages | @map.dependencies.keys)
 
-      def dependents_of(package) = packages.select { dependencies[it].include?(package) }.sort
+  def packaging = @census.packaging
 
-      def edge_list
-        dependencies.sort.flat_map { |from, tos| tos.sort.map { Edge.new(from:, to: it) } }
-      end
+  def folds = @census.folds
 
-      def weighted_edges
-        edge_list.map do |edge|
-          from, to = edge.deconstruct
-          [from, to, weight(from, to)]
-        end
-      end
+  def outgoing(package) = dependencies[package].to_a.sort
 
-      def evidence_for(from, to) = @edge_map.evidence[[from, to]]
+  def incoming(package) = packages.select { dependencies[it].include?(package) }.sort
 
-      def metric_for(package)
-        Metric.new(type_count: @census.type_count[package],
-                   afferent: dependents_of(package).size,
-                   efferent: dependencies[package].size)
-      end
+  def edges
+    dependencies.sort.flat_map { |from, tos| tos.sort.map { Hashira::Analysis::Edge.new(from:, to: it) } }
+  end
 
-      def metrics = packages.to_h { [it, metric_for(it)] }
+  def weighted
+    edges.map do |edge|
+      from, to = edge.deconstruct
+      [from, to, weight(from, to)]
+    end
+  end
 
-      def sdp_violations = SdpCheck.new(dependencies, metrics).violations
+  def evidence(from, to) = @map.evidence[[from, to]]
 
-      def cyclic?(package) = !!cycle_path(package)
+  def metric(package)
+    Hashira::Analysis::Metric.new(
+      types: @census.types[package],
+      afferent: incoming(package).size,
+      efferent: dependencies[package].size
+    )
+  end
 
-      def weight(from, to) = evidence_for(from, to).size
+  def metrics = packages.to_h { [it, metric(it)] }
 
-      def cycle_path(package) = CycleSearch.new(dependencies, package).path
+  def violations = Hashira::Analysis::SdpCheck.new(dependencies, metrics).violations
 
-      def weakest_edge(path)
-        path.each_cons(2).min_by { |from, to| weight(from, to) }
-      end
+  def weight(from, to) = evidence(from, to).size
 
-      private
+  private
 
-      def dependencies = @edge_map.dependencies
-    end
-  end
+  def dependencies = @map.dependencies
 end

data/lib/hashira/analysis/metric.rb

@@ -2,13 +2,14 @@
 
 module Hashira
   module Analysis
-    Metric = Data.define(:type_count, :afferent, :efferent) do
-      def instability
-        total = efferent + afferent
-        total.zero? ? 0.0 : efferent.to_f / total
-      end
+    Metric =
+      Data.define(:types, :afferent, :efferent) do
+        def instability
+          total = efferent + afferent
+          total.zero? ? 0.0 : efferent.fdiv(total)
+        end
 
-      def to_h = { tc: type_count, ca: afferent, ce: efferent, i: instability }
-    end
+        def to_h = { tc: types, ca: afferent, ce: efferent, i: instability }
+      end
   end
 end

data/lib/hashira/analysis/namespace_placement.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "placement"
+
+class Hashira::Analysis::NamespacePlacement < Hashira::Analysis::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::Analysis::Folding.new(catalog, census, suffixes: suffixes)
+
+  private
+
+  def suffixes = project.rails? ? Hashira::Analysis::Folding::SUFFIXES : []
+end

data/lib/hashira/analysis/namespace_prefix.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Analysis
+    module NamespacePrefix
+      module_function
+
+      def infer(definitions)
+        build(definitions.map { |_node, full, _package| full }.uniq)
+      end
+
+      def build(fulls, prefix = [])
+        depth = prefix.length
+        wrapper = wrapper(fulls, depth)
+        return prefix unless wrapper
+        build(fulls.select { it[depth] == wrapper }, prefix + [wrapper])
+      end
+
+      def wrapper(fulls, depth)
+        wrapper, count = fulls.filter_map { it[depth] if it[depth + 1] }.tally.max_by { |_wrapper, tally| tally }
+        wrapper if wrapper && count == peers(fulls, depth, wrapper)
+      end
+
+      def peers(fulls, depth, wrapper)
+        fulls.count do |full|
+          size = full.length
+          size > depth && !(size == depth + 1 && full[depth] == wrapper)
+        end
+      end
+    end
+  end
+end

data/lib/hashira/analysis/naming.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Hashira::Analysis::Naming
+  def initialize(definitions)
+    @segments = Hashira::Analysis::NamespacePrefix.infer(definitions)
+  end
+
+  attr_reader :segments
+
+  def strip(path)
+    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/analysis/no_folding.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Analysis
+    module NoFolding
+      module_function
+
+      def map = {}
+
+      def disclosed = []
+    end
+  end
+end

data/lib/hashira/analysis/node_walk.rb

@@ -5,14 +5,14 @@ module Hashira
     module NodeWalk
       module_function
 
-      def each_node(node, &)
+      def each(node, &)
         yield(node)
-        node.compact_child_nodes.each { each_node(it, &) }
+        node.compact_child_nodes.each { each(it, &) }
       end
 
       def collect(node)
         found = []
-        each_node(node) { found << it }
+        each(node) { found << it }
         found
       end
     end

data/lib/hashira/analysis/placement.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class Hashira::Analysis::Placement
+  def self.build(packaging, project, catalog)
+    {
+      folder: Hashira::Analysis::FolderPlacement,
+      namespace: Hashira::Analysis::NamespacePlacement
+    }.fetch(packaging).new(project, catalog)
+  end
+
+  def initialize(project, catalog)
+    @project = project
+    @catalog = catalog
+  end
+
+  private
+
+  attr_reader :project, :catalog
+end

data/lib/hashira/analysis/references.rb

@@ -8,31 +8,32 @@ module Hashira
       module_function
 
       def list(tree)
-        each_sighting(tree).map(&:first)
+        sightings(tree).map(&:first)
       end
 
-      def each_sighting(tree)
-        [].tap { collect(tree, it) }
+      def sightings(tree, roots = nil)
+        [].tap { collect(tree, [], it, roots) }
       end
 
-      def collect(node, accumulator)
+      def collect(node, nesting, accumulator, roots, home = nesting)
         return unless node
-        return accumulator << [Syntax.path_segments(node), node.location.start_line] if constant?(node)
+        return accumulator << sighting(node, nesting, home) if constant?(node)
+        return enter(node, nesting, accumulator, roots) if definition?(node)
+        node.compact_child_nodes.each { collect(it, nesting, accumulator, roots, home) }
+      end
 
-        branches(node).each { collect(it, accumulator) }
+      def sighting(node, nesting, home)
+        [Syntax.segments(node), node.location.start_line, Syntax.cbase?(node) ? nil : nesting, home]
       end
 
       def constant?(node) = node.is_a?(Prism::ConstantPathNode) || node.is_a?(Prism::ConstantReadNode)
 
-      def branches(node)
-        definition?(node) ? definition_branches(node) : node.compact_child_nodes
-      end
-
       def definition?(node) = node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)
 
-      def definition_branches(node)
-        superclass = node.is_a?(Prism::ClassNode) ? node.superclass : nil
-        [superclass, node.body]
+      def enter(node, nesting, accumulator, roots)
+        opened = nesting + [Syntax.anchor(nesting, Syntax.segments(node.constant_path), roots)]
+        collect(node.superclass, nesting, accumulator, roots, opened) if node.is_a?(Prism::ClassNode)
+        collect(node.body, opened, accumulator, roots)
       end
     end
   end

data/lib/hashira/analysis/resolver.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Hashira::Analysis::Resolver
+  def initialize(registry, catalog, placement)
+    @registry = registry
+    @catalog = catalog
+    @placement = placement
+  end
+
+  def resolve(segments, nesting)
+    return if @placement.skip?(segments)
+    scoped = nesting.reverse_each.filter_map { descend(it, segments) }.first
+    scoped ? qualify(scoped) : @registry.package(@catalog.strip(segments))
+  end
+
+  def pinpoint(segments)
+    return if @placement.skip?(segments)
+    qualify(descend([], segments))
+  end
+
+  private
+
+  def descend(entry, segments)
+    segments.length.downto(1).filter_map { @registry.exact(@catalog.strip(entry + segments.first(it))) }.first
+  end
+
+  def qualify(found) = (found unless found == Hashira::Analysis::ConstantRegistry::AMBIGUOUS)
+end

data/lib/hashira/analysis/roster.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Hashira::Analysis::Roster
+  def initialize(placed)
+    @registry = Hashira::Analysis::ConstantRegistry.new
+    @types = Hash.new(0)
+    counted = Set.new
+    placed.each { |definition, package| admit(definition, package, counted) }
+  end
+
+  attr_reader :registry, :types
+
+  def origins = @registry.origins
+
+  def packages = @types.keys | @registry.packages
+
+  private
+
+  def admit(definition, package, counted)
+    return unless package
+    path = definition.path
+    @registry.register(path, package)
+    @types[package] += 1 if definition.counted? && counted.add?(path)
+  end
+end

data/lib/hashira/analysis/rule.rb

@@ -1,22 +1,18 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Analysis
-    class Rule
-      def initialize(project, graph)
-        @project = project
-        @graph = graph
-      end
+class Hashira::Analysis::Rule
+  def initialize(project, graph)
+    @project = project
+    @graph = graph
+  end
 
-      private
+  private
 
-      attr_reader :project, :graph
+  attr_reader :project, :graph
 
-      def metrics = @metrics ||= graph.metrics
+  def metrics = @metrics ||= graph.metrics
 
-      def finding(**attributes)
-        Finding.new(kind: self.class::KIND, cycle: nil, **attributes)
-      end
-    end
+  def finding(**attributes)
+    Hashira::Analysis::Finding.new(kind: self.class::KIND, cycle: nil, **attributes)
   end
 end

data/lib/hashira/analysis/sdp_check.rb

@@ -1,18 +1,14 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Analysis
-    class SdpCheck
-      def initialize(dependencies, metrics)
-        @dependencies = dependencies
-        @metrics = metrics
-      end
+class Hashira::Analysis::SdpCheck
+  def initialize(dependencies, metrics)
+    @dependencies = dependencies
+    @metrics = metrics
+  end
 
-      def violations
-        @dependencies.flat_map do |from, tos|
-          tos.select { @metrics[it].instability > @metrics[from].instability }.map { [from, it] }
-        end
-      end
+  def violations
+    @dependencies.flat_map do |from, tos|
+      tos.select { @metrics[it].instability > @metrics[from].instability }.map { [from, it] }
     end
   end
 end

data/lib/hashira/analysis/sdp_violation_findings.rb

@@ -1,27 +1,29 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Analysis
-    class SdpViolationFindings < Rule
-      KIND = "sdp_violation"
+require_relative "rule"
 
-      def list
-        graph.sdp_violations.sort_by { |from, to| instability(from) - instability(to) }
-                            .map { |from, to| violation_finding(from, to) }
-      end
+class Hashira::Analysis::SdpViolationFindings < Hashira::Analysis::Rule
+  KIND = "sdp_violation"
 
-      private
+  def list
+    ranked.map { |from, to| violation(from, to) }
+  end
+
+  private
 
-      def violation_finding(from, to)
-        finding(package: from, evidence: graph.evidence_for(from, to).to_a.first(5),
-                message: "#{from} (I=#{label(from)}) depends on the LESS stable #{to} " \
-                         "(I=#{label(to)}) — churn in #{to} will force churn in #{from}. " \
-                         "Invert the edge or extract the stable part of #{to} that #{from} needs.")
-      end
+  def ranked = graph.violations.sort_by { |from, to| instability(from) - instability(to) }
 
-      def instability(package) = metrics[package].instability
+  def violation(from, to)
+    finding(package: from, evidence: graph.evidence(from, to).to_a.first(5), message: message(from, to))
+  end
 
-      def label(package) = format("%.2f", instability(package))
-    end
+  def message(from, to)
+    "#{from} (I=#{label(from)}) depends on the LESS stable #{to} " \
+      "(I=#{label(to)}) — churn in #{to} will force churn in #{from}. " \
+      "Invert the edge or extract the stable part of #{to} that #{from} needs."
   end
+
+  def instability(package) = metrics[package].instability
+
+  def label(package) = format("%.2f", instability(package))
 end

data/lib/hashira/analysis/syntax.rb

@@ -7,20 +7,35 @@ module Hashira
     module Syntax
       module_function
 
-      def path_segments(node)
+      def segments(node)
         case node
         when Prism::ConstantReadNode then [node.name.to_s]
-        when Prism::ConstantPathNode then path_segments(node.parent) + name_of(node)
+        when Prism::ConstantPathNode then segments(node.parent) + label(node)
         else []
         end
       end
 
-      def name_of(node) = [node.name.to_s]
+      def label(node) = [node.name.to_s]
 
-      def direct_definitions(type_node)
+      def cbase?(node)
+        return false unless node.is_a?(Prism::ConstantPathNode)
+        parent = node.parent
+        !parent || cbase?(parent)
+      end
+
+      def anchor(stack, segments, roots)
+        return (stack.last || []) + segments if segments.length < 2 || !roots
+        base = stack.reverse_each.find { roots.include?(it + segments.first(1)) }
+        base ? base + segments : hoist(stack, segments, roots)
+      end
+
+      def hoist(stack, segments, roots)
+        roots.include?(segments.first(1)) ? segments : (stack.last || []) + segments
+      end
+
+      def direct(type_node)
         body = type_node.body
-        statements = body.is_a?(Prism::StatementsNode) ? body.body : [body]
-        statements.grep(Prism::DefNode)
+        (body.is_a?(Prism::StatementsNode) ? body.body : [body]).grep(Prism::DefNode)
       end
     end
   end