hashira 0.3.0 → 0.5.0

data/lib/hashira/cli/run.rb

@@ -1,44 +1,50 @@
 # frozen_string_literal: true
 
-module Hashira
-  class CLI
-    class Run
-      MODES = { update_baseline: :update_baseline, ratchet: :check_ratchet,
-                fail_on: :check_gate, json: :print_json,
-                dot: :print_diagram, mermaid: :print_diagram }.freeze
+class Hashira::CLI::Run
+  MODES = { update: :update, ratchet: :check, fail_on: :guard, json: :json, dot: :diagram, mermaid: :diagram }.freeze
 
-      def initialize(pipeline, options)
-        @pipeline = pipeline
-        @options = options
-      end
+  def initialize(pipeline, options)
+    @pipeline = pipeline
+    @options = options
+  end
+
+  def status = __send__(MODES.fetch(@options.mode, :text))
+
+  private
 
-      def exit_code = send(MODES.fetch(@options.mode, :print_text))
+  def graph = @pipeline.graph
 
-      private
+  def findings = @findings ||= Hashira::CI::Accepted.load(@options.baseline).screen(@pipeline.findings)
 
-      def graph = @pipeline.graph
+  def update = ratchet.update
+
+  def check
+    stop = ratchet.blocker
+    raise(Hashira::Error, stop) if stop
+    ratchet.check
+  end
 
-      def ratchet = CI::Ratchet.new(graph, findings.all, @options.baseline)
+  def guard = gate.check
 
-      def update_baseline = ratchet.update
+  def diagram = source.print
 
-      def check_ratchet = ratchet.check
+  def json = report(Hashira::Report::Json)
 
-      def findings = @findings ||= CI::Accepted.load(@options.baseline).screen(@pipeline.findings)
+  def text = report(Hashira::Report::Text)
 
-      def check_gate = CI::Gate.new(findings, @options.fail_on).check
+  def report(kind) = kind.new(view).print
 
-      def print_json = Report::Json.new(view).print
+  def ratchet = @ratchet ||= Hashira::CI::Ratchet.new(graph, findings.all, @options.baseline)
 
-      def print_diagram = Diagram::Renderer.new(graph, @options.mode).display
+  def gate = Hashira::CI::Gate.new(findings, @options.fail_on)
 
-      def print_text = Report::Text.new(view).print
+  def source = Hashira::Diagram::Source.new(graph, @options.mode)
 
-      def view
-        Report::View.new(project: @pipeline.project, graph: (graph if @pipeline.enabled?(:coupling)),
-                         complexity: @pipeline.complexity, duplication: @pipeline.duplication,
-                         hotspots: @pipeline.hotspots, findings:)
-      end
-    end
+  def view
+    Hashira::Report::View.new(
+      project: @pipeline.project, graph: (graph if @pipeline.enabled?(:coupling)),
+      complexity: @pipeline.complexity, duplication: @pipeline.duplication,
+      hotspots: @pipeline.hotspots, findings:
+    )
   end
 end

data/lib/hashira/cli/skip.rb

@@ -1,27 +1,21 @@
 # frozen_string_literal: true
 
-module Hashira
-  class CLI
-    module Skip
-      module_function
+module Hashira::CLI::Skip
+  module_function
 
-      def parse(list)
-        return [] unless list
-
-        keys = list.split(",").map { key(it.strip) }
-        raise Error, "cannot skip every analyzer" if (Pipeline::ANALYZERS - keys).empty?
-
-        keys
-      end
+  def parse(list)
+    return [] unless list
+    keys = list.split(",").map { key(it.strip) }
+    raise(Hashira::Error, "cannot skip every analyzer") if (Hashira::Pipeline::ANALYZERS - keys).empty?
+    keys
+  end
 
-      def key(name)
-        symbol = name.to_sym
-        Pipeline::ANALYZERS.include?(symbol) ? symbol : unknown(name)
-      end
+  def key(name)
+    symbol = name.to_sym
+    Hashira::Pipeline::ANALYZERS.include?(symbol) ? symbol : unknown(name)
+  end
 
-      def unknown(name)
-        raise Error, "unknown --skip #{name.inspect} (use: #{Pipeline::ANALYZERS.join(", ")})"
-      end
-    end
+  def unknown(name)
+    raise(Hashira::Error, "unknown --skip #{name.inspect} (use: #{Hashira::Pipeline::ANALYZERS.join(", ")})")
   end
 end

