hashira 0.1.0 → 0.3.0

data/lib/hashira/analysis/definitions.rb

@@ -14,7 +14,7 @@ module Hashira
         @trees.each { |file, tree| definitions_in(file, tree, &) }
       end
 
-      def packages = @trees.keys.map { @project.package_for(_1) }.uniq
+      def packages = @trees.keys.map { @project.package_for(it) }.uniq
 
       private
 

data/lib/hashira/analysis/finding.rb

@@ -2,8 +2,12 @@
 
 module Hashira
   module Analysis
-    Finding = Data.define(:kind, :package, :message, :evidence, :cycle) do
-      def initialize(cycle: nil, **rest) = super
+    Finding = Data.define(:kind, :package, :message, :evidence, :cycle, :digest) do
+      def initialize(cycle: nil, digest: nil, **rest) = super
+
+      def signature = "#{kind}:#{identity}"
+
+      def identity = digest || package
 
       def to_h = super.compact
     end

data/lib/hashira/analysis/graph.rb

@@ -13,10 +13,10 @@ module Hashira
 
       def dependencies_of(package) = dependencies[package].to_a.sort
 
-      def dependents_of(package) = packages.select { dependencies[_1].include?(package) }.sort
+      def dependents_of(package) = packages.select { dependencies[it].include?(package) }.sort
 
       def edge_list
-        dependencies.sort.flat_map { |from, tos| tos.sort.map { Edge.new(from:, to: _1) } }
+        dependencies.sort.flat_map { |from, tos| tos.sort.map { Edge.new(from:, to: it) } }
       end
 
       def weighted_edges
@@ -34,7 +34,7 @@ module Hashira
                    efferent: dependencies[package].size)
       end
 
-      def metrics = packages.to_h { [_1, metric_for(_1)] }
+      def metrics = packages.to_h { [it, metric_for(it)] }
 
       def sdp_violations = SdpCheck.new(dependencies, metrics).violations
 

data/lib/hashira/analysis/namespace_prefix.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Hashira
+  module Analysis
+    module NamespacePrefix
+      module_function
+
+      def infer(definitions)
+        build(deepest_definition_per_package(definitions))
+      end
+
+      def build(fulls, prefix = [])
+        depth = prefix.length
+        wrapper = shared_wrapper(fulls, depth)
+        return prefix unless wrapper
+
+        build(fulls.select { it[depth] == wrapper }, prefix + [wrapper])
+      end
+
+      def deepest_definition_per_package(definitions)
+        definitions.map { |_node, full, package| [package, full] }
+                   .sort_by { |_package, full| full.length }
+                   .to_h.values
+      end
+
+      def shared_wrapper(fulls, depth)
+        wrapper, count = fulls.filter_map { it[depth] if it[depth + 1] }.tally.max_by { |_wrapper, tally| tally }
+        wrapper if wrapper && count > fulls.size / 2
+      end
+    end
+  end
+end

data/lib/hashira/analysis/node_walk.rb

@@ -7,7 +7,13 @@ module Hashira
 
       def each_node(node, &)
         yield(node)
-        node.compact_child_nodes.each { each_node(_1, &) }
+        node.compact_child_nodes.each { each_node(it, &) }
+      end
+
+      def collect(node)
+        found = []
+        each_node(node) { found << it }
+        found
       end
     end
   end

data/lib/hashira/analysis/references.rb

@@ -12,14 +12,14 @@ module Hashira
       end
 
       def each_sighting(tree)
-        [].tap { collect(tree, _1) }
+        [].tap { collect(tree, it) }
       end
 
       def collect(node, accumulator)
         return unless node
         return accumulator << [Syntax.path_segments(node), node.location.start_line] if constant?(node)
 
-        branches(node).each { collect(_1, accumulator) }
+        branches(node).each { collect(it, accumulator) }
       end
 
       def constant?(node) = node.is_a?(Prism::ConstantPathNode) || node.is_a?(Prism::ConstantReadNode)

data/lib/hashira/analysis/sdp_check.rb

@@ -10,7 +10,7 @@ module Hashira
 
       def violations
         @dependencies.flat_map do |from, tos|
-          tos.select { @metrics[_1].instability > @metrics[from].instability }.map { [from, _1] }
+          tos.select { @metrics[it].instability > @metrics[from].instability }.map { [from, it] }
         end
       end
     end

data/lib/hashira/analysis/type_walk.rb

@@ -19,7 +19,7 @@ module Hashira
 
       def each_child_definition(node, prefix, &)
         children = node ? node.compact_child_nodes : []
-        children.each { each_definition(_1, prefix, &) }
+        children.each { each_definition(it, prefix, &) }
       end
     end
   end

data/lib/hashira/churn.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Hashira
+  class Churn
+    LOG = "git log --name-only --format= 2>/dev/null"
+    SITES_THAT_DRIFT_APART = 2
+
+    def self.from_git = new(tally(`#{LOG}`))
+
+    def self.tally(output) = output.split("\n").map(&:strip).reject(&:empty?).tally
+
+    def initialize(counts)
+      @counts = counts
+    end
+
+    def hits(file) = @counts.select { |path, _| path.end_with?(file) }.values.max || 0
+
+    def hot?(members) = changing(members) >= SITES_THAT_DRIFT_APART
+
+    def changing(members) = members.count { |member| hits(member.file).positive? }
+  end
+end

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