hashira 0.3.0 → 0.5.0

data/lib/hashira/duplication/duplication_finding.rb

@@ -1,30 +1,24 @@
 # 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
+class Hashira::Duplication::DuplicationFinding
+  def initialize(cluster, churn)
+    @cluster = cluster
+    @churn = churn
+  end
 
-      def message
-        "#{@cluster.size} similar fragments (mass #{@cluster.mass}) — #{Delta.new(@cluster).summary}#{note}"
-      end
+  def to_finding
+    site = @cluster.canonical
+    Hashira::Analysis::Finding.new(kind: "duplication", package: site.location, digest: site.digest, detail:, evidence:)
+  end
 
-      def evidence = @cluster.sites.sort_by(&:sort_key).map(&:range)
+  private
 
-      def note
-        @churn.hot?(@cluster.sites) ? " Both sites change often — fix one, miss the other." : ""
-      end
-    end
+  def detail
+    {
+      size: @cluster.size, mass: @cluster.mass,
+      kind: Hashira::Duplication::Delta.new(@cluster).kind, hot: @churn.hot?(@cluster.sites)
+    }
   end
+
+  def evidence = @cluster.sites.sort_by(&:rank).map(&:range)
 end

data/lib/hashira/duplication/fragment.rb

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

data/lib/hashira/duplication/grouping.rb

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

data/lib/hashira/duplication/harvest.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Duplication::Harvest
+  WHOLE = [Prism::DefNode, Prism::WhenNode, Prism::RescueNode].freeze
+
+  def initialize(project, trees)
+    @project = project
+    @fragments = trees.flat_map { |path, tree| scan(@project.relative(path), tree) }
+  end
+
+  attr_reader :fragments
+
+  private
+
+  def scan(rel, tree)
+    nodes = Hashira::Analysis::NodeWalk.collect(tree)
+    windows(rel, nodes) + wholes(nodes).map { Hashira::Duplication::Fragment.new(rel, [it]) }
+  end
+
+  def windows(rel, nodes) = runs(nodes).flat_map { Hashira::Duplication::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

data/lib/hashira/duplication/index.rb

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

data/lib/hashira/duplication/maximal.rb

@@ -1,21 +1,17 @@
 # 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
+class Hashira::Duplication::Maximal
+  def initialize(clusters)
+    @clusters = clusters
+  end
 
-      def shadowed_by?(cluster, bigger) = cluster.sites.all? { it.overlaps_any?(bigger) }
+  def reduced
+    @clusters.sort_by { -it.mass }.each_with_object([]) do |cluster, kept|
+      kept << cluster unless within?(cluster, kept.flat_map(&:sites))
     end
   end
+
+  private
+
+  def within?(cluster, bigger) = cluster.sites.all? { it.touches?(bigger) }
 end

data/lib/hashira/duplication/near_miss.rb

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

data/lib/hashira/duplication/sequence.rb

@@ -1,36 +1,34 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Duplication
-    class Sequence
-      MIN_STATEMENTS = 1
-      MAX_STATEMENTS = 12
-      LIST_RUN = 3
+class Hashira::Duplication::Sequence
+  MIN_STATEMENTS = 1
+  MAX_STATEMENTS = 12
+  LIST_RUN = 3
+
+  def initialize(file, statements)
+    @file = file
+    @statements = statements
+  end
 
-      def initialize(file, statements)
-        @file = file
-        @statements = statements
-      end
+  def fragments = segments.flat_map { windows(it) }
 
-      def fragments = segments.flat_map { windows(it) }
+  private
 
-      private
+  def segments = runs.chunk { listing?(it) }.filter_map { |listed, group| group.flatten(1) unless listed }
 
-      def segments = runs.chunk { listing?(it) }.filter_map { |listed, group| group.flatten(1) unless listed }
+  def listing?(run) = run.size >= LIST_RUN
 
-      def listing?(run) = run.size >= LIST_RUN
+  def runs = shaped.slice_when { |left, right| left.last != right.last }.map { it.map(&:first) }
 
-      def runs = shaped.slice_when { |left, right| left.last != right.last }.map { it.map(&:first) }
+  def shaped = @statements.map { [it, fragment([it]).types] }
 
-      def shaped = @statements.map { [it, fragment([it]).types] }
+  def windows(segment) = lengths(segment).flat_map { |length| slide(segment, length) }
 
-      def windows(segment) = lengths(segment).flat_map { |length| slide(segment, length) }
+  def lengths(segment) = MIN_STATEMENTS..[segment.size, MAX_STATEMENTS].min
 
-      def lengths(segment) = MIN_STATEMENTS..[segment.size, MAX_STATEMENTS].min
+  def slide(segment, length) = spans(segment, length).map { fragment(segment[it, length]) }
 
-      def slide(segment, length) = (0..(segment.size - length)).map { fragment(segment[it, length]) }
+  def spans(segment, length) = 0..(segment.size - length)
 
-      def fragment(roots) = Fragment.new(@file, roots)
-    end
-  end
+  def fragment(roots) = Hashira::Duplication::Fragment.new(@file, roots)
 end

data/lib/hashira/duplication/similarity.rb

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

data/lib/hashira/duplication/union_find.rb

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

data/lib/hashira/duplication/variance.rb

@@ -1,57 +1,49 @@
 # 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
+class Hashira::Duplication::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
 
-        named.any? && named.all? { |left, right| left.name != right.name }
-      end
+  def kinds
+    return [:structure] if @canonical.types != @other.types
+    differing.map { |node| category(node) }.uniq
+  end
 
-      private
+  def structural?
+    return false unless @canonical.types == @other.types
+    named.any? && named.all? { |left, right| left.name != right.name }
+  end
 
-      def pairs = @canonical.nodes.zip(@other.nodes)
+  private
 
-      def named = @named ||= pairs.select { |left, _| NAMED.include?(left.type) }
+  def pairs = @canonical.nodes.zip(@other.nodes)
 
-      def differing = pairs.select { |pair| varies?(*pair) }.map(&:first)
+  def named = @named ||= pairs.select { |left, _| NAMED.include?(left.type) }
 
-      def varies?(left, right) = signature(left) != signature(right)
+  def differing = pairs.select { |pair| varies?(*pair) }.map(&:first)
 
-      def category(node)
-        type = node.type
-        return :literal if LITERALS.include?(type)
+  def varies?(left, right) = signature(left) != signature(right)
 
-        CONSTANTS.include?(type) ? :constant : :message
-      end
+  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)
+  def signature(node)
+    LITERALS.include?(node.type) ? literal(node) : label(node)
+  end
 
