hashira 0.2.0 → 0.4.0

data/lib/hashira/analysis/type_walk.rb

@@ -7,19 +7,17 @@ module Hashira
     module TypeWalk
       module_function
 
-      def each_definition(node, prefix = [], &)
-        return each_child_definition(node, prefix, &) unless type_node?(node)
-
-        full = prefix + Syntax.path_segments(node.constant_path)
+      def each(node, stack = [], roots: nil, &)
+        return descend(node, stack, roots, &) unless type?(node)
+        full = Syntax.anchor(stack, Syntax.segments(node.constant_path), roots)
         yield(node, full)
-        each_child_definition(node.body, full, &)
+        descend(node.body, stack + [full], roots, &)
       end
 
-      def type_node?(node) = node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)
+      def type?(node) = node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)
 
-      def each_child_definition(node, prefix, &)
-        children = node ? node.compact_child_nodes : []
-        children.each { each_definition(it, prefix, &) }
+      def descend(node, stack, roots, &)
+        (node ? node.compact_child_nodes : []).each { each(it, stack, roots:, &) }
       end
     end
   end

data/lib/hashira/churn.rb

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

data/lib/hashira/ci/accepted.rb

@@ -2,47 +2,43 @@
 
 require "json"
 
-module Hashira
-  module CI
-    class Accepted
-      Screened = Data.define(:all, :accepted)
+class Hashira::CI::Accepted
+  Screened = Data.define(:all, :accepted)
 
-      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 == finding.kind && identity == finding.identity
+  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 identity = digest || package
+      def matches?(finding) = kind == finding.kind && identity == finding.identity
 
-        def label = reason || "accepted (no reason recorded)"
+      def identity = digest || package
 
-        def to_h = { kind:, package:, digest:, reason: }.compact
-      end
+      def label = reason || "accepted (no reason recorded)"
 
-      def self.load(path)
-        return new([]) unless path && File.exist?(path)
+      def to_h = { kind:, package:, digest:, reason: }.compact
+    end
 
-        new(JSON.parse(File.read(path)).fetch("accepted", []))
-      end
+  def self.load(path)
+    return new([]) unless path && File.exist?(path)
+    new(JSON.parse(File.read(path)).fetch("accepted", []))
+  end
 
-      def initialize(entries)
-        @entries = entries.map { Entry.from(it) }
-      end
+  def initialize(entries)
+    @entries = entries.map { Entry.from(it) }
+  end
 
-      def entries = @entries.map(&:to_h)
+  def entries = @entries.map(&:to_h)
 
-      def screen(findings)
-        accepted, live = findings.map { [it, reason_for(it)] }.partition(&:last)
-        Screened.new(all: live.map(&:first), accepted:)
-      end
+  def screen(findings)
+    accepted, live = findings.map { [it, reason(it)] }.partition(&:last)
+    Screened.new(all: live.map(&:first), accepted:)
+  end
 
-      private
+  private
 
-      def reason_for(finding)
-        @entries.find { it.matches?(finding) }&.label
-      end
-    end
+  def reason(finding)
+    @entries.find { it.matches?(finding) }&.label
   end
 end

data/lib/hashira/ci/baseline.rb

@@ -2,39 +2,37 @@
 
 require "json"
 
-module Hashira
-  module CI
-    class Baseline
-      SCHEMA_VERSION = 2
+class Hashira::CI::Baseline
+  SCHEMA_VERSION = 3
 
-      def self.load(path) = new(path, File.exist?(path) ? JSON.parse(File.read(path)) : {})
+  def self.load(path) = new(path, File.exist?(path) ? JSON.parse(File.read(path)) : {})
 
-      def initialize(path, recorded)
-        @path = path
-        @recorded = recorded
-      end
+  def initialize(path, recorded)
+    @path = path
+    @recorded = recorded
+  end
+
+  attr_reader :path
 
-      attr_reader :path
+  def exist? = File.exist?(@path)
 
-      def exist? = File.exist?(@path)
+  def edges = @recorded.fetch("edges", [])
 
-      def edges = @recorded.fetch("edges", [])
+  def findings = @recorded.fetch("findings", [])
 
-      def findings = @recorded.fetch("findings", [])
+  def findings? = @recorded.key?("findings")
 
-      def ratchets_findings? = @recorded.key?("findings")
+  def packaging = @recorded.fetch("packaging", "folder")
 
-      def write(edges, findings)
-        File.write(@path, JSON.pretty_generate(payload(edges, findings)) << "\n")
-      end
+  def write(edges, findings, packaging:)
+    File.write(@path, JSON.pretty_generate(payload(edges, findings, packaging)) << "\n")
+  end
 
