hashira 0.2.0 → 0.4.0

data/lib/hashira/complexity/cognitive_score.rb

@@ -2,71 +2,66 @@
 
 require "prism"
 
-module Hashira
-  module Complexity
-    class CognitiveScore
-      HANDLERS = {
-        Prism::IfNode => :on_if,
-        Prism::UnlessNode => :on_nester,
-        Prism::WhileNode => :on_nester,
-        Prism::UntilNode => :on_nester,
-        Prism::ForNode => :on_nester,
-        Prism::CaseNode => :on_nester,
-        Prism::CaseMatchNode => :on_nester,
-        Prism::BeginNode => :on_begin,
-        Prism::AndNode => :on_boolean,
-        Prism::OrNode => :on_boolean,
-        Prism::BlockNode => :on_block,
-        Prism::CallNode => :on_call
-      }.freeze
-
-      LABELS = {
-        Prism::UnlessNode => "unless", Prism::WhileNode => "while",
-        Prism::UntilNode => "until", Prism::ForNode => "for",
-        Prism::CaseNode => "case", Prism::CaseMatchNode => "case"
-      }.freeze
-
-      def initialize(def_node)
-        @increments = []
-        @calls = 0
-        visit(def_node.body, 0)
-      end
-
-      attr_reader :increments, :calls
-
-      def total = @increments.sum(&:cost)
-
-      def visit(node, nesting)
-        return unless node
-
-        send(HANDLERS.fetch(node.class, :descend), node, nesting)
-      end
-
-      def add(node, cost, label)
-        @increments << Increment.new(line: node.location.start_line, cost:, label:)
-      end
-
-      private
-
-      def descend(node, nesting) = node.compact_child_nodes.each { visit(it, nesting) }
-
-      def on_call(node, nesting)
-        @calls += 1
-        descend(node, nesting)
-      end
-
-      def on_block(node, nesting) = node.compact_child_nodes.each { visit(it, nesting + 1) }
-
-      def on_nester(node, nesting)
-        add(node, 1 + nesting, LABELS.fetch(node.class))
-        node.compact_child_nodes.each { visit(it, nesting + 1) }
-      end
-
-      def on_if(node, nesting) = IfChain.new(self).apply(node, nesting)
-
-      def on_begin(node, nesting) = RescueScan.new(self).apply(node, nesting)
-
-      def on_boolean(node, nesting) = BooleanRun.new(self).apply(node, nesting)
-    end
+class Hashira::Complexity::CognitiveScore
+  HANDLERS = {
+    Prism::IfNode => :on_if,
+    Prism::UnlessNode => :on_nester,
+    Prism::WhileNode => :on_nester,
+    Prism::UntilNode => :on_nester,
+    Prism::ForNode => :on_nester,
+    Prism::CaseNode => :on_nester,
+    Prism::CaseMatchNode => :on_nester,
+    Prism::BeginNode => :on_begin,
+    Prism::AndNode => :on_boolean,
+    Prism::OrNode => :on_boolean,
+    Prism::BlockNode => :on_block,
+    Prism::CallNode => :on_call
+  }.freeze
+
+  LABELS = {
+    Prism::UnlessNode => "unless", Prism::WhileNode => "while",
+    Prism::UntilNode => "until", Prism::ForNode => "for",
+    Prism::CaseNode => "case", Prism::CaseMatchNode => "case"
+  }.freeze
+
+  def initialize(def_node)
+    @increments = []
+    @calls = 0
+    visit(def_node.body, 0)
   end
+
+  attr_reader :increments, :calls
+
+  def total = @increments.sum(&:cost)
+
+  def visit(node, nesting)
+    return unless node
+    __send__(HANDLERS.fetch(node.class, :descend), node, nesting)
+  end
+
+  def add(node, cost, label)
+    @increments << Hashira::Complexity::Increment.new(line: node.location.start_line, cost:, label:)
+  end
+
+  private
+
+  def descend(node, nesting) = node.compact_child_nodes.each { visit(it, nesting) }
+
+  def on_call(node, nesting)
+    @calls += 1
+    descend(node, nesting)
+  end
+
+  def on_block(node, nesting) = node.compact_child_nodes.each { visit(it, nesting + 1) }
+
+  def on_nester(node, nesting)
+    add(node, 1 + nesting, LABELS.fetch(node.class))
+    node.compact_child_nodes.each { visit(it, nesting + 1) }
+  end
+
+  def on_if(node, nesting) = Hashira::Complexity::IfChain.new(self).apply(node, nesting)
+
+  def on_begin(node, nesting) = Hashira::Complexity::RescueScan.new(self).apply(node, nesting)
+
+  def on_boolean(node, nesting) = Hashira::Complexity::BooleanRun.new(self).apply(node, nesting)
 end

