hashira 0.1.0 → 0.3.0

data/lib/hashira/complexity/analyzer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Complexity
+    class Analyzer
+      THRESHOLD = 10
+
+      def initialize(project, trees)
+        @project = project
+        @scores = trees.flat_map { |path, tree| scores_for(path, tree) }
+      end
+
+      def methods = @scores.sort_by { -it.cognitive }
+
+      def classes = Rollup.new(@scores).classes.sort_by { -it.cognitive }
+
+      def findings = flagged.map { MethodFinding.new(it).to_finding }
+
+      private
+
+      def flagged = methods.select { it.cognitive >= THRESHOLD }
+
+      def scores_for(path, tree)
+        rel = @project.relative(path)
+        methods_in(tree).map { |full, node| build_score(rel, full, node) }
+      end
+
+      def methods_in(tree)
+        found = []
+        Analysis::TypeWalk.each_definition(tree) do |type_node, full|
+          Analysis::Syntax.direct_definitions(type_node).each { found << [full, it] }
+        end
+        found
+      end
+
+      def build_score(rel, full, node)
+        score = CognitiveScore.new(node)
+        MethodScore.new(subject: subject(full, node), file: rel, line: node.location.start_line,
+                        cognitive: score.total, calls: score.calls, increments: score.increments)
+      end
+
+      def subject(full, node) = "#{full.join("::")}#{node.receiver ? "." : "#"}#{node.name}"
+    end
+  end
+end

data/lib/hashira/complexity/boolean_run.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Complexity
+    class BooleanRun
+      def initialize(scorer)
+        @scorer = scorer
+      end
+
+      def apply(node, nesting)
+        @scorer.add(node, 1, "boolean")
+        operands(node).each { @scorer.visit(it, nesting) }
+      end
+
+      private
+
+      def operands(node)
+        node.compact_child_nodes.flat_map { it.instance_of?(node.class) ? operands(it) : [it] }
+      end
+    end
+  end
+end

data/lib/hashira/complexity/cognitive_score.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+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
+  end
+end

data/lib/hashira/complexity/if_chain.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+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
+    end
+  end
+end

data/lib/hashira/complexity/method_finding.rb

@@ -0,0 +1,52 @@
+# 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
+  end
+end

data/lib/hashira/complexity/method_score.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+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: }
+
+      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
+  end
+end

data/lib/hashira/complexity/rescue_scan.rb

@@ -0,0 +1,28 @@
+# 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
+
+      private
+
+      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
+  end
+end

data/lib/hashira/complexity/rollup.rb

