hashira 0.3.0 → 0.5.0

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

@@ -1,31 +1,31 @@
 # frozen_string_literal: true
 
 module Hashira
-  module Analysis
+  module Coupling
     module NamespacePrefix
       module_function
 
       def infer(definitions)
-        build(deepest_definition_per_package(definitions))
+        build(definitions.map { |_node, full, _package| full }.uniq)
       end
 
       def build(fulls, prefix = [])
         depth = prefix.length
-        wrapper = shared_wrapper(fulls, depth)
+        wrapper = wrapper(fulls, depth)
         return prefix unless wrapper
-
         build(fulls.select { it[depth] == wrapper }, prefix + [wrapper])
       end
 
-      def deepest_definition_per_package(definitions)
-        definitions.map { |_node, full, package| [package, full] }
-                   .sort_by { |_package, full| full.length }
-                   .to_h.values
+      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 shared_wrapper(fulls, depth)
-        wrapper, count = fulls.filter_map { it[depth] if it[depth + 1] }.tally.max_by { |_wrapper, tally| tally }
-        wrapper if wrapper && count > fulls.size / 2
+      def peers(fulls, depth, wrapper)
+        fulls.count do |full|
+          size = full.length
+          size > depth && !(size == depth + 1 && full[depth] == wrapper)
+        end
       end
     end
   end

data/lib/hashira/coupling/naming.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Hashira::Coupling::Naming
+  def initialize(definitions)
+    @segments = Hashira::Coupling::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/coupling/no_folding.rb

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

data/lib/hashira/coupling/placement.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class Hashira::Coupling::Placement
+  def self.build(packaging, project, catalog)
+    {
+      folder: Hashira::Coupling::FolderPlacement,
+      namespace: Hashira::Coupling::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/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

data/lib/hashira/coupling/roll_call_findings.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "rule"
+
+class Hashira::Coupling::RollCallFindings < Hashira::Coupling::Rule
+  KIND = "roll_call"
+
+  def list = rolls.map { entry(it) }
+
+  private
+
+  def rolls = Hashira::Coupling::RollCall.new(lists, homes).rolls
+
+  def 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?
+      end
+  end
+
+  def lists = sightings.to_h { |file, _home, words| [file, words] }
+
+  def homes = sightings.to_h { |file, home, _words| [file, home] }
+
+  def entry(roll)
+    words, files, packages = roll.deconstruct
+    finding(package: packages.first, digest: words.join(","), evidence: files, detail: { words:, files:, packages: })
+  end
+end

data/lib/hashira/coupling/roster.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Hashira::Coupling::Roster
+  def initialize(placed)
+    @registry = Hashira::Coupling::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/coupling/rule.rb

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

data/lib/hashira/coupling/scope.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Hashira::Coupling::Scope
+  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::Coupling::ConstantRegistry::AMBIGUOUS)
+end

data/lib/hashira/coupling/sdp_check.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Hashira::Coupling::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
+end

data/lib/hashira/coupling/sdp_violation_findings.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "rule"
+
+class Hashira::Coupling::SdpViolationFindings < Hashira::Coupling::Rule
+  KIND = "sdp_violation"
+
+  def list
+    ranked.map { |from, to| violation(from, to) }
+  end
+
+  private
+
+  def ranked = graph.violations.sort_by { |from, to| instability(from) - instability(to) }
+
+  def violation(from, to)
+    finding(package: from, evidence: graph.evidence(from, to).to_a.first(5), detail: detail(from, to))
+  end
+
+  def detail(from, to)
+    { from:, to:, from_instability: instability(from), to_instability: instability(to) }
+  end
+
+  def instability(package) = metrics[package].instability
+end

data/lib/hashira/coupling/wide_edge_findings.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "rule"
+
+class Hashira::Coupling::WideEdgeFindings < Hashira::Coupling::Rule
+  KIND = "wide_edge"
+
+  WIDTH = 5
+
+  def list
+    graph.edges.select { wide?(it) }.map { entry(it) }
+  end
+
+  private
+
+  def wide?(edge) = graph.constants(edge).size >= WIDTH
+
+  def entry(edge)
+    from, to = edge.deconstruct
+    finding(
+      package: from, digest: "#{from} -> #{to}", evidence: graph.evidence(from, to).to_a.first(4),
+      detail: { from:, to:, constants: graph.constants(edge) }
+    )
+  end
+end