data/lib/hashira/complexity/if_chain.rb

@@ -2,44 +2,39 @@
 
 require "prism"
 
-module Hashira
-  module Complexity
-    class IfChain
-      def initialize(scorer)
-        @scorer = scorer
-      end
-
-      def apply(node, nesting)
-        return ternary(node, nesting) unless node.if_keyword
-
-        branch(node, 1 + nesting, nesting, "if")
-      end
-
-      private
-
-      def branch(node, cost, nesting, label)
-        @scorer.add(node, cost, label)
-        @scorer.visit(node.predicate, nesting)
-        @scorer.visit(node.statements, nesting + 1)
-        tail(node.subsequent, nesting)
-      end
-
-      def tail(node, nesting)
-        case node
-        when Prism::IfNode then branch(node, 1, nesting, "elsif")
-        when Prism::ElseNode then otherwise(node, nesting)
-        end
-      end
-
-      def otherwise(node, nesting)
-        @scorer.add(node, 1, "else")
-        @scorer.visit(node.statements, nesting + 1)
-      end
-
-      def ternary(node, nesting)
-        @scorer.add(node, 1, "ternary")
-        node.compact_child_nodes.each { @scorer.visit(it, nesting) }
-      end
+class Hashira::Complexity::IfChain
+  def initialize(scorer)
+    @scorer = scorer
+  end
+
+  def apply(node, nesting)
+    return ternary(node, nesting) unless node.if_keyword
+    branch(node, 1 + nesting, nesting, "if")
+  end
+
+  private
+
+  def branch(node, cost, nesting, label)
+    @scorer.add(node, cost, label)
+    @scorer.visit(node.predicate, nesting)
+    @scorer.visit(node.statements, nesting + 1)
+    tail(node.subsequent, nesting)
+  end
+
+  def tail(node, nesting)
+    case node
+    when Prism::IfNode then branch(node, 1, nesting, "elsif")
+    when Prism::ElseNode then otherwise(node, nesting)
     end
   end
+
+  def otherwise(node, nesting)
+    @scorer.add(node, 1, "else")
+    @scorer.visit(node.statements, nesting + 1)
+  end
+
+  def ternary(node, nesting)
+    @scorer.add(node, 1, "ternary")
+    node.compact_child_nodes.each { @scorer.visit(it, nesting) }
+  end
 end

data/lib/hashira/complexity/method_finding.rb

