hashira 0.1.0 → 0.2.0

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,24 @@
+# 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 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,44 @@
+# 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.select { |cluster| cluster.mass >= floor(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

data/lib/hashira/duplication/sequence.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Duplication
+    class Sequence
+      MIN_STATEMENTS = 1
+      MAX_STATEMENTS = 12
+      LIST_RUN = 3
+
+      def initialize(file, statements)
+        @file = file
+        @statements = statements
+      end
+
+      def fragments
+        return [] if listing?
+
+        lengths.flat_map { |length| slide(length) }
+      end
+
+      private
+
+      def listing? = @statements.size >= LIST_RUN && shapes.uniq.size == 1
+
+      def shapes = @statements.map { fragment([it]).types }
+
+      def lengths = MIN_STATEMENTS..[@statements.size, MAX_STATEMENTS].min
+
+      def slide(length) = (0..(@statements.size - length)).map { fragment(@statements[it, length]) }
+
+      def fragment(roots) = Fragment.new(@file, roots)
+    end
+  end
+end

data/lib/hashira/duplication/similarity.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Duplication
+    class Similarity
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def ratio
+        return 0.0 if @left.empty? || @right.empty?
+
+        normalized(lcs)
+      end
+
+      def at_least?(threshold) = upper_bound >= threshold && ratio >= threshold
+
+      private
+
+      def upper_bound = normalized(tokens_in_common)
+
+      def normalized(length) = (2.0 * length) / (@left.size + @right.size)
+
+      def tokens_in_common
+        counts = @right.tally
+        @left.count { taken?(counts, it) }
+      end
+
+      def taken?(counts, token)
+        return false unless counts.fetch(token, 0).positive?
+
+        counts[token] -= 1
+        true
+      end
+
+      def lcs = @left.reduce(blank) { |prev, token| next_row(prev, token) }.last
+
+      def blank = Array.new(@right.size + 1, 0)
+
+      def next_row(prev, token)
+        @right.each_index.reduce([0]) { |row, index| row << cell(prev, row, token, index) }
+      end
+
+      def cell(prev, row, token, index)
+        @right[index] == token ? prev[index] + 1 : [prev[index + 1], row[index]].max
+      end
+    end
+  end
+end

data/lib/hashira/duplication/union_find.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Duplication
+    class UnionFind
+      def initialize
+        @parent = {}
+      end
+
+      def union(left, right) = @parent[root(left)] = root(right)
+
+      def clusters = @parent.keys.group_by { root(it) }.values
+
+      def root(node)
+        @parent[node] = node unless @parent.key?(node)
+        found = @parent[node]
+        found == node ? node : (@parent[node] = root(found))
+      end
+    end
+  end
+end

data/lib/hashira/duplication/variance.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Duplication
+    class Variance
+      LITERALS = %i[integer_node float_node string_node symbol_node].freeze
+      VALUED = %i[integer_node float_node].freeze
+      NAMED = %i[call_node constant_read_node constant_path_node
+                 local_variable_read_node local_variable_write_node
+                 instance_variable_read_node instance_variable_write_node].freeze
+      CONSTANTS = %i[constant_read_node constant_path_node].freeze
+
+      def initialize(canonical, other)
+        @canonical = canonical
+        @other = other
+      end
+
+      def kinds
+        return [:structure] if @canonical.types != @other.types
+
+        differing.map { |node| category(node) }.uniq
+      end
+
+      def shape_only?
+        return false unless @canonical.types == @other.types
+
+        named.any? && named.all? { |left, right| left.name != right.name }
+      end
+
+      private
+
+      def pairs = @canonical.nodes.zip(@other.nodes)
+
+      def named = @named ||= pairs.select { |left, _| NAMED.include?(left.type) }
+
+      def differing = pairs.select { |pair| varies?(*pair) }.map(&:first)
+
+      def varies?(left, right) = signature(left) != signature(right)
+
+      def category(node)
+        type = node.type
+        return :literal if LITERALS.include?(type)
+
+        CONSTANTS.include?(type) ? :constant : :message
+      end
+
+      def signature(node)
+        type = node.type
+        return literal(node) if LITERALS.include?(type)
+
+        node.name if NAMED.include?(type)
+      end
+
+      def literal(node) = VALUED.include?(node.type) ? node.value : node.unescaped
+    end
+  end
+end