hashira 0.1.0 → 0.3.0

data/lib/hashira/duplication/sequence.rb

@@ -0,0 +1,36 @@
+# 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 = segments.flat_map { windows(it) }
+
+      private
+
+      def segments = runs.chunk { listing?(it) }.filter_map { |listed, group| group.flatten(1) unless listed }
+
+      def listing?(run) = run.size >= LIST_RUN
+
+      def runs = shaped.slice_when { |left, right| left.last != right.last }.map { it.map(&:first) }
+
+      def shaped = @statements.map { [it, fragment([it]).types] }
+
+      def windows(segment) = lengths(segment).flat_map { |length| slide(segment, length) }
+
+      def lengths(segment) = MIN_STATEMENTS..[segment.size, MAX_STATEMENTS].min
+
+      def slide(segment, length) = (0..(segment.size - length)).map { fragment(segment[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

data/lib/hashira/hotspots/file_cost.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Hotspots
+    CHURN_FLOOR = 1
+
+    FileCost = Data.define(:file, :cognitive, :duplication, :churn) do
+      def cost = cognitive + duplication
+
+      def rank = cost * effective_churn
+
+      def effective_churn = [churn, CHURN_FLOOR].max
+
+      def to_h = { file:, cognitive:, duplication:, churn:, cost:, rank: }
+
+      def cells = [file, cognitive, duplication, churn, rank]
+    end
+  end
+end

data/lib/hashira/hotspots/rollup.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Hotspots
+    class Rollup
+      def initialize(complexity, duplication, churn)
+        @complexity = complexity
+        @duplication = duplication
+        @churn = churn
+      end
+
+      def files = costs.reject { it.cost.zero? }.sort_by { [-it.rank, it.file] }
+
+      private
+
+      def costs = (cognitive.keys | duplicated.keys).map { cost_for(it) }
+
+      def cost_for(file)
+        FileCost.new(file:, cognitive: cognitive[file], duplication: duplicated[file], churn: @churn.hits(file))
+      end
+
+      def scores = @complexity ? @complexity.methods : []
+
+      def clusters = @duplication ? @duplication.clusters : []
+
+      def cognitive = @cognitive ||= per_file(scores.map { [it.file, it.cognitive] })
+
+      def duplicated = @duplicated ||= per_file(clusters.flat_map(&:site_masses))
+
+      def per_file(charges) = charges.each_with_object(Hash.new(0)) { |(file, cost), total| total[file] += cost }
+    end
+  end
+end

data/lib/hashira/pipeline.rb

@@ -4,21 +4,43 @@ require "prism"
 
 module Hashira
   class Pipeline
-    def initialize(project)
+    ANALYZERS = %i[coupling complexity duplication].freeze
+
+    RULES = [Analysis::CycleFindings, Analysis::SdpViolationFindings].freeze
+
+    def initialize(project, enabled: ANALYZERS)
       @project = project
-      trees = project.files.to_h { [_1, parse(_1)] }
-      @census = Analysis::Census.new(project, trees)
-      @graph = Analysis::Graph.new(project, trees, @census)
+      @enabled = enabled
+      @trees = project.files.to_h { [it, parse(it)] }
+      @graph = Analysis::Graph.new(project, @trees, Analysis::Census.new(project, @trees))
     end
 
     attr_reader :project, :graph
 
-    RULES = [Analysis::CycleFindings, Analysis::SdpViolationFindings].freeze
+    def complexity
+      @complexity ||= Complexity::Analyzer.new(@project, @trees) if enabled?(:complexity)
+    end
 
-    def findings = RULES.flat_map { _1.new(@project, @graph).list }
+    def duplication
+      @duplication ||= Duplication::Analyzer.new(@project, @trees, churn) if enabled?(:duplication)
+    end
+
+    def hotspots
+      @hotspots ||= Hotspots::Rollup.new(complexity, duplication, churn) if complexity || duplication
+    end
+
+    def churn = @churn ||= Churn.from_git
+
+    def enabled?(analyzer) = @enabled.include?(analyzer)
+
+    def findings = coupling_findings + listed(complexity) + listed(duplication)
 
     private
 
+    def coupling_findings = enabled?(:coupling) ? RULES.flat_map { it.new(@project, @graph).list } : []
+
+    def listed(analyzer) = analyzer ? analyzer.findings : []
+
     def parse(path)
       Prism.parse_file(path).value
     rescue SystemCallError => error

data/lib/hashira/project.rb

@@ -5,28 +5,46 @@ module Hashira
     ROOT_PACKAGE = "(root)"
 
     def self.detect(directories)
-      return new(directories) unless directories.empty?
+      targets = directories.empty? ? default_directories : directories
+      new(targets.map { descend(it.delete_suffix("/")) })
+    end
 
-      subdirectories = Dir["lib/*/"].map { File.basename(_1) }
-      raise Error, "no lib/ directory here — pass the source directory explicitly" if subdirectories.empty?
+    def self.default_directories
+      raise Error, "no lib/ directory here — pass the source directory explicitly" if Dir["lib/*/"].empty?
 
-      new(subdirectories.size == 1 ? ["lib/#{subdirectories.first}"] : ["lib"])
+      ["lib"]
     end
+    private_class_method :default_directories
+
+    def self.descend(directory)
+      child = only_subdirectory(directory)
+      return directory unless child && Dir["#{child}/*/"].any? && (Dir["#{directory}/*.rb"] - ["#{child}.rb"]).empty?
+
+      descend(child)
+    end
+
+    def self.only_subdirectory(directory)
+      subdirectories = Dir["#{directory}/*/"]
+      subdirectories.size == 1 ? subdirectories.first.delete_suffix("/") : nil
+    end
+    private_class_method :descend, :only_subdirectory
 
     def initialize(directories)
-      missing = directories.reject { Dir.exist?(_1) }
+      missing = directories.reject { Dir.exist?(it) }
       raise Error, "no such directory: #{missing.join(", ")}" unless missing.empty?
 
-      @directories = directories.map { _1.delete_suffix("/") }
+      @directories = directories.map { it.delete_suffix("/") }
     end
 
     attr_reader :directories
 
-    def files = @directories.flat_map { Dir["#{_1}/**/*.rb"] }.sort
+    def files = @directories.flat_map { Dir["#{it}/**/*.rb"] }.sort
 
     def package_for(path)
       first, rest = relative(path).delete_suffix(".rb").split("/", 2)
-      rest || folder?(path, first) ? first : ROOT_PACKAGE
+      return ROOT_PACKAGE unless rest || folder?(path, first)
+
+      contested.include?(first) ? "#{directory_of(path)}/#{first}" : first
     end
 
     def relative(path) = path.delete_prefix("#{directory_of(path)}/")
@@ -39,8 +57,13 @@ module Hashira
 
     def folder?(path, name) = Dir.exist?("#{directory_of(path)}/#{name}")
 
+    def contested
+      @contested ||= @directories.flat_map { |directory| Dir["#{directory}/*/"].map { File.basename(it) } }
+                                 .tally.filter_map { |name, count| name if count > 1 }
+    end
+
     def directory_of(path)
-      @directories.find { path.start_with?("#{_1}/") } ||
+      @directories.find { path.start_with?("#{it}/") } ||
         raise(Error, "#{path} is outside the analyzed directories")
     end
   end

data/lib/hashira/report/complexity_table.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Report
+    class ComplexityTable
+      TOP = 10
+      METHOD_ROW = "%-44s %4s %6s  %s"
+      CLASS_ROW = "%-32s %5s %8s %6s"
+
+      def initialize(complexity, io: $stdout)
+        @complexity = complexity
+        @io = io
+      end
+
+      def print
+        section(@complexity.methods, METHOD_ROW, %w[method Cog Calls Loc],
+                "Cognitive complexity — worst methods (Cog = how hard to read, Calls = message sends)")
+        section(@complexity.classes, CLASS_ROW, %w[class Cog Methods Peak],
+                "Per-class rollup (Cog total survives extract-method; Peak is the worst method it hides)")
+      end
+
+      private
+
+      def section(scores, row_format, columns, title)
+        heading(row_format, columns, title)
+        ranked(scores).each { @io.puts format(row_format, *it.cells) }
+        @io.puts
+      end
+
+      def heading(row_format, columns, title)
+        header = format(row_format, *columns)
+        @io.puts "#{title}:\n\n"
+        @io.puts header
+        @io.puts "-" * header.length
+      end
+
+      def ranked(scores) = scores.select { it.cognitive.positive? }.first(TOP)
+    end
+  end
+end

data/lib/hashira/report/dependency_map.rb

@@ -10,18 +10,21 @@ module Hashira
 
       def print
         @io.puts "Dependencies (DependsUpon(refs) -> | <- UsedBy):"
-        @graph.packages.sort.each { @io.puts row(_1) }
+        @graph.packages.sort.each { @io.puts row(it) }
       end
 
       private
 
       def row(package)
-        depends_upon = @graph.dependencies_of(package).map { "#{_1}(#{@graph.weight(package, _1)})" }.join(", ")
-        used_by = @graph.dependents_of(package).join(", ")
         format("  %-12s -> %-32s <- %s", package,
-               depends_upon.empty? ? "(none)" : depends_upon,
-               used_by.empty? ? "(none)" : used_by)
+               list(depends_upon(package)), list(@graph.dependents_of(package)))
       end
+
+      def depends_upon(package)
+        @graph.dependencies_of(package).map { "#{it}(#{@graph.weight(package, it)})" }
+      end
+
+      def list(items) = items.empty? ? "(none)" : items.join(", ")
     end
   end
 end

data/lib/hashira/report/finding_lines.rb

@@ -13,7 +13,7 @@ module Hashira
 
       def print
         @io.puts "#{@indent}#{@finding.kind}: #{@finding.message}"
-        @finding.evidence.first(SAMPLE).each { @io.puts "#{@indent}    · #{_1}" }
+        @finding.evidence.first(SAMPLE).each { @io.puts "#{@indent}    · #{it}" }
       end
 
       def print_with_overflow

data/lib/hashira/report/graph_payload.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Report
+    class GraphPayload
+      def initialize(graph)
+        @graph = graph
+      end
+
+      def to_h = { packages:, edges: }
+
+      private
+
+      def packages
+        @graph.metrics.sort_by { |_package, metric| metric.instability }
+                      .to_h do |package, metric|
+          [package,
+           metric.to_h.merge(cyclic: @graph.cyclic?(package))]
+        end
+      end
+
+      def edges
+        @graph.weighted_edges.map do |from, to, weight|
+          { from:, to:, weight:, refs: @graph.evidence_for(from, to).to_a.sort }
+        end
+      end
+    end
+  end
+end

data/lib/hashira/report/hotspot_table.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Report
+    class HotspotTable
+      TOP = 10
+      ROW = "%-46s %5s %5s %6s %7s"
+
+      def initialize(hotspots, io: $stdout)
+        @hotspots = hotspots
+        @io = io
+      end
+
+      def print
+        return if ranked.empty?
+
+        heading
+        rows
+        legend
+      end
+
+      private
+
+      def ranked = @ranked ||= @hotspots.files.first(TOP)
+
+      def rows = ranked.each { @io.puts format(ROW, *it.cells) }
+
+      def heading
+        @io.puts "Hotspots — cost × churn (where refactoring pays the most):\n\n"
+        header = format(ROW, *%w[file Cog Dup Churn Rank])
+        @io.puts header
+        @io.puts "-" * header.length
+      end
+
+      def legend
+        @io.puts "\nLegend: Cog cognitive complexity, Dup mass of the clones the file carries,"
+        @io.puts "        Churn commits touching it, Rank (Cog+Dup) × Churn\n\n"
+      end
+    end
+  end
+end

data/lib/hashira/report/json.rb

@@ -5,37 +5,44 @@ require "json"
 module Hashira
   module Report
     class Json
-      def initialize(graph, findings, io: $stdout)
-        @graph = graph
-        @findings = findings
+      def initialize(view, io: $stdout)
+        @view = view
         @io = io
       end
 
       def print
-        @io.puts JSON.pretty_generate(packages:, edges:, findings: @findings.all.map(&:to_h),
-                                      accepted: accepted_entries)
+        @io.puts JSON.pretty_generate(payload)
         0
       end
 
       private
 
-      def accepted_entries
-        @findings.accepted.map { |finding, reason| finding.to_h.merge(reason:) }
+      def payload = base.merge(graph_payload).merge(sections.compact)
+
+      def base = { findings: @view.findings.all.map(&:to_h), accepted: accepted_entries }
+
+      def graph_payload
+        graph = @view.graph
+        graph ? GraphPayload.new(graph).to_h : {}
       end
 
-      def packages
-        @graph.metrics.sort_by { |_package, metric| metric.instability }
-                      .to_h do |package, metric|
-          [package,
-           metric.to_h.merge(cyclic: @graph.cyclic?(package))]
-        end
+      def sections
+        { complexity: (complexity_payload if @view.complexity),
+          duplication: (duplication_payload if @view.duplication),
+          hotspots: @view.hotspots&.files&.map(&:to_h) }
       end
 
-      def edges
-        @graph.weighted_edges.map do |from, to, weight|
-          { from:, to:, weight:, refs: @graph.evidence_for(from, to).to_a.sort }
-        end
+      def accepted_entries
+        @view.findings.accepted.map { |finding, reason| finding.to_h.merge(reason:) }
       end
+
+      def complexity_payload = { methods: method_scores, classes: class_scores }
+
+      def method_scores = @view.complexity.methods.map(&:to_h)
+
+      def class_scores = @view.complexity.classes.map(&:to_h)
+
+      def duplication_payload = @view.duplication.clusters.map { Duplication::Delta.new(it).to_h }
     end
   end
 end

data/lib/hashira/report/metrics_table.rb

@@ -25,8 +25,7 @@ module Hashira
 
       def row(package, metric)
         cyclic = @graph.cyclic?(package) ? "YES" : "-"
-        format("%-12s %3d %3d %3d %5.2f  %-3s", package,
-               metric.type_count, metric.afferent, metric.efferent, metric.instability, cyclic)
+        format("%-12s %3d %3d %3d %5.2f  %-3s", package, *metric.to_h.values, cyclic)
       end
 
       def legend

data/lib/hashira/report/text.rb

@@ -3,27 +3,37 @@
 module Hashira
   module Report
     class Text
-      def initialize(project, graph, findings, io: $stdout)
-        @project = project
-        @graph = graph
-        @findings = findings
+      def initialize(view, io: $stdout)
+        @view = view
         @io = io
       end
 
       def print
-        header
-        MetricsTable.new(@graph, io: @io).print
-        DependencyMap.new(@graph, io: @io).print
+        coupling_sections if @view.graph
+        complexity_section if @view.complexity
+        hotspot_section if @view.hotspots
         findings_section
         0
       end
 
       private
 
-      def header
-        packages = @graph.packages.size
-        @io.puts "Package (layer) metrics for #{@project.label}  " \
-                 "(#{packages} packages, #{@project.files.size} files)\n\n"
+      def coupling_sections
+        graph = @view.graph
+        header(graph)
+        MetricsTable.new(graph, io: @io).print
+        DependencyMap.new(graph, io: @io).print
+      end
+
+      def complexity_section = ComplexityTable.new(@view.complexity, io: @io).print
+
+      def hotspot_section = HotspotTable.new(@view.hotspots, io: @io).print
+
+      def header(graph)
+        project = @view.project
+        packages = graph.packages.size
+        @io.puts "Package (layer) metrics for #{project.label}  " \
+                 "(#{packages} packages, #{project.files.size} files)\n\n"
         single_package_note if packages == 1
       end
 
@@ -33,7 +43,7 @@ module Hashira
       end
 
       def findings_section
-        all = @findings.all
+        all = @view.findings.all
         @io.puts "\nFindings (#{all.size}):"
         print_findings(all)
         accepted_section
@@ -43,11 +53,11 @@ module Hashira
       def print_findings(all)
         return @io.puts "  none ✓ — structure is healthy" if all.empty?
 
-        all.each { FindingLines.new(_1, indent: "  ", io: @io).print_with_overflow }
+        all.each { FindingLines.new(it, indent: "  ", io: @io).print_with_overflow }
       end
 
       def accepted_section
-        accepted = @findings.accepted
+        accepted = @view.findings.accepted
         return if accepted.empty?
 
         @io.puts "\nAccepted (#{accepted.size}):"

data/lib/hashira/report/view.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Report
+    View = Data.define(:project, :graph, :complexity, :duplication, :hotspots, :findings)
+  end
+end

data/lib/hashira/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hashira
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end