@@ -1,52 +1,47 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Complexity
-    class MethodFinding
-      ADVICE = {
-        "if" => "flatten the branching — guard clauses, early returns, or polymorphism.",
-        "elsif" => "replace the elsif ladder with a lookup or polymorphic dispatch.",
-        "else" => "flatten the branching — guard clauses, early returns, or polymorphism.",
-        "case" => "a case this size often wants polymorphism or a dispatch table.",
-        "boolean" => "name the compound condition in a predicate method.",
-        "rescue" => "narrow the rescue, or lift error handling to the caller.",
-        "while" => "extract the loop body into its own method.",
-        "until" => "extract the loop body into its own method.",
-        "for" => "extract the loop body into its own method.",
-        "unless" => "invert to a guard clause or a named predicate.",
-        "ternary" => "extract the nested ternary into a named method."
-      }.freeze
-
-      def initialize(score)
-        @score = score
-      end
-
-      def to_finding
-        Analysis::Finding.new(kind: "complexity", package: @score.subject, cycle: nil,
-                              message:, evidence:)
-      end
-
-      private
-
-      def message
-        "#{@score.subject} — cognitive #{@score.cognitive}, #{@score.calls} calls " \
-          "(#{@score.file}:#{@score.line}). #{advice}"
-      end
-
-      def evidence
-        @score.increments.group_by(&:label).map { |label, incs| line_summary(label, incs) }
-      end
-
-      def line_summary(label, incs)
-        lines = incs.map(&:line).uniq
-        "#{label} +#{incs.sum(&:cost)} (line#{"s" if lines.size > 1} #{lines.join(", ")})"
-      end
-
-      def advice = ADVICE.fetch(dominant)
-
-      def dominant
-        @score.increments.group_by(&:label).transform_values { it.sum(&:cost) }.max_by(&:last).first
-      end
-    end
+class Hashira::Complexity::MethodFinding
+  ADVICE = {
+    "if" => "flatten the branching — guard clauses, early returns, or polymorphism.",
+    "elsif" => "replace the elsif ladder with a lookup or polymorphic dispatch.",
+    "else" => "flatten the branching — guard clauses, early returns, or polymorphism.",
+    "case" => "a case this size often wants polymorphism or a dispatch table.",
+    "boolean" => "name the compound condition in a predicate method.",
+    "rescue" => "narrow the rescue, or lift error handling to the caller.",
+    "while" => "extract the loop body into its own method.",
+    "until" => "extract the loop body into its own method.",
+    "for" => "extract the loop body into its own method.",
+    "unless" => "invert to a guard clause or a named predicate.",
+    "ternary" => "extract the nested ternary into a named method."
+  }.freeze
+
+  def initialize(score)
+    @score = score
+  end
+
+  def to_finding
+    Hashira::Analysis::Finding.new(kind: "complexity", package: @score.subject, cycle: nil, message:, evidence:)
+  end
+
+  private
+
+  def message
+    "#{@score.subject} — cognitive #{@score.cognitive}, #{@score.calls} calls " \
+      "(#{@score.file}:#{@score.line}). #{advice}"
+  end
+
+  def evidence
+    @score.increments.group_by(&:label).map { |label, incs| lines(label, incs) }
+  end
+
+  def lines(label, incs)
+    lines = incs.map(&:line).uniq
+    "#{label} +#{incs.sum(&:cost)} (line#{"s" if lines.size > 1} #{lines.join(", ")})"
+  end
+
+  def advice = ADVICE.fetch(dominant)
+
+  def dominant
+    @score.increments.group_by(&:label).transform_values { it.sum(&:cost) }.max_by(&:last).first
   end
 end

data/lib/hashira/complexity/method_score.rb

@@ -4,14 +4,16 @@ module Hashira
   module Complexity
     Increment = Data.define(:line, :cost, :label)
 
-    MethodScore = Data.define(:subject, :file, :line, :cognitive, :calls, :increments) do
-      def to_h = { subject:, file:, line:, cognitive:, calls: }
+    MethodScore =
+      Data.define(:subject, :file, :line, :cognitive, :calls, :increments) do
+        def to_h = { subject:, file:, line:, cognitive:, calls: }
 
-      def cells = [subject, cognitive, calls, "#{file}:#{line}"]
-    end
+        def cells = [subject, cognitive, calls, "#{file}:#{line}"]
+      end
 
-    ClassScore = Data.define(:name, :cognitive, :method_count, :peak) do
-      def cells = [name, cognitive, method_count, peak]
-    end
+    ClassScore =
+      Data.define(:name, :cognitive, :method_count, :peak) do
+        def cells = [name, cognitive, method_count, peak]
+      end
   end
 end

data/lib/hashira/complexity/rescue_scan.rb

@@ -1,28 +1,23 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Complexity
-    class RescueScan
-      def initialize(scorer)
-        @scorer = scorer
-      end
-
-      def apply(node, nesting)
-        @scorer.visit(node.statements, nesting)
-        clauses(node.rescue_clause, nesting)
-        @scorer.visit(node.else_clause, nesting)
-        @scorer.visit(node.ensure_clause, nesting)
-      end
+class Hashira::Complexity::RescueScan
+  def initialize(scorer)
+    @scorer = scorer
+  end
 
-      private
+  def apply(node, nesting)
+    @scorer.visit(node.statements, nesting)
+    clauses(node.rescue_clause, nesting)
+    @scorer.visit(node.else_clause, nesting)
+    @scorer.visit(node.ensure_clause, nesting)
+  end
 
-      def clauses(node, nesting)
-        return unless node
+  private
 
-        @scorer.add(node, 1 + nesting, "rescue")
-        @scorer.visit(node.statements, nesting + 1)
-        clauses(node.subsequent, nesting)
-      end
-    end
+  def clauses(node, nesting)
+    return unless node
+    @scorer.add(node, 1 + nesting, "rescue")
+    @scorer.visit(node.statements, nesting + 1)
+    clauses(node.subsequent, nesting)
   end
 end

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/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/renderer.rb

