hashira 0.2.0 → 0.4.0

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

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

data/lib/hashira/hotspots/rollup.rb

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

data/lib/hashira/pipeline.rb

@@ -2,49 +2,54 @@
 
 require "prism"
 
-module Hashira
-  class Pipeline
-    ANALYZERS = %i[coupling complexity duplication].freeze
+class Hashira::Pipeline
+  ANALYZERS = %i[coupling complexity duplication].freeze
 
-    RULES = [Analysis::CycleFindings, Analysis::SdpViolationFindings].freeze
+  RULES = [Hashira::Analysis::CycleFindings, Hashira::Analysis::SdpViolationFindings].freeze
 
-    def initialize(project, enabled: ANALYZERS)
-      @project = project
-      @enabled = enabled
-      @trees = project.files.to_h { [it, parse(it)] }
-      @graph = Analysis::Graph.new(project, @trees, Analysis::Census.new(project, @trees))
-    end
+  def initialize(project, enabled: ANALYZERS, packaging: :auto)
+    @project = project
+    @enabled = enabled
+    @trees = project.files.to_h { [it, parse(it)] }
+    @graph = Hashira::Analysis::Graph.new(project, @trees, census(settle(packaging)))
+  end
 
-    attr_reader :project, :graph
+  attr_reader :project, :graph
 
-    def complexity
-      @complexity ||= Complexity::Analyzer.new(@project, @trees) if enabled?(:complexity)
-    end
+  def complexity
+    @complexity ||= Hashira::Complexity::Analyzer.new(@project, @trees) if enabled?(:complexity)
+  end
 
-    def duplication
-      @duplication ||= Duplication::Analyzer.new(@project, @trees, churn) if enabled?(:duplication)
-    end
+  def duplication
+    @duplication ||= Hashira::Duplication::Analyzer.new(@project, @trees, churn) if enabled?(:duplication)
+  end
 
-    def hotspots
-      @hotspots ||= Hotspots::Rollup.new(complexity, duplication, churn) if complexity || duplication
-    end
+  def hotspots
+    @hotspots ||= Hashira::Hotspots::Rollup.new(complexity, duplication, churn) if complexity || duplication
+  end
 
-    def churn = @churn ||= Churn.from_git
+  def churn = @churn ||= Hashira::Churn.scan
 
-    def enabled?(analyzer) = @enabled.include?(analyzer)
+  def enabled?(analyzer) = @enabled.include?(analyzer)
 
-    def findings = coupling_findings + listed(complexity) + listed(duplication)
+  def findings = structural + listed(complexity) + listed(duplication)
 
-    private
+  private
+
+  def census(packaging) = Hashira::Analysis::Census.new(@project, @trees, packaging:)
+
+  def settle(packaging)
+    return packaging unless packaging == :auto
+    @project.rails? ? :namespace : :folder
+  end
 
-    def coupling_findings = enabled?(:coupling) ? RULES.flat_map { it.new(@project, @graph).list } : []
+  def structural = enabled?(:coupling) ? RULES.flat_map { it.new(@project, @graph).list } : []
 
-    def listed(analyzer) = analyzer ? analyzer.findings : []
+  def listed(analyzer) = analyzer ? analyzer.findings : []
 
-    def parse(path)
-      Prism.parse_file(path).value
-    rescue SystemCallError => error
-      raise Error, "cannot read #{path} (#{error.message})"
-    end
+  def parse(path)
+    Prism.parse_file(path).value
+  rescue SystemCallError => error
+    raise(Hashira::Error, "cannot read #{path} (#{error.message})")
   end
 end

data/lib/hashira/project.rb

@@ -1,50 +1,71 @@
 # frozen_string_literal: true
 
-module Hashira
-  class Project
-    ROOT_PACKAGE = "(root)"
+class Hashira::Project
+  ROOT_PACKAGE = "(root)"
 
-    def self.detect(directories)
-      directories.empty? ? new(default_directories) : new(directories)
-    end
+  def self.detect(directories)
+    new((directories.empty? ? defaults : directories).map { descend(it.delete_suffix("/")) })
+  end
 