-      private
+  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
+  def payload(edges, findings, packaging)
+    base = { version: SCHEMA_VERSION, packaging:, edges:, findings: }
+    accepted = Hashira::CI::Accepted.new(@recorded.fetch("accepted", [])).entries
+    accepted.empty? ? base : base.merge(accepted:)
   end
 end

data/lib/hashira/ci/diff.rb

@@ -2,14 +2,15 @@
 
 module Hashira
   module CI
-    Diff = Data.define(:added, :removed) do
-      def self.between(current, recorded)
-        new(added: current - recorded, removed: recorded - current)
-      end
+    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 empty? = added.empty? && removed.empty?
 
-      def worse? = !added.empty?
-    end
+        def worse? = !added.empty?
+      end
   end
 end

data/lib/hashira/ci/edge_diff_report.rb

@@ -1,24 +1,20 @@
 # frozen_string_literal: true
 
-module Hashira
-  module CI
-    class EdgeDiffReport
-      def initialize(graph, io: $stdout)
-        @graph = graph
-        @io = io
-      end
+class Hashira::CI::EdgeDiffReport
+  def initialize(graph, io: $stdout)
+    @graph = graph
+    @io = io
+  end
 
-      def print(diff)
-        diff.added.each { print_edge(it) }
-        Improvement.new("Edges removed", io: @io).print(diff.removed)
-      end
+  def print(diff)
+    diff.added.each { emit(it) }
+    Hashira::CI::Improvement.new("Edges removed", io: @io).print(diff.removed)
+  end
 
-      private
+  private
 
-      def print_edge(edge)
-        @io.puts "NEW EDGE #{edge} — introduced by:"
-        @graph.evidence_for(edge.from, edge.to).to_a.sort.each { @io.puts "  · #{it}" }
-      end
-    end
+  def emit(edge)
+    @io.puts("NEW EDGE #{edge} — introduced by:")
+    @graph.evidence(edge.from, edge.to).to_a.sort.each { @io.puts("  · #{it}") }
   end
 end

data/lib/hashira/ci/finding_diff_report.rb

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

data/lib/hashira/ci/gate.rb

@@ -1,31 +1,27 @@
 # frozen_string_literal: true
 
-module Hashira
-  module CI
-    class Gate
-      def initialize(findings, kinds, io: $stdout)
-        @findings = findings
-        @kinds = kinds
-        @io = io
-      end
+class Hashira::CI::Gate
+  def initialize(findings, kinds, io: $stdout)
+    @findings = findings
+    @kinds = kinds
+    @io = io
+  end
 
-      def check
-        offending = @findings.all.select { @kinds.include?(it.kind) }
-        offending.empty? ? report_clean : report_failure(offending)
-      end
+  def check
+    offending = @findings.all.select { @kinds.include?(it.kind) }
+    offending.empty? ? clean : failure(offending)
+  end
 
-      private
+  private
 
-      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
+  def failure(offending)
+    offending.each { Hashira::Report::FindingLines.new(it, io: @io).print }
+    @io.puts("\nGate FAILED: #{offending.size} finding(s) of kind #{@kinds.join(", ")}.")
+    1
+  end
 
-      def report_clean
-        @io.puts "Gate OK: no findings of kind #{@kinds.join(", ")}."
-        0
-      end
-    end
+  def clean
+    @io.puts("Gate OK: no findings of kind #{@kinds.join(", ")}.")
+    0
   end
 end

data/lib/hashira/ci/improvement.rb

@@ -1,19 +1,14 @@
 # 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?
+class Hashira::CI::Improvement
+  def initialize(label, io: $stdout)
+    @label = label
+    @io = io
+  end
 
-        @io.puts "#{@label} (improvement!): #{removed.join(", ")}"
-        @io.puts "Lock it in: hashira --update-baseline"
-      end
-    end
+  def print(removed)
+    return if removed.empty?
+    @io.puts("#{@label} (improvement!): #{removed.join(", ")}")
+    @io.puts("Lock it in: hashira --update-baseline")
   end
 end

data/lib/hashira/ci/ratchet.rb

@@ -1,40 +1,49 @@
 # frozen_string_literal: true
 
