hashira 0.1.0 → 0.2.0

data/lib/hashira/ci/accepted.rb

@@ -7,14 +7,18 @@ module Hashira
     class Accepted
       Screened = Data.define(:all, :accepted)
 
-      Entry = Data.define(:kind, :package, :reason) do
-        def self.from(hash) = new(kind: hash["kind"], package: hash["package"], reason: hash["reason"])
+      Entry = Data.define(:kind, :package, :digest, :reason) do
+        def self.from(hash)
+          new(kind: hash["kind"], package: hash["package"], digest: hash["digest"], reason: hash["reason"])
+        end
 
-        def matches?(finding) = [kind, package] == [finding.kind, finding.package]
+        def matches?(finding) = kind == finding.kind && identity == finding.identity
+
+        def identity = digest || package
 
         def label = reason || "accepted (no reason recorded)"
 
-        def to_h = { kind:, package:, reason: }.compact
+        def to_h = { kind:, package:, digest:, reason: }.compact
       end
 
       def self.load(path)
@@ -24,20 +28,20 @@ module Hashira
       end
 
       def initialize(entries)
-        @entries = entries.map { Entry.from(_1) }
+        @entries = entries.map { Entry.from(it) }
       end
 
       def entries = @entries.map(&:to_h)
 
       def screen(findings)
-        accepted, live = findings.map { [_1, reason_for(_1)] }.partition(&:last)
+        accepted, live = findings.map { [it, reason_for(it)] }.partition(&:last)
         Screened.new(all: live.map(&:first), accepted:)
       end
 
       private
 
       def reason_for(finding)
-        @entries.find { _1.matches?(finding) }&.label
+        @entries.find { it.matches?(finding) }&.label
       end
     end
   end

data/lib/hashira/ci/baseline.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Hashira
+  module CI
+    class Baseline
+      SCHEMA_VERSION = 2
+
+      def self.load(path) = new(path, File.exist?(path) ? JSON.parse(File.read(path)) : {})
+
+      def initialize(path, recorded)
+        @path = path
+        @recorded = recorded
+      end
+
+      attr_reader :path
+
+      def exist? = File.exist?(@path)
+
+      def edges = @recorded.fetch("edges", [])
+
+      def findings = @recorded.fetch("findings", [])
+
+      def ratchets_findings? = @recorded.key?("findings")
+
+      def write(edges, findings)
+        File.write(@path, JSON.pretty_generate(payload(edges, findings)) << "\n")
+      end
+
+      private
+
+      def payload(edges, findings)
+        base = { version: SCHEMA_VERSION, edges:, findings: }
+        accepted = Accepted.new(@recorded.fetch("accepted", [])).entries
+        accepted.empty? ? base : base.merge(accepted:)
+      end
+    end
+  end
+end

data/lib/hashira/ci/diff.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Hashira
+  module CI
+    Diff = Data.define(:added, :removed) do
+      def self.between(current, recorded)
+        new(added: current - recorded, removed: recorded - current)
+      end
+
+      def empty? = added.empty? && removed.empty?
+
+      def worse? = !added.empty?
+    end
+  end
+end

data/lib/hashira/ci/edge_diff_report.rb

@@ -8,39 +8,16 @@ module Hashira
         @io = io
       end
 
-      def print(added, removed)
-        return print_unchanged if added.empty? && removed.empty?
-
-        print_added(added)
-        print_removed(removed)
-        1
+      def print(diff)
+        diff.added.each { print_edge(it) }
+        Improvement.new("Edges removed", io: @io).print(diff.removed)
       end
 
       private
 
-      def print_unchanged
-        @io.puts "Ratchet OK: #{@graph.edge_list.size} edges, unchanged."
-        0
-      end
-
-      def print_added(added)
-        return if added.empty?
-
-        added.each { print_edge(_1) }
-        @io.puts "\nRatchet FAILED. Either decouple, or if the new edge is a deliberate"
-        @io.puts "design decision, update the baseline and say why in the commit."
-      end
-
       def print_edge(edge)
         @io.puts "NEW EDGE #{edge} — introduced by:"