-        node.name if NAMED.include?(type)
-      end
+  def label(node) = (node.name if NAMED.include?(node.type))
 
-      def literal(node) = VALUED.include?(node.type) ? node.value : node.unescaped
-    end
-  end
+  def literal(node) = VALUED.include?(node.type) ? node.value : node.unescaped
 end

data/lib/hashira/error.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
-module Hashira
-  class Error < StandardError; end
+class Hashira::Error < StandardError
+  def self.unknown(flag, value, choices)
+    new("unknown #{flag} #{value.inspect} (use: #{choices.join(", ")})")
+  end
 end

data/lib/hashira/hotspots/file_cost.rb

@@ -4,16 +4,17 @@ module Hashira
   module Hotspots
     CHURN_FLOOR = 1
 
-    FileCost = Data.define(:file, :cognitive, :duplication, :churn) do
-      def cost = cognitive + duplication
+    FileCost =
+      Data.define(:file, :cognitive, :duplication, :churn) do
+        def cost = cognitive + duplication
 
-      def rank = cost * effective_churn
+        def rank = cost * heat
 
-      def effective_churn = [churn, CHURN_FLOOR].max
+        def heat = [churn, CHURN_FLOOR].max
 
-      def to_h = { file:, cognitive:, duplication:, churn:, cost:, rank: }
+        def to_h = { file:, cognitive:, duplication:, churn:, cost:, rank: }
 
-      def cells = [file, cognitive, duplication, churn, rank]
-    end
+        def cells = [file, cognitive, duplication, churn, rank]
+      end
   end
 end