-    def self.default_directories
-      subdirectories = Dir["lib/*/"].map { File.basename(it) }
-      raise Error, "no lib/ directory here — pass the source directory explicitly" if subdirectories.empty?
+  def self.defaults
+    raise(Hashira::Error, "no lib/ directory here — pass the source directory explicitly") if Dir["lib/*/"].empty?
+    ["lib"]
+  end
+  private_class_method :defaults
 
-      subdirectories.size == 1 ? ["lib/#{subdirectories.first}"] : ["lib"]
-    end
-    private_class_method :default_directories
+  def self.descend(directory)
+    child = sole(directory)
+    return directory unless child && Dir["#{child}/*/"].any? && (Dir["#{directory}/*.rb"] - ["#{child}.rb"]).empty?
+    descend(child)
+  end
 
-    def initialize(directories)
-      missing = directories.reject { Dir.exist?(it) }
-      raise Error, "no such directory: #{missing.join(", ")}" unless missing.empty?
+  def self.sole(directory)
+    subdirectories = Dir["#{directory}/*/"]
+    subdirectories.size == 1 ? subdirectories.first.delete_suffix("/") : nil
+  end
+  private_class_method :descend, :sole
 
-      @directories = directories.map { it.delete_suffix("/") }
-    end
+  def initialize(directories)
+    missing = directories.reject { Dir.exist?(it) }
+    raise(Hashira::Error, "no such directory: #{missing.join(", ")}") unless missing.empty?
+    @directories = directories.map { it.delete_suffix("/") }
+    @rails = @directories.any? { config?(File.expand_path(it)) }
+  end
 
-    attr_reader :directories
+  attr_reader :directories
 
-    def files = @directories.flat_map { Dir["#{it}/**/*.rb"] }.sort
+  def rails? = @rails
 
-    def package_for(path)
-      first, rest = relative(path).delete_suffix(".rb").split("/", 2)
-      rest || folder?(path, first) ? first : ROOT_PACKAGE
-    end
+  def files = @directories.flat_map { Dir["#{it}/**/*.rb"] }.sort
 
-    def relative(path) = path.delete_prefix("#{directory_of(path)}/")
+  def package(path)
+    first, rest = relative(path).delete_suffix(".rb").split("/", 2)
+    return ROOT_PACKAGE unless rest || folder?(path, first)
+    contested.include?(first) ? "#{parent(path)}/#{first}" : first
+  end
 
-    def label = @directories.join(", ")
+  def relative(path) = path.delete_prefix("#{parent(path)}/")
 
-    def root_package = ROOT_PACKAGE
+  def label = @directories.join(", ")
 
-    private
+  def root = ROOT_PACKAGE
 