data/lib/hashira/cli/usage.rb

@@ -1,45 +1,48 @@
 # frozen_string_literal: true
 
-module Hashira
-  class CLI
-    module Usage
-      TEXT = <<~HELP
-        Usage: hashira [DIRECTORY ...] [options]
-
-        Coupling, cognitive-complexity, and duplication metrics for Ruby, via
-        Prism, rolled up per file as a ranked list of hotspots. With no
-        directory, auto-detects lib/<gem>.
-
-        Options:
-          --format FORMAT      text (default), json, dot, or mermaid
-          --json               shorthand for --format json
-          --fail-on KINDS      exit 1 if findings exist; comma-separated
-                               kinds: cycles, sdp, complexity, duplication
-          --skip ANALYZERS     drop an analyzer; comma-separated: coupling, complexity, duplication
-          --ratchet            fail when edges or findings appear that the
-                               baseline lacks
-          --update-baseline    record the current edges and findings
-          --baseline PATH      baseline file (default: hashira_baseline.json)
-          -h, --help           print this help
-          --version            print the version
-
-        Findings accepted by design can be recorded in the baseline as
-          "accepted": [{"kind": "...", "package": "...", "reason": "..."}]
-        — they leave reports and gates, keeping a one-line reminder each.
-        Clones are named by "digest" instead of "package", so an acceptance
-        survives the lines above it moving. Read digests from --json.
-      HELP
-
-      module_function
-
-      def help = emit(TEXT)
-
-      def version = emit("hashira #{VERSION}")
-
-      def emit(output)
-        puts output
-        0
-      end
-    end
+module Hashira::CLI::Usage
+  TEXT = <<~HELP
+    Usage: hashira [DIRECTORY ...] [options]
+
+    Coupling, cognitive-complexity, duplication, and code-smell metrics
+    for Ruby, via Prism, rolled up per file as a ranked list of hotspots.
+    With no directory, auto-detects lib/<gem>.
+
+    Options:
+      --format FORMAT      text (default), json, dot, or mermaid
+      --json               shorthand for --format json
+      --fail-on KINDS      exit 1 if findings exist; comma-separated
+                           kinds: cycles, sdp, mixed_audience, wide_edge,
+                           roll_call, complexity, duplication, smells (all
+                           of them), or one smell kind such as feature_envy
+      --skip ANALYZERS     drop an analyzer; comma-separated: coupling,
+                           complexity, duplication, smells
+      --package-by WHAT    group coupling by: auto, folder, or namespace
+                           (top-level constant). Default auto: namespace for
+                           Rails apps (config/application.rb in or beside the
+                           analyzed directory), folder otherwise
+      --ratchet            fail when edges or findings appear that the
+                           baseline lacks
+      --update-baseline    record the current edges and findings
+      --baseline PATH      baseline file (default: hashira_baseline.json)
+      -h, --help           print this help
+      --version            print the version
+
+    Findings accepted by design can be recorded in the baseline as
+      "accepted": [{"kind": "...", "package": "...", "reason": "..."}]
+    — they leave reports and gates, keeping a one-line reminder each.
+    Clones are named by "digest" instead of "package", so an acceptance
+    survives the lines above it moving. Read digests from --json.
+  HELP
+
+  module_function
+
+  def help = emit(TEXT)
+
+  def version = emit("hashira #{Hashira::VERSION}")
+
+  def emit(output)
+    puts(output)
+    0
   end
 end

data/lib/hashira/cli.rb

@@ -1,26 +1,24 @@
 # frozen_string_literal: true
 
-module Hashira
-  class CLI
-    def self.run(argv)
-      options = Options.parse(argv)
-      usage?(options) ? Usage.public_send(options.mode) : new(options).run
-    rescue Error => error
-      report_failure(error)
-    end
-
-    def self.usage?(options) = %i[help version].include?(options.mode)
+class Hashira::CLI
+  def self.run(argv)
+    options = Options.parse(argv)
+    usage?(options) ? Usage.public_send(options.mode) : new(options).run
+  rescue Hashira::Error => error
+    failure(error)
+  end
 
-    def self.report_failure(error)
-      warn "hashira: #{error.message}"
-      1
-    end
+  def self.usage?(options) = %i[help version].include?(options.mode)
 
-    def initialize(options)
-      @options = options
-      @pipeline = Pipeline.new(Project.detect(options.directories), enabled: Pipeline::ANALYZERS - options.skip)
-    end
+  def self.failure(error)
+    warn("hashira: #{error.message}")
+    1
+  end
 