@@ -1,20 +1,15 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Diagram
-    class Renderer
-      def initialize(graph, format, io: $stdout)
-        @graph = graph
-        @format = format
-        @io = io
-      end
+class Hashira::Diagram::Renderer
+  def initialize(graph, format, io: $stdout)
+    @graph = graph
+    @format = format
+    @io = io
+  end
 
-      def display
-        edges = @graph.weighted_edges
-        renderer = @format == :dot ? Dot.new(edges) : Mermaid.new(edges)
-        @io.puts renderer.source
-        0
-      end
-    end
+  def display
+    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/analyzer.rb

@@ -1,21 +1,17 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Duplication
-    class Analyzer
-      def initialize(project, trees, churn)
-        @project = project
-        @trees = trees
-        @churn = churn
-      end
+class Hashira::Duplication::Analyzer
+  def initialize(project, trees, churn)
+    @project = project
+    @trees = trees
+    @churn = churn
+  end
 
-      def clusters = @clusters ||= Clusterer.new(fragments).clusters.sort_by { -it.mass }
+  def clusters = @clusters ||= Hashira::Duplication::Clusterer.new(fragments).clusters.sort_by { -it.mass }
 
-      def findings = clusters.map { |cluster| DuplicationFinding.new(cluster, @churn).to_finding }
+  def findings = clusters.map { |cluster| Hashira::Duplication::DuplicationFinding.new(cluster, @churn).to_finding }
 
-      private
+  private
 
-      def fragments = Extractor.new(@project, @trees).fragments
-    end
-  end
+  def fragments = Hashira::Duplication::Extractor.new(@project, @trees).fragments
 end

data/lib/hashira/duplication/cluster.rb

@@ -2,23 +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 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/clusterer.rb

@@ -1,44 +1,46 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Duplication
-    class Clusterer
-      PREFILTER = 12
-      BASE_MASS = 16
-      NEAR_MASS = 40
-      PAIR = 2
-      PENALTY_PER_RECURRENCE = 2
+class Hashira::Duplication::Clusterer
+  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 initialize(fragments)
-        @fragments = fragments.select { |fragment| fragment.mass >= PREFILTER }
-        @sets = UnionFind.new
-      end
+  def clusters
+    @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
+  end
 
-      def clusters
-        @fragments.group_by(&:types).each_value { |group| chain(group) }
-        NearMiss.new(@fragments).pairs.each { |left, right| @sets.union(left, right) }
-        Maximal.new(sized).reduced
-      end
+  private
 
-      private
+  def chain(group) = group.each_cons(2) { |left, right| @sets.union(left, right) }
 
-      def chain(group) = group.each_cons(2) { |left, right| @sets.union(left, right) }
+  def sized = built.filter_map { admitted(it) }
 
-      def sized = built.select { |cluster| cluster.mass >= floor(cluster) }
+  def admitted(cluster) = [cluster, core(cluster)].compact.find { fits?(it) }
 
-      def built = @sets.clusters.filter_map { |group| Grouping.new(group).cluster }
+  def fits?(cluster) = cluster.mass >= floor(cluster)
 
-      def floor(cluster) = base(cluster) + idiom_penalty(cluster)
+  def core(cluster) = Hashira::Duplication::Grouping.new(cluster.identical).cluster
 
-      def base(cluster) = thin_evidence?(cluster) ? NEAR_MASS : BASE_MASS
+  def built = @sets.clusters.filter_map { |group| Hashira::Duplication::Grouping.new(group).cluster }
 
-      def thin_evidence?(cluster) = !one_shape?(cluster) || cluster.shape_only?
+  def floor(cluster) = base(cluster) + penalty(cluster)
 
-      def idiom_penalty(cluster) = recurrences(cluster) * PENALTY_PER_RECURRENCE
+  def base(cluster) = thin?(cluster) ? NEAR_MASS : BASE_MASS
 
-      def recurrences(cluster) = [cluster.size - PAIR, 0].max
+  def thin?(cluster) = !uniform?(cluster) || cluster.structural?
 
-      def one_shape?(cluster) = cluster.sites.map(&:types).uniq.size == 1
-    end
-  end
+  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