-    def folder?(path, name) = Dir.exist?("#{directory_of(path)}/#{name}")
+  private
+
+  def config?(directory)
+    ["config/application.rb", "../config/application.rb"].any? { File.exist?(File.expand_path(it, directory)) }
+  end
+
+  def folder?(path, name) = Dir.exist?("#{parent(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?("#{it}/") } ||
-        raise(Error, "#{path} is outside the analyzed directories")
-    end
+  def parent(path)
+    @directories.find { path.start_with?("#{it}/") } ||
+      raise(Hashira::Error, "#{path} is outside the analyzed directories")
   end
 end

data/lib/hashira/report/complexity_table.rb

@@ -1,40 +1,36 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Report
-    class ComplexityTable
-      TOP = 10
-      METHOD_ROW = "%-44s %4s %6s  %s"
-      CLASS_ROW = "%-32s %5s %8s %6s"
+class Hashira::Report::ComplexityTable
+  TOP = 10
+  METHOD_ROW = "%-44s %4s %6s  %s"
+  CLASS_ROW = "%-32s %5s %8s %6s"
+  METHOD_TITLE = "Cognitive complexity — worst methods (Cog = how hard to read, Calls = message sends)"
+  CLASS_TITLE = "Per-class rollup (Cog total survives extract-method; Peak is the worst method it hides)"
 
-      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
+  def initialize(complexity, io: $stdout)
+    @complexity = complexity
+    @io = io
+  end
 
-      private
+  def print
+    section(@complexity.methods, METHOD_ROW, %w[method Cog Calls Loc], METHOD_TITLE)
+    section(@complexity.classes, CLASS_ROW, %w[class Cog Methods Peak], CLASS_TITLE)
+  end
 
-      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
+  private
 
-      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 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 ranked(scores) = scores.select { it.cognitive.positive? }.first(TOP)
-    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

data/lib/hashira/report/dependency_map.rb

@@ -1,30 +1,25 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Report
-    class DependencyMap
-      def initialize(graph, io: $stdout)
-        @graph = graph
-        @io = io
-      end
-
-      def print
-        @io.puts "Dependencies (DependsUpon(refs) -> | <- UsedBy):"
-        @graph.packages.sort.each { @io.puts row(it) }
-      end
+class Hashira::Report::DependencyMap
+  def initialize(graph, io: $stdout)
+    @graph = graph
+    @io = io
+  end
 
-      private
+  def print
+    @io.puts("Dependencies (DependsUpon(refs) -> | <- UsedBy):")
+    @graph.packages.sort.each { @io.puts(row(it)) }
+  end
 
-      def row(package)
-        format("  %-12s -> %-32s <- %s", package,
-               list(depends_upon(package)), list(@graph.dependents_of(package)))
-      end
+  private
 
-      def depends_upon(package)
-        @graph.dependencies_of(package).map { "#{it}(#{@graph.weight(package, it)})" }
-      end
+  def row(package)
+    format("  %-12s -> %-32s <- %s", package, list(outgoing(package)), list(@graph.incoming(package)))
+  end
 
-      def list(items) = items.empty? ? "(none)" : items.join(", ")
-    end
+  def outgoing(package)
+    @graph.outgoing(package).map { "#{it}(#{@graph.weight(package, it)})" }
   end
+
+  def list(items) = items.empty? ? "(none)" : items.join(", ")
 end

data/lib/hashira/report/finding_lines.rb

@@ -1,26 +1,22 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Report
-    class FindingLines
-      SAMPLE = 4
+class Hashira::Report::FindingLines
+  SAMPLE = 4
 
-      def initialize(finding, indent: "", io: $stdout)
-        @finding = finding
-        @indent = indent
-        @io = io
-      end
+  def initialize(finding, indent: "", io: $stdout)
+    @finding = finding
+    @indent = indent
+    @io = io
+  end
 
-      def print
-        @io.puts "#{@indent}#{@finding.kind}: #{@finding.message}"
-        @finding.evidence.first(SAMPLE).each { @io.puts "#{@indent}    · #{it}" }
-      end
+  def print
+    @io.puts("#{@indent}#{@finding.kind}: #{@finding.message}")
+    @finding.evidence.first(SAMPLE).each { @io.puts("#{@indent}    · #{it}") }
+  end
 
-      def print_with_overflow
-        print
-        overflow = @finding.evidence.size - SAMPLE
-        @io.puts "#{@indent}    · … (#{overflow} more)" if overflow.positive?
-      end
-    end
+  def emit
+    print
+    overflow = @finding.evidence.size - SAMPLE
+    @io.puts("#{@indent}    · … (#{overflow} more)") if overflow.positive?
   end
 end

data/lib/hashira/report/graph_payload.rb

@@ -1,29 +1,23 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Report
-    class GraphPayload
-      def initialize(graph)
-        @graph = graph
-      end
+class Hashira::Report::GraphPayload
+  def initialize(graph)
+    @graph = graph
+  end
+
+  def to_h = { packages:, edges:, folds: @graph.folds }
 
-      def to_h = { packages:, edges: }
+  private
 
-      private
+  def packages
+    ranked.to_h { |package, metric| [package, metric.to_h.merge(cyclic: @graph.cycles.through?(package))] }
+  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
-      end
+  def ranked = @graph.metrics.sort_by { |_package, metric| metric.instability }
 
-      def edges
-        @graph.weighted_edges.map do |from, to, weight|
-          { from:, to:, weight:, refs: @graph.evidence_for(from, to).to_a.sort }
-        end
-      end
+  def edges
+    @graph.weighted.map do |from, to, weight|
+      { from:, to:, weight:, refs: @graph.evidence(from, to).to_a.sort }
     end
   end
 end

data/lib/hashira/report/hotspot_table.rb

@@ -1,41 +1,36 @@
 # 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
+class Hashira::Report::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