-    def run = Run.new(@pipeline, @options).exit_code
+  def initialize(options)
+    @options = options
+    @pipeline = options.pipeline
   end
+
+  def run = Run.new(@pipeline, @options).status
 end

data/lib/hashira/complexity/boolean_run.rb

@@ -1,22 +1,20 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Complexity
-    class BooleanRun
-      def initialize(scorer)
-        @scorer = scorer
-      end
+class Hashira::Complexity::BooleanRun
+  def initialize(scorer)
+    @scorer = scorer
+  end
 
-      def apply(node, nesting)
-        @scorer.add(node, 1, "boolean")
-        operands(node).each { @scorer.visit(it, nesting) }
-      end
+  def apply(node)
+    @scorer.add(node, 1, "boolean")
+    operands(node).each { @scorer.visit(it) }
+  end
 
-      private
+  private
 
-      def operands(node)
-        node.compact_child_nodes.flat_map { it.instance_of?(node.class) ? operands(it) : [it] }
-      end
-    end
+  def operands(node)
+    node.compact_child_nodes.flat_map { kin?(it, node) ? operands(it) : [it] }
   end
+
+  def kin?(child, node) = child.instance_of?(node.class)
 end

data/lib/hashira/complexity/cognitive_score.rb

@@ -2,71 +2,73 @@
 
 require "prism"
 
-module Hashira
-  module Complexity
-    class CognitiveScore
-      HANDLERS = {
-        Prism::IfNode => :on_if,
-        Prism::UnlessNode => :on_nester,
-        Prism::WhileNode => :on_nester,
-        Prism::UntilNode => :on_nester,
-        Prism::ForNode => :on_nester,
-        Prism::CaseNode => :on_nester,
-        Prism::CaseMatchNode => :on_nester,
-        Prism::BeginNode => :on_begin,
-        Prism::AndNode => :on_boolean,
-        Prism::OrNode => :on_boolean,
-        Prism::BlockNode => :on_block,
-        Prism::CallNode => :on_call
-      }.freeze
-
-      LABELS = {
-        Prism::UnlessNode => "unless", Prism::WhileNode => "while",
-        Prism::UntilNode => "until", Prism::ForNode => "for",
-        Prism::CaseNode => "case", Prism::CaseMatchNode => "case"
-      }.freeze
-
-      def initialize(def_node)
-        @increments = []
-        @calls = 0
-        visit(def_node.body, 0)
-      end
-
-      attr_reader :increments, :calls
-
-      def total = @increments.sum(&:cost)
-
-      def visit(node, nesting)
-        return unless node
-
-        send(HANDLERS.fetch(node.class, :descend), node, nesting)
-      end
-
-      def add(node, cost, label)
-        @increments << Increment.new(line: node.location.start_line, cost:, label:)
-      end
-
-      private
-
-      def descend(node, nesting) = node.compact_child_nodes.each { visit(it, nesting) }
-
-      def on_call(node, nesting)
-        @calls += 1
-        descend(node, nesting)
-      end
-
-      def on_block(node, nesting) = node.compact_child_nodes.each { visit(it, nesting + 1) }
-
-      def on_nester(node, nesting)
-        add(node, 1 + nesting, LABELS.fetch(node.class))
-        node.compact_child_nodes.each { visit(it, nesting + 1) }
-      end
-
-      def on_if(node, nesting) = IfChain.new(self).apply(node, nesting)
-
-      def on_begin(node, nesting) = RescueScan.new(self).apply(node, nesting)
-
-      def on_boolean(node, nesting) = BooleanRun.new(self).apply(node, nesting)
-    end
+class Hashira::Complexity::CognitiveScore
+  HANDLERS = {
+    Prism::IfNode => :on_if,
+    Prism::UnlessNode => :on_nester,
+    Prism::WhileNode => :on_nester,
+    Prism::UntilNode => :on_nester,
+    Prism::ForNode => :on_nester,
+    Prism::CaseNode => :on_nester,
+    Prism::CaseMatchNode => :on_nester,
+    Prism::BeginNode => :on_begin,
+    Prism::AndNode => :on_boolean,
+    Prism::OrNode => :on_boolean,
+    Prism::BlockNode => :on_block,
+    Prism::CallNode => :on_call
+  }.freeze
+
+  LABELS = {
+    Prism::UnlessNode => "unless", Prism::WhileNode => "while",
+    Prism::UntilNode => "until", Prism::ForNode => "for",
+    Prism::CaseNode => "case", Prism::CaseMatchNode => "case"
+  }.freeze
+
+  def initialize(def_node)
+    @increments = []
+    @calls = 0
+    @nesting = 0
+    visit(def_node.body)
   end