-        @graph.evidence_for(edge.from, edge.to).to_a.sort.each { @io.puts "  · #{_1}" }
-      end
-
-      def print_removed(removed)
-        return if removed.empty?
-
-        @io.puts "Edges removed (improvement!): #{removed.join(", ")}"
-        @io.puts "Lock it in: hashira --update-baseline"
+        @graph.evidence_for(edge.from, edge.to).to_a.sort.each { @io.puts "  · #{it}" }
       end
     end
   end

data/lib/hashira/ci/finding_diff_report.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Hashira
+  module CI
+    class FindingDiffReport
+      def initialize(findings, io: $stdout)
+        @findings = findings
+        @io = io
+      end
+
+      def print(diff)
+        introduced(diff.added).each { print_finding(it) }
+        Improvement.new("Findings resolved", io: @io).print(diff.removed)
+      end
+
+      private
+
+      def introduced(added) = added.filter_map { |signature| @findings.find { it.signature == signature } }
+
+      def print_finding(finding)
+        @io.puts "NEW FINDING:"
+        Report::FindingLines.new(finding, indent: "  ", io: @io).print_with_overflow
+      end
+    end
+  end
+end

data/lib/hashira/ci/gate.rb

@@ -10,16 +10,18 @@ module Hashira
       end
 
       def check
-        offending = @findings.all.select { @kinds.include?(_1.kind) }
-        return report_clean if offending.empty?
+        offending = @findings.all.select { @kinds.include?(it.kind) }
+        offending.empty? ? report_clean : report_failure(offending)
+      end
+
+      private
 
-        offending.each { Report::FindingLines.new(_1, io: @io).print }
+      def report_failure(offending)
+        offending.each { Report::FindingLines.new(it, io: @io).print }
         @io.puts "\nGate FAILED: #{offending.size} finding(s) of kind #{@kinds.join(", ")}."
         1
       end
 
-      private
-
       def report_clean
         @io.puts "Gate OK: no findings of kind #{@kinds.join(", ")}."
         0

data/lib/hashira/ci/improvement.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Hashira
+  module CI
+    class Improvement
+      def initialize(label, io: $stdout)
+        @label = label
+        @io = io
+      end
+
+      def print(removed)
+        return if removed.empty?
+
+        @io.puts "#{@label} (improvement!): #{removed.join(", ")}"
+        @io.puts "Lock it in: hashira --update-baseline"
+      end
+    end
+  end
+end

data/lib/hashira/ci/ratchet.rb

@@ -1,43 +1,39 @@
 # frozen_string_literal: true
 
-require "json"
-
 module Hashira
   module CI
     class Ratchet
-      def initialize(graph, baseline_path, io: $stdout)
+      def initialize(graph, findings, baseline_path, io: $stdout)
         @graph = graph
-        @baseline_path = baseline_path
+        @findings = findings
+        @baseline = Baseline.load(baseline_path)
         @io = io
       end
 
-      SCHEMA_VERSION = 1
-
       def update
-        edges = @graph.edge_list.map(&:to_s)
-        File.write(@baseline_path, JSON.pretty_generate(payload(edges)) << "\n")
-        @io.puts "Baseline updated: #{edges.size} edges."
+        @baseline.write(edge_signatures, finding_signatures)
+        @io.puts "Baseline updated: #{edge_signatures.size} edges, #{finding_signatures.size} findings."
         0
       end
 
       def check
-        added, removed = diff(@graph.edge_list)
-        EdgeDiffReport.new(@graph, io: @io).print(added, removed)
+        raise Error, "no baseline at #{@baseline.path} — run --update-baseline first" unless @baseline.exist?
+
+        RatchetReport.new(@graph, @findings, io: @io).print(edge_diff, finding_diff)
       end
 
       private
 
-      def payload(edges)
-        accepted = Accepted.load(File.exist?(@baseline_path) ? @baseline_path : nil).entries
-        base = { version: SCHEMA_VERSION, edges: }
-        accepted.empty? ? base : base.merge(accepted:)
-      end
+      def edge_signatures = @graph.edge_list.map(&:to_s)
+
+      def finding_signatures = @findings.map(&:signature).uniq.sort
+
+      def edge_diff = Diff.new(added: new_edges, removed: @baseline.edges - edge_signatures)
 