-module Hashira
-  module CI
-    class Ratchet
-      def initialize(graph, findings, baseline_path, io: $stdout)
-        @graph = graph
-        @findings = findings
-        @baseline = Baseline.load(baseline_path)
-        @io = io
-      end
+class Hashira::CI::Ratchet
+  def initialize(graph, findings, baseline_path, io: $stdout)
+    @graph = graph
+    @findings = findings
+    @baseline = Hashira::CI::Baseline.load(baseline_path)
+    @io = io
+  end
+
+  def update
+    @baseline.write(edges, digests, packaging:)
+    @io.puts("Baseline updated: #{edges.size} edges, #{digests.size} findings.")
+    0
+  end
 
-      def update
-        @baseline.write(edge_signatures, finding_signatures)
-        @io.puts "Baseline updated: #{edge_signatures.size} edges, #{finding_signatures.size} findings."
-        0
-      end
+  def check
+    raise(Hashira::Error, "no baseline at #{@baseline.path} — run --update-baseline first") unless @baseline.exist?
+    vet
+    Hashira::CI::RatchetReport.new(@graph, @findings, io: @io).print(drift, delta)
+  end
 
-      def check
-        raise Error, "no baseline at #{@baseline.path} — run --update-baseline first" unless @baseline.exist?
+  private
 
-        RatchetReport.new(@graph, @findings, io: @io).print(edge_diff, finding_diff)
-      end
+  def packaging = @graph.packaging.to_s
 
-      private
+  def vet
+    return if @baseline.packaging == packaging
+    raise(Hashira::Error, mismatch)
+  end
+
+  def mismatch
+    recorded = @baseline.packaging
+    "baseline #{@baseline.path} was recorded with --package-by #{recorded}, but this run " \
+      "uses #{packaging} — rerun with --package-by #{recorded}, or refresh it with --update-baseline"
+  end
 
-      def edge_signatures = @graph.edge_list.map(&:to_s)
+  def edges = @graph.edges.map(&:to_s)
 
-      def finding_signatures = @findings.map(&:signature).uniq.sort
+  def digests = @findings.map(&:signature).uniq.sort
 
-      def edge_diff = Diff.new(added: new_edges, removed: @baseline.edges - edge_signatures)
+  def drift = Hashira::CI::Diff.new(added: fresh, removed: @baseline.edges - edges)
 
-      def new_edges = @graph.edge_list.reject { @baseline.edges.include?(it.to_s) }
+  def fresh = @graph.edges.reject { @baseline.edges.include?(it.to_s) }
 
-      def finding_diff
-        Diff.between(finding_signatures, @baseline.findings) if @baseline.ratchets_findings?
-      end
-    end
+  def delta
+    Hashira::CI::Diff.between(digests, @baseline.findings) if @baseline.findings?
   end
 end

data/lib/hashira/ci/ratchet_report.rb

@@ -1,42 +1,36 @@
 # 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
+class Hashira::CI::RatchetReport
+  def initialize(graph, findings, io: $stdout)
+    @graph = graph
+    @findings = findings
+    @io = io
+  end
 
-      private
+  def print(edges, findings)
+    return unchanged if quiet?(edges, findings)
+    details(edges, findings)
+    advice(edges, findings)
+    1
+  end
 
-      def quiet?(*diffs) = diffs.compact.all?(&:empty?)
+  private
 
-      def unchanged
-        @io.puts "Ratchet OK: #{@graph.edge_list.size} edges, #{@findings.size} findings, unchanged."
-        0
-      end
+  def quiet?(*diffs) = diffs.compact.all?(&:empty?)
 
-      def details(edges, findings)
-        EdgeDiffReport.new(@graph, io: @io).print(edges)
-        FindingDiffReport.new(@findings, io: @io).print(findings) if findings
-      end
+  def unchanged
+    @io.puts("Ratchet OK: #{@graph.edges.size} edges, #{@findings.size} findings, unchanged.")
+    0
+  end
 
-      def advice(*diffs)
-        return unless diffs.compact.any?(&:worse?)
+  def details(edges, findings)
+    Hashira::CI::EdgeDiffReport.new(@graph, io: @io).print(edges)
+    Hashira::CI::FindingDiffReport.new(@findings, io: @io).print(findings) if findings
+  end
 
-        @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
+  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

data/lib/hashira/cli/arguments.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Hashira::CLI::Arguments
+  def initialize(argv)
+    @argv = argv.dup
+  end
+
+  def take(flag, default)
+    position = @argv.index(flag)
+    return default unless position
+    _flag, value = @argv.slice!(position, 2)
+    raise(Hashira::Error, "#{flag} needs a value") unless value
+    value
+  end
+
+  def delete(flag) = @argv.delete(flag)
+
+  def rest
+    stray = @argv.find { it.start_with?("-") }
+    raise(Hashira::Error, "unknown option #{stray}") if stray
+    @argv
+  end
+end