+
+  attr_reader :increments, :calls, :nesting
+
+  def total = @increments.sum(&:cost)
+
+  def visit(node)
+    return unless node
+    __send__(HANDLERS.fetch(node.class, :descend), node)
+  end
+
+  def add(node, cost, label)
+    @increments << Hashira::Complexity::Increment.new(line: node.location.start_line, cost:, label:)
+  end
+
+  def deeper
+    @nesting += 1
+    yield
+    @nesting -= 1
+  end
+
+  private
+
+  def descend(node) = node.compact_child_nodes.each { visit(it) }
+
+  def on_call(node)
+    @calls += 1
+    descend(node)
+  end
+
+  def on_block(node) = deeper { descend(node) }
+
+  def on_nester(node)
+    add(node, 1 + @nesting, LABELS.fetch(node.class))
+    deeper { descend(node) }
+  end
+
+  def on_if(node) = Hashira::Complexity::IfChain.new(self).apply(node)
+
+  def on_begin(node) = Hashira::Complexity::RescueScan.new(self).apply(node)
+
+  def on_boolean(node) = Hashira::Complexity::BooleanRun.new(self).apply(node)
 end

data/lib/hashira/complexity/if_chain.rb

@@ -2,44 +2,39 @@
 
 require "prism"
 
-module Hashira
-  module Complexity
-    class IfChain
-      def initialize(scorer)
-        @scorer = scorer
-      end
-
-      def apply(node, nesting)
-        return ternary(node, nesting) unless node.if_keyword
-
-        branch(node, 1 + nesting, nesting, "if")
-      end
-
-      private
-
-      def branch(node, cost, nesting, label)
-        @scorer.add(node, cost, label)
-        @scorer.visit(node.predicate, nesting)
-        @scorer.visit(node.statements, nesting + 1)
-        tail(node.subsequent, nesting)
-      end
-
-      def tail(node, nesting)
-        case node
-        when Prism::IfNode then branch(node, 1, nesting, "elsif")
-        when Prism::ElseNode then otherwise(node, nesting)
-        end
-      end
-
-      def otherwise(node, nesting)
-        @scorer.add(node, 1, "else")
-        @scorer.visit(node.statements, nesting + 1)
-      end
-
-      def ternary(node, nesting)
-        @scorer.add(node, 1, "ternary")
-        node.compact_child_nodes.each { @scorer.visit(it, nesting) }
-      end
+class Hashira::Complexity::IfChain
+  def initialize(scorer)
+    @scorer = scorer
+  end
+
+  def apply(node)
+    return ternary(node) unless node.if_keyword
+    branch(node, 1 + @scorer.nesting, "if")
+  end
+
+  private
+
+  def branch(node, cost, label)
+    @scorer.add(node, cost, label)
+    @scorer.visit(node.predicate)
+    @scorer.deeper { @scorer.visit(node.statements) }
+    tail(node.subsequent)
+  end
+
+  def tail(node)
+    case node
+    when Prism::IfNode then branch(node, 1, "elsif")
+    when Prism::ElseNode then otherwise(node)
     end
   end
+
+  def otherwise(node)
+    @scorer.add(node, 1, "else")
+    @scorer.deeper { @scorer.visit(node.statements) }
+  end
+
+  def ternary(node)
+    @scorer.add(node, 1, "ternary")
+    node.compact_child_nodes.each { @scorer.visit(it) }
+  end
 end

data/lib/hashira/complexity/method_finding.rb

@@ -1,52 +1,30 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Complexity
-    class MethodFinding
-      ADVICE = {
-        "if" => "flatten the branching — guard clauses, early returns, or polymorphism.",
-        "elsif" => "replace the elsif ladder with a lookup or polymorphic dispatch.",
-        "else" => "flatten the branching — guard clauses, early returns, or polymorphism.",
-        "case" => "a case this size often wants polymorphism or a dispatch table.",
-        "boolean" => "name the compound condition in a predicate method.",
-        "rescue" => "narrow the rescue, or lift error handling to the caller.",
-        "while" => "extract the loop body into its own method.",
-        "until" => "extract the loop body into its own method.",
-        "for" => "extract the loop body into its own method.",
-        "unless" => "invert to a guard clause or a named predicate.",
-        "ternary" => "extract the nested ternary into a named method."
-      }.freeze
-
-      def initialize(score)
-        @score = score
-      end
-
-      def to_finding
-        Analysis::Finding.new(kind: "complexity", package: @score.subject, cycle: nil,
-                              message:, evidence:)
-      end
+class Hashira::Complexity::MethodFinding
+  def initialize(score)
+    @score = score
+  end
 