@@ -0,0 +1,22 @@
+# 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) }
+
+      private
+
+      def score(name, group)
+        ClassScore.new(name:, cognitive: group.sum(&:cognitive), method_count: group.size,
+                       peak: group.map(&:cognitive).max)
+      end
+
+      def class_name(subject) = subject.split(/[#.]/, 2).first
+    end
+  end
+end

data/lib/hashira/duplication/analyzer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Duplication
+    class 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 findings = clusters.map { |cluster| DuplicationFinding.new(cluster, @churn).to_finding }
+
+      private
+
+      def fragments = Extractor.new(@project, @trees).fragments
+    end
+  end
+end

data/lib/hashira/duplication/cluster.rb

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

data/lib/hashira/duplication/clusterer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Duplication
+    class 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 = UnionFind.new
+      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
+
+      def chain(group) = group.each_cons(2) { |left, right| @sets.union(left, right) }
+
+      def sized = built.filter_map { admitted(it) }
+
+      def admitted(cluster) = [cluster, exact_core(cluster)].compact.find { fits?(it) }
+
+      def fits?(cluster) = cluster.mass >= floor(cluster)
+
+      def exact_core(cluster) = Grouping.new(cluster.exact_sites).cluster
+
+      def built = @sets.clusters.filter_map { |group| Grouping.new(group).cluster }
+
+      def floor(cluster) = base(cluster) + idiom_penalty(cluster)
+
+      def base(cluster) = thin_evidence?(cluster) ? NEAR_MASS : BASE_MASS
+
+      def thin_evidence?(cluster) = !one_shape?(cluster) || cluster.shape_only?
+
+      def idiom_penalty(cluster) = recurrences(cluster) * PENALTY_PER_RECURRENCE
+
+      def recurrences(cluster) = [cluster.size - PAIR, 0].max
+
+      def one_shape?(cluster) = cluster.sites.map(&:types).uniq.size == 1
+    end
+  end
+end

data/lib/hashira/duplication/delta.rb

@@ -0,0 +1,39 @@
+# 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)
+
+      def kind
+        tags = kinds
+        return :identical if tags.empty?
+        return :structure if tags.include?(:structure)
+
+        tags.size == 1 ? tags.first : :mixed
+      end
+
+      def to_h
+        { mass: @cluster.mass, sites: @cluster.size, kind:,
+          locations: @cluster.sites.sort_by(&:sort_key).map(&:range) }
+      end
+
+      private
+
+      def kinds = @cluster.others.flat_map { |other| Variance.new(@cluster.canonical, other).kinds }.uniq
+    end
+  end
+end

data/lib/hashira/duplication/duplication_finding.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Duplication
+    class DuplicationFinding
+      def initialize(cluster, churn)
+        @cluster = cluster
+        @churn = churn
+      end
+
+      def to_finding
+        site = @cluster.canonical
+        Analysis::Finding.new(kind: "duplication", package: site.location, digest: site.digest,
+                              cycle: nil, message:, evidence:)
+      end
+
+      private
+
+      def message
+        "#{@cluster.size} similar fragments (mass #{@cluster.mass}) — #{Delta.new(@cluster).summary}#{note}"
+      end
+
+      def evidence = @cluster.sites.sort_by(&:sort_key).map(&:range)
+
+      def note
+        @churn.hot?(@cluster.sites) ? " Both sites change often — fix one, miss the other." : ""
+      end
+    end
+  end
+end

data/lib/hashira/duplication/extractor.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Hashira
+  module Duplication
+    class Extractor
+      WHOLE = [Prism::DefNode, Prism::WhenNode, Prism::RescueNode].freeze
+
+      def initialize(project, trees)
+        @project = project
+        @fragments = trees.flat_map { |path, tree| from_tree(@project.relative(path), tree) }
+      end
+
+      attr_reader :fragments
+
+      private
+
+      def from_tree(rel, tree)
+        nodes = Analysis::NodeWalk.collect(tree)
+        windows(rel, nodes) + wholes(nodes).map { Fragment.new(rel, [it]) }
+      end
+
+      def windows(rel, nodes) = runs(nodes).flat_map { Sequence.new(rel, it).fragments }
+
+      def runs(nodes) = nodes.filter_map { it.body if it.is_a?(Prism::StatementsNode) }
+
+      def wholes(nodes) = nodes.select { WHOLE.include?(it.class) }
+    end
+  end
+end

data/lib/hashira/duplication/fragment.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Hashira
+  module Duplication
+    class Fragment
+      DIGEST_LENGTH = 12
+
+      def initialize(file, roots)
+        @file = file
+        @roots = roots
+      end
+
+      attr_reader :file
+
+      def types = @types ||= nodes.map(&:type)
+
+      def digest = Digest::SHA256.hexdigest(shape).slice(0, DIGEST_LENGTH)
+
+      def shape = types.join(",")
+
+      def mass = types.size
+
+      def line = @roots.first.location.start_line
+
+      def finish = @roots.last.location.end_line
+
+      def location = "#{file}:#{line}"
+
+      def range = "#{file}:#{line}-#{finish}"
+
+      def sort_key = [file, line]
+
+      def overlaps?(other) = file == other.file && line <= other.finish && other.line <= finish
+
+      def overlaps_any?(others) = others.any? { overlaps?(it) }
+
+      def nodes = @nodes ||= @roots.flat_map { Analysis::NodeWalk.collect(it) }
+    end
+  end
+end

data/lib/hashira/duplication/grouping.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Duplication
+    class Grouping
+      def initialize(group)
+        @group = group
+      end
+
+      def cluster
+        sites = distinct
+        Cluster.new(sites) if sites.size >= 2
+      end
+
+      private
+
+      def distinct
+        @group.sort_by { -it.mass }.each_with_object([]) do |fragment, kept|
+          kept << fragment unless fragment.overlaps_any?(kept)
+        end
+      end
+    end
+  end
+end

data/lib/hashira/duplication/index.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Duplication
+    class Index
+      RARE = 2
+      MAX_BUCKET = 60
+
+      def initialize(fragments)
+        @fragments = fragments
+        @document_frequency = frequencies(fragments)
+      end
+
+      def buckets = grouped.values.select { |bucket| bucket.size.between?(2, MAX_BUCKET) }
+
+      private
+
+      def frequencies(fragments)
+        fragments.each_with_object(Hash.new(0)) { |fragment, counts| tally(counts, fragment) }
+      end
+
+      def tally(counts, fragment) = fragment.types.uniq.each { |type| counts[type] += 1 }
+
+      def grouped
+        index = Hash.new { |hash, type| hash[type] = [] }
+        @fragments.each { |fragment| file(index, fragment) }
+        index
+      end
+
+      def file(index, fragment) = rarest(fragment).each { |type| index[type] << fragment }
+
+      def rarest(fragment) = fragment.types.uniq.min_by(RARE) { @document_frequency[it] }
+    end
+  end
+end

data/lib/hashira/duplication/maximal.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Duplication
+    class Maximal
+      def initialize(clusters)
+        @clusters = clusters
+      end
+
+      def reduced
+        @clusters.sort_by { -it.mass }.each_with_object([]) do |cluster, kept|
+          kept << cluster unless shadowed_by?(cluster, kept.flat_map(&:sites))
+        end
+      end
+
+      private
+
+      def shadowed_by?(cluster, bigger) = cluster.sites.all? { it.overlaps_any?(bigger) }
+    end
+  end
+end

data/lib/hashira/duplication/near_miss.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Duplication
+    class NearMiss
+      THRESHOLD = 0.8
+      MASS_RATIO = 1.5
+
+      def initialize(fragments)
+        @fragments = fragments
+      end
+
+      def pairs = Index.new(@fragments).buckets.flat_map { |bucket| verified(bucket) }.uniq
+
+      private
+
+      def verified(bucket) = bucket.combination(2).select { |left, right| near?(left, right) }
+
+      def near?(left, right)
+        return false unless comparable?(left, right) && !left.overlaps?(right)
+
+        drifted?(left.types, right.types)
+      end
+
+      def drifted?(first, second) = first != second && Similarity.new(first, second).at_least?(THRESHOLD)
+
+      def comparable?(left, right)
+        masses = [left.mass, right.mass]
+        masses.max <= masses.min * MASS_RATIO
+      end
+    end
+  end
+end