hashira 0.3.0 → 0.5.0

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.ranked : []
 
-      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

@@ -1,50 +1,60 @@
 # frozen_string_literal: true
 
 require "prism"
+require_relative "coupling/report"
 
-module Hashira
-  class Pipeline
-    ANALYZERS = %i[coupling complexity duplication].freeze
+class Hashira::Pipeline
+  ANALYZERS = %i[coupling complexity duplication smells].freeze
 
-    RULES = [Analysis::CycleFindings, Analysis::SdpViolationFindings].freeze
+  STRUCTURAL = Hashira::Coupling::Report::RULES.map { it::KIND }.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)] }
+    @coupling = Hashira::Coupling::Report.new(project, @trees, packaging: settle(packaging))
+  end
 
-    attr_reader :project, :graph
+  attr_reader :project
 
-    def complexity
-      @complexity ||= Complexity::Analyzer.new(@project, @trees) if enabled?(:complexity)
-    end
+  def graph = @coupling.graph
 
-    def duplication
-      @duplication ||= Duplication::Analyzer.new(@project, @trees, churn) if enabled?(:duplication)
-    end
+  def complexity
+    @complexity ||= Hashira::Complexity::Scores.new(@project, @trees) if enabled?(:complexity)
+  end
 
-    def hotspots
-      @hotspots ||= Hotspots::Rollup.new(complexity, duplication, churn) if complexity || duplication
-    end
+  def duplication
+    @duplication ||= Hashira::Duplication::Clones.new(@project, @trees, churn) if enabled?(:duplication)
+  end
 
-    def churn = @churn ||= Churn.from_git
+  def smells
+    @smells ||= Hashira::Smells::Report.new(@project, @trees) if enabled?(:smells)
+  end
 
-    def enabled?(analyzer) = @enabled.include?(analyzer)
+  def hotspots
+    @hotspots ||= Hashira::Hotspots::Rollup.new(complexity, duplication, churn) if complexity || duplication
+  end
 
-    def findings = coupling_findings + listed(complexity) + listed(duplication)
+  def churn = @churn ||= Hashira::Churn.scan
 
-    private
+  def enabled?(analyzer) = @enabled.include?(analyzer)
+
+  def findings = structural + listed(complexity) + listed(duplication) + listed(smells)
+
+  private
+
+  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) ? @coupling.findings : []
 
-    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,70 +1,71 @@
 # frozen_string_literal: true
 
-module Hashira
-  class Project
-    ROOT_PACKAGE = "(root)"
+class Hashira::Project
+  ROOT_PACKAGE = "(root)"
 
-    def self.detect(directories)
-      targets = directories.empty? ? default_directories : directories
-      new(targets.map { descend(it.delete_suffix("/")) })
-    end
-
-    def self.default_directories
-      raise Error, "no lib/ directory here — pass the source directory explicitly" if Dir["lib/*/"].empty?
-
-      ["lib"]
-    end
-    private_class_method :default_directories
+  def self.detect(directories)
+    new((directories.empty? ? defaults : directories).map { descend(it.delete_suffix("/")) })
+  end
 
-    def self.descend(directory)
-      child = only_subdirectory(directory)
-      return directory unless child && Dir["#{child}/*/"].any? && (Dir["#{directory}/*.rb"] - ["#{child}.rb"]).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
 
-      descend(child)
-    end
+  def self.descend(directory)
+    child = sole(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 self.sole(directory)
+    subdirectories = Dir["#{directory}/*/"]
+    subdirectories.size == 1 ? subdirectories.first.delete_suffix("/") : nil
+  end
+  private_class_method :descend, :sole
 
-    def initialize(directories)
-      missing = directories.reject { Dir.exist?(it) }
-      raise Error, "no such directory: #{missing.join(", ")}" unless missing.empty?
+  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
 
-      @directories = directories.map { it.delete_suffix("/") }
-    end
+  attr_reader :directories
 
-    attr_reader :directories
+  def rails? = @rails
 
-    def files = @directories.flat_map { Dir["#{it}/**/*.rb"] }.sort
+  def files = @directories.flat_map { Dir["#{it}/**/*.rb"] }.sort
 
-    def package_for(path)
-      first, rest = relative(path).delete_suffix(".rb").split("/", 2)
-      return ROOT_PACKAGE unless rest || folder?(path, first)
+  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
 
-      contested.include?(first) ? "#{directory_of(path)}/#{first}" : first
-    end
+  def relative(path) = path.delete_prefix("#{parent(path)}/")
 
-    def relative(path) = path.delete_prefix("#{directory_of(path)}/")
+  def label = @directories.join(", ")
 
-    def label = @directories.join(", ")
+  def root = ROOT_PACKAGE
 
-    def root_package = ROOT_PACKAGE
+  private
 
-    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?("#{directory_of(path)}/#{name}")
+  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 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.ranked, 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}: #{Hashira::Report::Phrases.message(@finding)}")
+    @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

data/lib/hashira/report/json.rb

@@ -2,47 +2,47 @@
 
 require "json"
 
-module Hashira
-  module Report
-    class Json
-      def initialize(view, io: $stdout)
-        @view = view
-        @io = io
-      end
+class Hashira::Report::Json
+  def initialize(view, io: $stdout)
+    @view = view
+    @io = io
+  end
 
-      def print
-        @io.puts JSON.pretty_generate(payload)
-        0
-      end
+  def print
+    @io.puts(JSON.pretty_generate(payload))
+    0
+  end
 
-      private
+  private
 
-      def payload = base.merge(graph_payload).merge(sections.compact)
+  def payload = base.merge(coupling).merge(sections.compact)
 
-      def base = { findings: @view.findings.all.map(&:to_h), accepted: accepted_entries }
+  def base = { findings: @view.findings.all.map { rendered(it) }, accepted: accepted }
 
-      def graph_payload
-        graph = @view.graph
-        graph ? GraphPayload.new(graph).to_h : {}
-      end
+  def rendered(finding) = finding.to_h.merge(message: Hashira::Report::Phrases.message(finding))
 
-      def sections
-        { complexity: (complexity_payload if @view.complexity),
-          duplication: (duplication_payload if @view.duplication),
-          hotspots: @view.hotspots&.files&.map(&:to_h) }
-      end
+  def coupling
+    graph = @view.graph
+    graph ? Hashira::Report::GraphPayload.new(graph).to_h : {}
+  end
 
-      def accepted_entries
-        @view.findings.accepted.map { |finding, reason| finding.to_h.merge(reason:) }
-      end
+  def sections
+    {
+      complexity: (complexity if @view.complexity),
+      duplication: (duplication if @view.duplication),
+      hotspots: @view.hotspots&.files&.map(&:to_h)
+    }
+  end
 
-      def complexity_payload = { methods: method_scores, classes: class_scores }
+  def accepted
+    @view.findings.accepted.map { |finding, reason| rendered(finding).merge(reason:) }
+  end
 
-      def method_scores = @view.complexity.methods.map(&:to_h)
+  def complexity = { methods: the_methods, classes: the_classes }
 
-      def class_scores = @view.complexity.classes.map(&:to_h)
+  def the_methods = @view.complexity.ranked.map(&:to_h)
 
-      def duplication_payload = @view.duplication.clusters.map { Duplication::Delta.new(it).to_h }
-    end
-  end
+  def the_classes = @view.complexity.classes.map(&:to_h)
+
+  def duplication = @view.duplication.clusters.map { Hashira::Duplication::Delta.new(it).to_h }
 end