-      private
+  def to_finding
+    Hashira::Analysis::Finding.new(kind: "complexity", package: @score.subject, detail:, evidence:)
+  end
 
-      def message
-        "#{@score.subject} — cognitive #{@score.cognitive}, #{@score.calls} calls " \
-          "(#{@score.file}:#{@score.line}). #{advice}"
-      end
+  private
 
-      def evidence
-        @score.increments.group_by(&:label).map { |label, incs| line_summary(label, incs) }
-      end
+  def detail
+    { cognitive: @score.cognitive, calls: @score.calls, site: "#{@score.file}:#{@score.line}", dominant: }
+  end
 
-      def line_summary(label, incs)
-        lines = incs.map(&:line).uniq
-        "#{label} +#{incs.sum(&:cost)} (line#{"s" if lines.size > 1} #{lines.join(", ")})"
-      end
+  def evidence
+    @score.increments.group_by(&:label).map { |label, incs| lines(label, incs) }
+  end
 
-      def advice = ADVICE.fetch(dominant)
+  def lines(label, incs)
+    lines = incs.map(&:line).uniq
+    "#{label} +#{incs.sum(&:cost)} (line#{"s" if lines.size > 1} #{lines.join(", ")})"
+  end
 
-      def dominant
-        @score.increments.group_by(&:label).transform_values { it.sum(&:cost) }.max_by(&:last).first
-      end
-    end
+  def dominant
+    @score.increments.group_by(&:label).transform_values { it.sum(&:cost) }.max_by(&:last).first
   end
 end

data/lib/hashira/complexity/method_score.rb

@@ -4,14 +4,16 @@ module Hashira
   module Complexity
     Increment = Data.define(:line, :cost, :label)
 
-    MethodScore = Data.define(:subject, :file, :line, :cognitive, :calls, :increments) do
-      def to_h = { subject:, file:, line:, cognitive:, calls: }
+    MethodScore =
+      Data.define(:subject, :file, :line, :cognitive, :calls, :increments) do
+        def to_h = { subject:, file:, line:, cognitive:, calls: }
 
-      def cells = [subject, cognitive, calls, "#{file}:#{line}"]
-    end
+        def cells = [subject, cognitive, calls, "#{file}:#{line}"]
+      end
 
-    ClassScore = Data.define(:name, :cognitive, :method_count, :peak) do
-      def cells = [name, cognitive, method_count, peak]
-    end
+    ClassScore =
+      Data.define(:name, :cognitive, :method_count, :peak) do
+        def cells = [name, cognitive, method_count, peak]
+      end
   end
 end

data/lib/hashira/complexity/rescue_scan.rb

@@ -1,28 +1,23 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Complexity
-    class RescueScan
-      def initialize(scorer)
-        @scorer = scorer
-      end
-
-      def apply(node, nesting)
-        @scorer.visit(node.statements, nesting)
-        clauses(node.rescue_clause, nesting)
-        @scorer.visit(node.else_clause, nesting)
-        @scorer.visit(node.ensure_clause, nesting)
-      end
+class Hashira::Complexity::RescueScan
+  def initialize(scorer)
+    @scorer = scorer
+  end
 
-      private
+  def apply(node)
+    @scorer.visit(node.statements)
+    clauses(node.rescue_clause)
+    @scorer.visit(node.else_clause)
+    @scorer.visit(node.ensure_clause)
+  end
 
-      def clauses(node, nesting)
-        return unless node
+  private
 
-        @scorer.add(node, 1 + nesting, "rescue")
-        @scorer.visit(node.statements, nesting + 1)
-        clauses(node.subsequent, nesting)
-      end
-    end
+  def clauses(node)
+    return unless node
+    @scorer.add(node, 1 + @scorer.nesting, "rescue")
+    @scorer.deeper { @scorer.visit(node.statements) }
+    clauses(node.subsequent)
   end
 end