hashira 0.2.0 → 0.4.0

data/lib/hashira/duplication/delta.rb

@@ -1,39 +1,38 @@
 # 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
+  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 kind
-        tags = kinds
-        return :identical if tags.empty?
-        return :structure if tags.include?(:structure)
+  def summary = ADVICE.fetch(kind)
 
-        tags.size == 1 ? tags.first : :mixed
-      end
+  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
+  def to_h
+    {
+      mass: @cluster.mass, sites: @cluster.size, kind:,
+      locations: @cluster.sites.sort_by(&:rank).map(&:range)
+    }
+  end
 
-      private
+  private
 
-      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

data/lib/hashira/duplication/duplication_finding.rb

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

data/lib/hashira/duplication/extractor.rb

@@ -2,30 +2,26 @@
 
 require "prism"
 
-module Hashira
-  module Duplication
-    class Extractor
-      WHOLE = [Prism::DefNode, Prism::WhenNode, Prism::RescueNode].freeze
+class Hashira::Duplication::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
+  def initialize(project, trees)
+    @project = project
+    @fragments = trees.flat_map { |path, tree| scan(@project.relative(path), tree) }
+  end
 
-      attr_reader :fragments
+  attr_reader :fragments
 
-      private
+  private
 
-      def from_tree(rel, tree)
-        nodes = Analysis::NodeWalk.collect(tree)
-        windows(rel, nodes) + wholes(nodes).map { Fragment.new(rel, [it]) }
-      end
+  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 { Sequence.new(rel, it).fragments }
+  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 runs(nodes) = nodes.filter_map { it.body if it.is_a?(Prism::StatementsNode) }
 
-      def wholes(nodes) = nodes.select { WHOLE.include?(it.class) }
-    end
-  end
+  def wholes(nodes) = nodes.select { WHOLE.include?(it.class) }
 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/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,34 +1,32 @@
 # 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
-        return [] if listing?
+  private
 
-        lengths.flat_map { |length| slide(length) }
-      end
+  def segments = runs.chunk { listing?(it) }.filter_map { |listed, group| group.flatten(1) unless listed }
 
-      private
+  def listing?(run) = run.size >= LIST_RUN
 
-      def listing? = @statements.size >= LIST_RUN && shapes.uniq.size == 1
+  def runs = shaped.slice_when { |left, right| left.last != right.last }.map { it.map(&:first) }
 
-      def shapes = @statements.map { fragment([it]).types }
+  def shaped = @statements.map { [it, fragment([it]).types] }
 
-      def lengths = MIN_STATEMENTS..[@statements.size, MAX_STATEMENTS].min
+  def windows(segment) = lengths(segment).flat_map { |length| slide(segment, length) }
 
-      def slide(length) = (0..(@statements.size - length)).map { fragment(@statements[it, length]) }
+  def lengths(segment) = MIN_STATEMENTS..[segment.size, MAX_STATEMENTS].min
 
-      def fragment(roots) = Fragment.new(@file, roots)
-    end
-  end
+  def slide(segment, length) = (0..(segment.size - length)).map { fragment(segment[it, length]) }
+
+  def fragment(roots) = Hashira::Duplication::Fragment.new(@file, roots)
 end

data/lib/hashira/duplication/similarity.rb

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