data/lib/hashira/coupling/words.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Hashira::Coupling::Words
+  PATTERN = /\A[a-z][a-z_]*\z/
+
+  module_function
+
+  def list(tree)
+    Hashira::Analysis::NodeWalk.collect(tree).flat_map { entries(it) }.compact.grep(PATTERN).to_set
+  end
+
+  def entries(node)
+    case node
+    when Prism::ArrayNode then node.elements.map { word(it) }
+    when Prism::HashNode then keys(node)
+    else []
+    end
+  end
+
+  def keys(node) = node.elements.grep(Prism::AssocNode).map { word(it.key) }
+
+  def word(node)
+    case node
+    when Prism::SymbolNode, Prism::StringNode then node.unescaped
+    end
+  end
+end

data/lib/hashira/diagram/dot.rb

@@ -1,16 +1,13 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Diagram
-    class Dot
-      def initialize(edges)
-        @edges = edges
-      end
+class Hashira::Diagram::Dot
+  def initialize(edges)
+    @edges = edges
+  end
 
-      def source
-        lines = @edges.map { |from, to, weight| %(  "#{from}" -> "#{to}" [label="#{weight}"];) }
-        "digraph hashira {\n  rankdir=LR;\n#{lines.join("\n")}\n}"
-      end
-    end
+  def source
+    "digraph hashira {\n  rankdir=LR;\n#{@edges.map do |from, to, weight|
+      %(  "#{from}" -> "#{to}" [label="#{weight}"];)
+    end.join("\n")}\n}"
   end
 end

data/lib/hashira/diagram/mermaid.rb

@@ -1,23 +1,18 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Diagram
-    class Mermaid
-      def initialize(edges)
-        @edges = edges
-        @nodes = {}
-      end
+class Hashira::Diagram::Mermaid
+  def initialize(edges)
+    @edges = edges
+    @nodes = {}
+  end
 
-      def source
-        lines = @edges.map { |from, to, weight| "  #{node(from)} -->|#{weight}| #{node(to)}" }
-        "graph LR\n#{lines.join("\n")}"
-      end
+  def source
+    "graph LR\n#{@edges.map { |from, to, weight| "  #{node(from)} -->|#{weight}| #{node(to)}" }.join("\n")}"
+  end
 
-      private
+  private
 
-      def node(package)
-        @nodes[package] ||= "#{package.gsub(/\W/, "_")}[\"#{package}\"]"
-      end
-    end
+  def node(package)
+    @nodes[package] ||= "#{package.gsub(/\W/, "_")}[\"#{package}\"]"
   end
 end

data/lib/hashira/diagram/source.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Hashira::Diagram::Source
+  def initialize(graph, format, io: $stdout)
+    @graph = graph
+    @format = format
+    @io = io
+  end
+
+  def print
+    edges = @graph.weighted
+    @io.puts((@format == :dot ? Hashira::Diagram::Dot.new(edges) : Hashira::Diagram::Mermaid.new(edges)).source)
+    0
+  end
+end

data/lib/hashira/duplication/clones.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Hashira::Duplication::Clones
+  def initialize(project, trees, churn)
+    @project = project
+    @trees = trees
+    @churn = churn
+  end
+
+  def clusters = @clusters ||= Hashira::Duplication::Clusters.new(fragments).sorted
+
+  def findings = clusters.map { |cluster| Hashira::Duplication::DuplicationFinding.new(cluster, @churn).to_finding }
+
+  private
+
+  def fragments = Hashira::Duplication::Harvest.new(@project, @trees).fragments
+end

data/lib/hashira/duplication/cluster.rb

@@ -2,25 +2,26 @@
 
 module Hashira
   module Duplication
-    Cluster = Data.define(:sites) do
-      def canonical = sites.max_by { |site| [shape_count(site), site.mass] }
+    Cluster =
+      Data.define(:sites) do
+        def canonical = sites.max_by { |site| [shapes(site), site.mass] }
 
-      def shape_count(site) = sites.count { |other| other.types == site.types }
+        def shapes(site) = sites.count { |other| other.types == site.types }
 
