hashira 0.3.0 → 0.5.0

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,45 @@
 # 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 = Hashira::CI::RatchetReport.new(@graph, @findings, io: @io).print(drift, delta)
 
-      def check
-        raise Error, "no baseline at #{@baseline.path} — run --update-baseline first" unless @baseline.exist?
+  def blocker
+    return "no baseline at #{@baseline.path} — run --update-baseline first" unless @baseline.exist?
+    mismatch unless @baseline.packaging == packaging
+  end
+
+  private
 
-        RatchetReport.new(@graph, @findings, io: @io).print(edge_diff, finding_diff)
-      end
+  def packaging = @graph.packaging.to_s
 
-      private
+  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

data/lib/hashira/cli/command_line.rb

@@ -1,92 +1,76 @@
 # frozen_string_literal: true
 
-module Hashira
-  class CLI
-    class CommandLine
-      DEFAULT_BASELINE = "hashira_baseline.json"
+class Hashira::CLI::CommandLine
+  DEFAULT_BASELINE = "hashira_baseline.json"
 
-      FORMATS = %w[text json dot mermaid].freeze
+  FORMATS = %w[text json dot mermaid].freeze
 
-      CI_FLAGS = { "--update-baseline" => :update_baseline, "--ratchet" => :ratchet }.freeze
+  CI_FLAGS = { "--update-baseline" => :update, "--ratchet" => :ratchet }.freeze
 
-      def initialize(argv)
-        @arguments = argv.dup
-      end
-
-      def options = usage_options || parsed_options
-
-      private
-
-      def usage_options
-        return usage(:help) if delete("--help") || delete("-h")
-
-        usage(:version) if delete("--version")
-      end
+  def initialize(argv)
+    @arguments = Hashira::CLI::Arguments.new(argv)
+  end
 
-      def usage(mode) = Options.new(directories: [], mode:, baseline: nil, fail_on: [], skip: [])
+  def options = shortcuts || parsed
 
-      def parsed_options
-        values = flag_values
-        mode = parse_mode(values[:fail_on])
-        reject_unknown_flags
-        Options.new(directories: @arguments, mode:, **values)
-      end
+  private
 
-      def flag_values
-        { skip: Skip.parse(take_value("--skip")),
-          fail_on: FailOn.parse(take_value("--fail-on")),
-          baseline: take_value("--baseline") || DEFAULT_BASELINE }
-      end
+  def shortcuts
+    return usage(:help) if delete("--help") || delete("-h")
+    usage(:version) if delete("--version")
+  end
 
-      def parse_mode(fail_on)
-        case (requested = requested_modes(fail_on).uniq(&:last))
-        in [] then :text
-        in [[_flag, mode]] then mode
-        else conflict(requested)
-        end
-      end
+  def usage(mode)
+    Hashira::CLI::Options.new(directories: [], mode:, baseline: nil, fail_on: [], skip: [], packaging: :auto)
+  end
 
-      def conflict(requested)
-        raise Error, "conflicting options: #{requested.map(&:first).join(" and ")}"
-      end
+  def parsed
+    values = flags
+    values[:mode] = mode(values[:fail_on])
+    Hashira::CLI::Options.new(directories: @arguments.rest, **values)
+  end
 
-      def requested_modes(fail_on)
-        ci = CI_FLAGS.filter_map { |flag, mode| [flag, mode] if delete(flag) }
-        ci + fail_on_mode(fail_on) + format_modes
-      end
+  def flags
+    {
+      skip: Hashira::CLI::Skip.parse(take("--skip", "")),
+      fail_on: Hashira::CLI::FailOn.parse(take("--fail-on", "")),
+      baseline: take("--baseline", DEFAULT_BASELINE), packaging: grouping
+    }
+  end
 
-      def fail_on_mode(fail_on) = fail_on.empty? ? [] : [["--fail-on", :fail_on]]
+  def grouping = Hashira::CLI::PackageBy.parse(take("--package-by", ""))
 
-      def format_modes
-        format = take_format
-        modes = format ? [["--format #{format}", format.to_sym]] : []
-        delete("--json") ? modes + [["--json", :json]] : modes
-      end
+  def mode(fail_on)
+    case (asked = requested(fail_on).uniq(&:last))
+    in [] then :text
+    in [[_flag, mode]] then mode
+    else conflict(asked)
+    end
+  end
 
-      def take_format
-        format = take_value("--format")
-        return format unless format
-        raise Error, "unknown --format #{format.inspect} (use: #{FORMATS.join(", ")})" unless FORMATS.include?(format)
+  def conflict(asked)
+    raise(Hashira::Error, "conflicting options: #{asked.map(&:first).join(" and ")}")
+  end
 