-      def diff(edges)
-        raise Error, "no baseline at #{@baseline_path} — run --update-baseline first" unless File.exist?(@baseline_path)
+      def new_edges = @graph.edge_list.reject { @baseline.edges.include?(it.to_s) }
 
-        baseline = JSON.parse(File.read(@baseline_path)).fetch("edges")
-        [edges.reject { baseline.include?(_1.to_s) }, baseline - edges.map(&:to_s)]
+      def finding_diff
+        Diff.between(finding_signatures, @baseline.findings) if @baseline.ratchets_findings?
       end
     end
   end

data/lib/hashira/ci/ratchet_report.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Hashira
+  module CI
+    class RatchetReport
+      def initialize(graph, findings, io: $stdout)
+        @graph = graph
+        @findings = findings
+        @io = io
+      end
+
+      def print(edges, findings)
+        return unchanged if quiet?(edges, findings)
+
+        details(edges, findings)
+        advice(edges, findings)
+        1
+      end
+
+      private
+
+      def quiet?(*diffs) = diffs.compact.all?(&:empty?)
+
+      def unchanged
+        @io.puts "Ratchet OK: #{@graph.edge_list.size} edges, #{@findings.size} findings, unchanged."
+        0
+      end
+
+      def details(edges, findings)
+        EdgeDiffReport.new(@graph, io: @io).print(edges)
+        FindingDiffReport.new(@findings, io: @io).print(findings) if findings
+      end
+
+      def advice(*diffs)
+        return unless diffs.compact.any?(&:worse?)
+
+        @io.puts "\nRatchet FAILED. Either fix what regressed, or — if it is deliberate —"
+        @io.puts "record the decision: update the baseline, or accept it with a reason."
+      end
+    end
+  end
+end

data/lib/hashira/cli/command_line.rb

@@ -23,7 +23,7 @@ module Hashira
         usage(:version) if delete("--version")
       end
 
-      def usage(mode) = Options.new(directories: [], mode:, baseline: nil, fail_on: [])
+      def usage(mode) = Options.new(directories: [], mode:, baseline: nil, fail_on: [], skip: [])
 
       def parsed_options
         values = flag_values
@@ -33,15 +33,21 @@ module Hashira
       end
 
       def flag_values