-      def others
-        chosen = canonical
-        sites.reject { |site| site.equal?(chosen) }
-      end
+        def others
+          chosen = canonical
+          sites.reject { |site| site.equal?(chosen) }
+        end
 
-      def exact_sites = sites.select { it.types == canonical.types }
+        def identical = sites.select { it.types == canonical.types }
 
-      def mass = canonical.mass
+        def mass = canonical.mass
 
-      def size = sites.size
+        def size = sites.size
 
-      def site_masses = sites.map { [it.file, mass] }
+        def masses = sites.map { [it.file, mass] }
 
-      def shape_only? = others.all? { Variance.new(canonical, it).shape_only? }
-    end
+        def structural? = others.all? { Variance.new(canonical, it).structural? }
+      end
   end
 end

data/lib/hashira/duplication/clusters.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class Hashira::Duplication::Clusters
+  PREFILTER = 12
+  BASE_MASS = 16
+  NEAR_MASS = 40
+  PAIR = 2
+  PENALTY_PER_RECURRENCE = 2
+
+  def initialize(fragments)
+    @fragments = fragments.select { |fragment| fragment.mass >= PREFILTER }
+    @sets = Hashira::Duplication::UnionFind.new
+  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) }
+    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 sized = built.filter_map { admitted(it) }
+
+  def admitted(cluster) = [cluster, core(cluster)].compact.find { fits?(it) }
+
+  def fits?(cluster) = cluster.mass >= floor(cluster)
+
+  def core(cluster) = Hashira::Duplication::Grouping.new(cluster.identical).cluster
+
+  def built = @sets.clusters.filter_map { |group| Hashira::Duplication::Grouping.new(group).cluster }
+
+  def floor(cluster) = base(cluster) + penalty(cluster)
+
+  def base(cluster) = thin?(cluster) ? NEAR_MASS : BASE_MASS
+
+  def thin?(cluster) = !uniform?(cluster) || cluster.structural?
+
+  def penalty(cluster) = recurrences(cluster) * PENALTY_PER_RECURRENCE
+
+  def recurrences(cluster) = [cluster.size - PAIR, 0].max
+
+  def uniform?(cluster) = cluster.sites.map(&:types).uniq.size == 1
+end

data/lib/hashira/duplication/delta.rb

@@ -1,39 +1,30 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Duplication
-    class Delta
-      ADVICE = {
-        identical: "byte-for-byte identical — extract a shared method and call it from each site.",
-        literal: "differs only in literal values — extract a method, pass them as arguments.",
-        message: "differs only in the receiver or message — extract a method taking the receiver.",
-        constant: "differs only in a constant — extract a method and parameterize it.",
-        structure: "the control flow differs — extract the common core, but verify by hand (lower confidence).",
-        mixed: "extract the shared shape and pass what differs as parameters."
-      }.freeze
-
-      def initialize(cluster)
-        @cluster = cluster
-      end
-
-      def summary = ADVICE.fetch(kind)
+class Hashira::Duplication::Delta
+  def initialize(cluster)
+    @cluster = cluster
+  end
 
-      def kind
-        tags = kinds
-        return :identical if tags.empty?
-        return :structure if tags.include?(:structure)
+  def kind
+    tags = kinds
+    tags.empty? ? :identical : label(tags)
+  end
 
-        tags.size == 1 ? tags.first : :mixed
-      end
+  def to_h
+    {
+      mass: @cluster.mass, sites: @cluster.size, kind:,
+      locations: @cluster.sites.sort_by(&:rank).map(&:range)
+    }
+  end
 
-      def to_h
-        { mass: @cluster.mass, sites: @cluster.size, kind:,
-          locations: @cluster.sites.sort_by(&:sort_key).map(&:range) }
-      end
+  private
 
-      private
+  def label(tags)
+    return :structure if tags.include?(:structure)
+    tags.size == 1 ? tags.first : :mixed
+  end
 
-      def kinds = @cluster.others.flat_map { |other| Variance.new(@cluster.canonical, other).kinds }.uniq
-    end
+  def kinds
+    @cluster.others.flat_map { |other| Hashira::Duplication::Variance.new(@cluster.canonical, other).kinds }.uniq
   end
 end