-        format
-      end
+  def requested(fail_on)
+    CI_FLAGS.filter_map { |flag, mode| [flag, mode] if delete(flag) } + gate(fail_on) + formats
+  end
 
-      def take_value(flag)
-        position = @arguments.index(flag)
-        return nil unless position
+  def gate(fail_on) = fail_on.empty? ? [] : [["--fail-on", :fail_on]]
 
-        _flag, value = @arguments.slice!(position, 2)
-        raise Error, "#{flag} needs a value" unless value
+  def formats
+    chosen = format
+    modes = chosen.empty? ? [] : [["--format #{chosen}", chosen.to_sym]]
+    delete("--json") ? modes + [["--json", :json]] : modes
+  end
 
-        value
-      end
+  def format
+    wanted = take("--format", "")
+    return wanted if wanted.empty? || FORMATS.include?(wanted)
+    raise(Hashira::Error.unknown("--format", wanted, FORMATS))
+  end
 
-      def delete(flag) = @arguments.delete(flag)
+  def take(flag, default) = @arguments.take(flag, default)
 
-      def reject_unknown_flags
-        stray = @arguments.find { it.start_with?("-") }
-        raise Error, "unknown option #{stray}" if stray
-      end
-    end
-  end
+  def delete(flag) = @arguments.delete(flag)
 end

data/lib/hashira/cli/fail_on.rb

@@ -1,28 +1,33 @@
 # frozen_string_literal: true
 
-module Hashira
-  class CLI
-    module FailOn
-      KINDS = {
-        "cycles" => "cycle", "cycle" => "cycle",
-        "sdp" => "sdp_violation", "sdp_violation" => "sdp_violation",
-        "complexity" => "complexity",
-        "duplication" => "duplication", "dupe" => "duplication"
-      }.freeze
+require_relative "../pipeline"
 
-      module_function
+module Hashira::CLI::FailOn
+  SMELLS = %w[
+    control_parameter data_clump duplicate_method_call feature_envy instance_variable_assumption
+    manual_dispatch module_initialize nil_check repeated_conditional too_many_instance_variables
+    utility_function
+  ].freeze
 
-      def parse(list)
-        return [] unless list
+  MEASURES = (Hashira::Pipeline::ANALYZERS - %i[coupling smells]).map(&:to_s).freeze
 
-        list.split(",").map { kind(it.strip) }.uniq
-      end
+  KINDS = {
+    "cycles" => "cycle", "sdp" => "sdp_violation", "dupe" => "duplication",
+    **Hashira::Pipeline::STRUCTURAL.to_h { [it, it] },
+    **MEASURES.to_h { [it, it] },
+    "smells" => SMELLS, **SMELLS.to_h { [it, it] }
+  }.freeze
 
-      def kind(name)
-        KINDS.fetch(name) do
-          raise Error, "unknown --fail-on kind #{name.inspect} (use: #{KINDS.keys.join(", ")})"
-        end
-      end
+  module_function
+
+  def parse(list)
+    return [] unless list
+    list.split(",").flat_map { Array(kind(it.strip)) }.uniq
+  end
+
+  def kind(name)
+    KINDS.fetch(name) do
+      raise(Hashira::Error, "unknown --fail-on kind #{name.inspect} (use: #{KINDS.keys.join(", ")})")
     end
   end
 end

data/lib/hashira/cli/options.rb

@@ -1,9 +1,14 @@
 # frozen_string_literal: true
 
-module Hashira
-  class CLI
-    Options = Data.define(:directories, :mode, :baseline, :fail_on, :skip) do
+class Hashira::CLI
+  Options =
+    Data.define(:directories, :mode, :baseline, :fail_on, :skip, :packaging) do
       def self.parse(argv) = CommandLine.new(argv).options
+
+      def pipeline
+        Hashira::Pipeline.new(Hashira::Project.detect(directories), enabled: analyzers, packaging:)
+      end
+
+      def analyzers = Hashira::Pipeline::ANALYZERS - skip
     end
-  end
 end

data/lib/hashira/cli/package_by.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Hashira::CLI::PackageBy
+  CHOICES = %i[auto folder namespace].freeze
+
+  module_function
+
+  def parse(value)
+    return :auto if value.empty?
+    choice = value.to_sym
+    return choice if CHOICES.include?(choice)
+    raise(Hashira::Error.unknown("--package-by", value, CHOICES))
+  end
+end