-        { fail_on: FailOn.parse(take_value("--fail-on")),
+        { skip: Skip.parse(take_value("--skip")),
+          fail_on: FailOn.parse(take_value("--fail-on")),
           baseline: take_value("--baseline") || DEFAULT_BASELINE }
       end
 
       def parse_mode(fail_on)
-        requested = requested_modes(fail_on).uniq(&:last)
-        raise Error, "conflicting options: #{requested.map(&:first).join(" and ")}" if requested.size > 1
+        case (requested = requested_modes(fail_on).uniq(&:last))
+        in [] then :text
+        in [[_flag, mode]] then mode
+        else conflict(requested)
+        end
+      end
 
-        requested.dig(0, 1) || :text
+      def conflict(requested)
+        raise Error, "conflicting options: #{requested.map(&:first).join(" and ")}"
       end
 
       def requested_modes(fail_on)
@@ -78,7 +84,7 @@ module Hashira
       def delete(flag) = @arguments.delete(flag)
 
       def reject_unknown_flags
-        stray = @arguments.find { _1.start_with?("-") }
+        stray = @arguments.find { it.start_with?("-") }
         raise Error, "unknown option #{stray}" if stray
       end
     end

data/lib/hashira/cli/fail_on.rb

@@ -5,7 +5,9 @@ module Hashira
     module FailOn
       KINDS = {
         "cycles" => "cycle", "cycle" => "cycle",
-        "sdp" => "sdp_violation", "sdp_violation" => "sdp_violation"
+        "sdp" => "sdp_violation", "sdp_violation" => "sdp_violation",
+        "complexity" => "complexity",
+        "duplication" => "duplication", "dupe" => "duplication"
       }.freeze
 
       module_function
@@ -13,7 +15,7 @@ module Hashira
       def parse(list)
         return [] unless list
 
-        list.split(",").map { kind(_1.strip) }.uniq
+        list.split(",").map { kind(it.strip) }.uniq
       end
 
       def kind(name)

data/lib/hashira/cli/options.rb

@@ -2,7 +2,7 @@
 
 module Hashira
   class CLI
-    Options = Data.define(:directories, :mode, :baseline, :fail_on) do
+    Options = Data.define(:directories, :mode, :baseline, :fail_on, :skip) do
       def self.parse(argv) = CommandLine.new(argv).options
     end
   end

data/lib/hashira/cli/run.rb

@@ -18,7 +18,7 @@ module Hashira
 
       def graph = @pipeline.graph
 
-      def ratchet = CI::Ratchet.new(graph, @options.baseline)
+      def ratchet = CI::Ratchet.new(graph, findings.all, @options.baseline)
 
       def update_baseline = ratchet.update
 
@@ -28,11 +28,17 @@ module Hashira
 
       def check_gate = CI::Gate.new(findings, @options.fail_on).check
 
-      def print_json = Report::Json.new(graph, findings).print
+      def print_json = Report::Json.new(view).print
 
       def print_diagram = Diagram::Renderer.new(graph, @options.mode).display
 
-      def print_text = Report::Text.new(@pipeline.project, graph, findings).print
+      def print_text = Report::Text.new(view).print
+
+      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
   end
 end

data/lib/hashira/cli/skip.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Hashira
+  class CLI
+    module 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 key(name)
+        symbol = name.to_sym
+        Pipeline::ANALYZERS.include?(symbol) ? symbol : unknown(name)
+      end
+
+      def unknown(name)
+        raise Error, "unknown --skip #{name.inspect} (use: #{Pipeline::ANALYZERS.join(", ")})"
+      end
+    end
+  end
+end

data/lib/hashira/cli/usage.rb

@@ -6,16 +6,19 @@ module Hashira
       TEXT = <<~HELP
         Usage: hashira [DIRECTORY ...] [options]
 
-        Package coupling metrics for Ruby, via Prism. With no directory,
-        auto-detects lib/<gem>.
+        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
-          --ratchet            fail when edges appear that the baseline lacks
-          --update-baseline    write the current edge set as the baseline
+                               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
@@ -23,6 +26,8 @@ module Hashira
         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

data/lib/hashira/cli.rb

@@ -18,7 +18,7 @@ module Hashira
 
     def initialize(options)
       @options = options
-      @pipeline = Pipeline.new(Project.detect(options.directories))
+      @pipeline = Pipeline.new(Project.detect(options.directories), enabled: Pipeline::ANALYZERS - options.skip)
     end
 
     def run = Run.new(@pipeline, @options).exit_code

data/lib/hashira/complexity/analyzer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Complexity
+    class Analyzer
+      THRESHOLD = 10
+
+      def initialize(project, trees)
+        @project = project
+        @scores = trees.flat_map { |path, tree| scores_for(path, tree) }
+      end
+
+      def methods = @scores.sort_by { -it.cognitive }
+
+      def classes = Rollup.new(@scores).classes.sort_by { -it.cognitive }
+
+      def findings = flagged.map { MethodFinding.new(it).to_finding }
+
+      private
+
+      def flagged = methods.select { it.cognitive >= THRESHOLD }
+
+      def scores_for(path, tree)
+        rel = @project.relative(path)
+        methods_in(tree).map { |full, node| build_score(rel, full, node) }
+      end
+
+      def methods_in(tree)
+        found = []
+        Analysis::TypeWalk.each_definition(tree) do |type_node, full|
+          Analysis::Syntax.direct_definitions(type_node).each { found << [full, it] }
+        end
+        found
+      end
+
+      def build_score(rel, full, node)
+        score = CognitiveScore.new(node)
+        MethodScore.new(subject: subject(full, node), file: rel, line: node.location.start_line,
+                        cognitive: score.total, calls: score.calls, increments: score.increments)
+      end
+
+      def subject(full, node) = "#{full.join("::")}#{node.receiver ? "." : "#"}#{node.name}"
+    end
+  end
+end

data/lib/hashira/complexity/boolean_run.rb

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

data/lib/hashira/complexity/cognitive_score.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+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
+  end
+end