hashira 0.2.0 → 0.4.0

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,23 @@
 # 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
+module Hashira::CLI::FailOn
+  KINDS = {
+    "cycles" => "cycle", "cycle" => "cycle",
+    "sdp" => "sdp_violation", "sdp_violation" => "sdp_violation",
+    "complexity" => "complexity",
+    "duplication" => "duplication", "dupe" => "duplication"
+  }.freeze
 
-      module_function
+  module_function
 
-      def parse(list)
-        return [] unless list
-
-        list.split(",").map { kind(it.strip) }.uniq
-      end
+  def parse(list)
+    return [] unless list
+    list.split(",").map { kind(it.strip) }.uniq
+  end
 
-      def kind(name)
-        KINDS.fetch(name) do
-          raise Error, "unknown --fail-on kind #{name.inspect} (use: #{KINDS.keys.join(", ")})"
-        end
-      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

data/lib/hashira/cli/run.rb

@@ -1,44 +1,46 @@
 # 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 graph = @pipeline.graph
 
-      def exit_code = send(MODES.fetch(@options.mode, :print_text))
+  def findings = @findings ||= Hashira::CI::Accepted.load(@options.baseline).screen(@pipeline.findings)
 
-      private
+  def update = ratchet.update
 
-      def graph = @pipeline.graph
+  def check = ratchet.check
 
-      def ratchet = CI::Ratchet.new(graph, findings.all, @options.baseline)
+  def guard = gate.check
 
-      def update_baseline = ratchet.update
+  def diagram = renderer.display
 
-      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 = 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 renderer = Hashira::Diagram::Renderer.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,45 @@
 # 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, 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
+      --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/analyzer.rb

@@ -1,45 +1,43 @@
 # frozen_string_literal: true
 
-module Hashira
-  module Complexity
-    class Analyzer
-      THRESHOLD = 10
+class Hashira::Complexity::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 initialize(project, trees)
+    @project = project
+    @scores = trees.flat_map { |path, tree| harvest(path, tree) }
+  end
 
-      def findings = flagged.map { MethodFinding.new(it).to_finding }
+  def methods = @scores.sort_by { -it.cognitive }
 
-      private
+  def classes = Hashira::Complexity::Rollup.new(@scores).classes.sort_by { -it.cognitive }
 
-      def flagged = methods.select { it.cognitive >= THRESHOLD }
+  def findings = flagged.map { Hashira::Complexity::MethodFinding.new(it).to_finding }
 
-      def scores_for(path, tree)
-        rel = @project.relative(path)
-        methods_in(tree).map { |full, node| build_score(rel, full, node) }
-      end
+  private
 
-      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 flagged = methods.select { it.cognitive >= THRESHOLD }
 
-      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 harvest(path, tree)
+    rel = @project.relative(path)
+    sites(tree).map { |full, node| score(rel, full, node) }
+  end
 
-      def subject(full, node) = "#{full.join("::")}#{node.receiver ? "." : "#"}#{node.name}"
+  def sites(tree)
+    found = []
+    Hashira::Analysis::TypeWalk.each(tree) do |type_node, full|
+      Hashira::Analysis::Syntax.direct(type_node).each { found << [full, it] }
     end
+    found
   end
+
+  def score(rel, full, node)
+    score = Hashira::Complexity::CognitiveScore.new(node)
+    Hashira::Complexity::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

data/lib/hashira/complexity/boolean_run.rb

@@ -1,22 +1,18 @@
 # 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, nesting)
+    @scorer.add(node, 1, "boolean")
+    operands(node).each { @scorer.visit(it, nesting) }
+  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 { it.instance_of?(node.class) ? operands(it) : [it] }
   end
 end