hashira 0.7.0 → 0.9.0

data/lib/hashira/cli/arguments.rb

@@ -1,28 +1,32 @@
 # frozen_string_literal: true
 
 class Hashira::CLI::Arguments
-  def initialize(argv)
-    @argv = argv.dup
+  def initialize(given)
+    @given = given
   end
 
   def take(flag, default)
-    position = @argv.index(flag)
+    position = argv.index(flag)
     return default unless position
-    _flag, value = @argv.slice!(position, 2)
+    _flag, value = argv.slice!(position, 2)
     vet(flag, value)
   end
 
   def vet(flag, value)
     raise(Hashira::Error, "#{flag} needs a value") if value.to_s.strip.empty?
-    raise(Hashira::Error, "#{flag} given more than once") if @argv.include?(flag)
+    raise(Hashira::Error, "#{flag} given more than once") if argv.include?(flag)
     value
   end
 
-  def delete(flag) = @argv.delete(flag)
+  def delete(flag) = argv.delete(flag)
 
   def rest
-    stray = @argv.find { it.start_with?("-") }
+    stray = argv.find { it.start_with?("-") }
     raise(Hashira::Error, "unknown option #{stray}") if stray
-    @argv
+    argv
   end
+
+  private
+
+  def argv = @_argv ||= @given.dup
 end

data/lib/hashira/cli/choice.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Hashira::CLI::Choice
+  module_function
+
+  def unknown(flag, value, choices)
+    Hashira::Error.new("unknown #{flag} #{value.inspect} (use: #{choices.join(", ")})")
+  end
+end

data/lib/hashira/cli/command_line.rb

@@ -2,23 +2,26 @@
 
 class Hashira::CLI::CommandLine
   def initialize(argv)
-    @arguments = Hashira::CLI::Arguments.new(argv)
+    @argv = argv
   end
 
   def options = page || parsed
 
   private
 
+  def arguments = @_arguments ||= Hashira::CLI::Arguments.new(@argv)
+
   def page
     flag = Hashira::CLI::FLAGS.select(&:page?).find { seen?(it) }
-    Hashira::CLI::Options.page(flag.mode) if flag
+    Hashira::CLI::Options.build(flag.mode) if flag
   end
 
-  def seen?(flag) = flag.names.any? { @arguments.delete(it) }
+  def seen?(flag) = flag.names.any? { arguments.delete(it) }
 
   def parsed
-    parses = Hashira::CLI::FLAGS.reject(&:page?).to_h { [it, it.read(@arguments)] }
-    Hashira::CLI::Options.new(directories: @arguments.rest, mode: mode(parses), **fields(parses))
+    parses = Hashira::CLI::FLAGS.reject(&:page?).to_h { [it, it.read(arguments)] }
+    Hashira::CLI::Options.new(directories: arguments.rest, mode: mode(parses), **fields(parses))
+      .tap { Hashira::CLI::Needs.check(it) }
   end
 
   def fields(parses) = parses.to_h { |flag, value| [flag.field, value] }.except(nil)

data/lib/hashira/cli/fail_on.rb

@@ -5,12 +5,12 @@ require_relative "../pipeline"
 module Hashira::CLI::FailOn
   MEASURES = (Hashira::Pipeline::ANALYZERS - %i[coupling smells]).map(&:to_s).freeze
 
-  KINDS = {
-    "cycles" => "cycle", "sdp" => "sdp_violation", "dupe" => "duplication",
-    **Hashira::Pipeline::STRUCTURAL.to_h { [it, it] },
-    **MEASURES.to_h { [it, it] },
-    "smells" => Hashira::Pipeline::SMELLS, **Hashira::Pipeline::SMELLS.to_h { [it, it] }
-  }.freeze
+  KINDS = { "cycles" => "cycle", "sdp" => "sdp_violation", "dupe" => "duplication" }
+    .merge(Hashira::Pipeline::STRUCTURAL.to_h { [it, it] })
+    .merge(MEASURES.to_h { [it, it] })
+    .merge("smells" => Hashira::Pipeline::SMELLS)
+    .merge(Hashira::Pipeline::SMELLS.to_h { [it, it] })
+    .freeze
 
   OWNERS = {
     **Hashira::Pipeline::STRUCTURAL.to_h { [it, :coupling] },

data/lib/hashira/cli/flag.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 class Hashira::CLI
+  BLANK = %i[arg field parse mode].to_h { [it, nil] }.freeze
+
   Flag =
     Data.define(:name, :arg, :default, :field, :parse, :mode, :text) do
-      def initialize(**attributes) = super(arg: nil, default: "", field: nil, parse: nil, mode: nil, **attributes)
+      def initialize(**attributes) = super(**BLANK, default: "", **attributes)
 
       def read(arguments) = arg ? take(arguments) : arguments.delete(name)
 

data/lib/hashira/cli/flags.rb

@@ -3,6 +3,7 @@
 require_relative "fail_on"
 require_relative "flag"
 require_relative "format"
+require_relative "only"
 require_relative "package_by"
 require_relative "skip"
 require_relative "top"
@@ -31,6 +32,15 @@ class Hashira::CLI
       name: "--skip", arg: "ANALYZERS", field: :skip, parse: Skip,
       text: ["drop an analyzer; comma-separated: coupling,", "complexity, duplication, smells"]
     ),
+    Flag.new(
+      name: "--only", arg: "PATHS", field: :only, parse: Only,
+      text: [
+        "keep only the findings that name these files;",
+        "comma-separated. The whole project is still read,",
+        "so cross-file signals stay right. Meant for hooks:",
+        "hashira --only $CHANGED --ratchet"
+      ]
+    ),
     Flag.new(
       name: "--top", arg: "N", field: :top, parse: Top,
       text: [

data/lib/hashira/cli/format.rb

@@ -8,6 +8,6 @@ module Hashira::CLI::Format
   def parse(value)
     return if value.empty?
     return value.to_sym if CHOICES.include?(value)
-    raise(Hashira::Error.unknown("--format", value, CHOICES))
+    raise(Hashira::CLI::Choice.unknown("--format", value, CHOICES))
   end
 end

data/lib/hashira/cli/needs.rb

@@ -12,10 +12,21 @@ module Hashira::CLI::Needs
     skip = options.skip
     drawing(mode, skip)
     gate(options.fail_on, skip)
-    shaping(mode) if options.compact
+    shaping(options, mode)
   end
 
-  def shaping(mode)
+  def shaping(options, mode)
+    compacting(mode) if options.compact
+    focusing(mode) unless options.only.empty?
+  end
+
+  def focusing(mode)
+    raise(Hashira::Error, "--only narrows the findings, but --update-baseline records them all") if mode == :update
+    return unless DIAGRAMS.include?(mode)
+    raise(Hashira::Error, "--format #{mode} draws the coupling graph, which --only cannot narrow")
+  end
+
+  def compacting(mode)
     raise(Hashira::Error, "--compact shapes JSON, but this run emits #{mode}") unless mode == :json
   end
 

data/lib/hashira/cli/only.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Hashira::CLI::Only
+  module_function
+
+  def parse(value)
+    return [] if value.empty?
+    value.split(",").map { vet(it.strip) }
+  end
+
+  def vet(path)
+    here = path.delete_prefix("#{Dir.pwd}/").delete_prefix("./")
+    raise(Hashira::Error, "--only #{path.inspect} is not a file here") unless File.file?(here)
+    here
+  end
+end

data/lib/hashira/cli/options.rb

@@ -1,25 +1,23 @@
 # frozen_string_literal: true
 
 class Hashira::CLI
-  PAGE = { directories: [], baseline: "", fail_on: [], skip: [], packaging: :auto, top: nil, compact: nil }.freeze
-
   Options =
-    Data.define(:directories, :mode, :baseline, :fail_on, :skip, :packaging, :top, :compact) do
+    Data.define(:directories, :mode, :baseline, :fail_on, :skip, :only, :packaging, :top, :compact) do
       def self.parse(argv) = CommandLine.new(argv).options
 
-      def self.page(mode) = new(**PAGE, mode:)
-
-      def initialize(**attributes)
-        super
-        Needs.check(self)
+      def self.build(mode)
+        new(
+          directories: [], baseline: "", fail_on: [], skip: [], only: [],
+          packaging: :auto, top: nil, compact: nil, mode:
+        )
       end
 
       def pipeline
-        chosen = Hashira::Project.detect(directories)
+        chosen = Hashira::Project.new(directories)
         told = Hashira::Report::Notices.new
         told.scanning(chosen.files.size)
         told.rails if directories.empty? && File.exist?("config/application.rb")
-        Hashira::Pipeline.new(chosen, enabled: analyzers, packaging:)
+        Hashira::Pipeline.new(chosen, enabled: analyzers, packaging:, only:)
       end
 
       def analyzers = Hashira::Pipeline::ANALYZERS - skip

data/lib/hashira/cli/package_by.rb

@@ -9,6 +9,6 @@ module Hashira::CLI::PackageBy
     return :auto if value.empty?
     choice = value.to_sym
     return choice if CHOICES.include?(choice)
-    raise(Hashira::Error.unknown("--package-by", value, CHOICES))
+    raise(Hashira::CLI::Choice.unknown("--package-by", value, CHOICES))
   end
 end

data/lib/hashira/cli/run.rb

@@ -1,26 +1,27 @@
 # frozen_string_literal: true
 
 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
 
+  MODES = { update: :update, ratchet: :check, fail_on: :guard }
+    .merge(json: :json, dot: :diagram, mermaid: :diagram).freeze
+
   def status = __send__(MODES.fetch(@options.mode, :text))
 
   private
 
   def graph = @pipeline.graph
 
-  def findings = @findings ||= accepted.screen(@pipeline.findings)
+  def findings = @_findings ||= accepted.screen(@pipeline.findings)
 
   def accepted
     path = @options.baseline
-    stop = Hashira::CI::Baseline.trouble(path)
+    stop = Hashira::CI::Baseline.new(path).trouble
     raise(Hashira::Error, stop) if stop
-    Hashira::CI::Accepted.load(path)
+    Hashira::CI::Accepted.build(path)
   end
 
   def update
@@ -32,7 +33,7 @@ class Hashira::CLI::Run
   def check
     stop = ratchet.blocker
     raise(Hashira::Error, stop) if stop
-    ratchet.check
+    ratchet.check(@pipeline.focus)
   end
 
   def guard = gate.check
@@ -55,10 +56,10 @@ class Hashira::CLI::Run
     told.unparsed(broken.size, broken.first(3).join(", ")) unless broken.empty?
   end
 
-  def ratchet = @ratchet ||= Hashira::CI::Ratchet.new(graph, findings.all, baseline)
+  def ratchet = @_ratchet ||= Hashira::CI::Ratchet.new(graph, findings.all, baseline)
 
   def baseline
-    Hashira::CI::Baseline.load(@options.baseline, analyzers: @options.analyzers, targets:)
+    Hashira::CI::Baseline.new(@options.baseline, analyzers: @options.analyzers, targets:)
   end
 
   def targets = @pipeline.project.directories

data/lib/hashira/cli.rb

@@ -4,40 +4,41 @@ class Hashira::CLI
   MISUSE = 2
   BROKEN = 70
 
-  def self.run(argv)
-    dispatch(Options.parse(argv))
+  def initialize(argv)
+    @argv = argv
+  end
+
+  def status
+    dispatch(Options.parse(@argv))
   rescue Hashira::Error => error
     failure(error)
   rescue StandardError => error
     crash(error)
   end
 
-  def self.dispatch(options) = usage?(options) ? Usage.public_send(options.mode) : new(options).run
+  private
+
+  def dispatch(options) = usage?(options) ? Usage.public_send(options.mode) : timed(options)
+
+  def usage?(options) = Usage::PAGES.include?(options.mode)
+
+  def timed(options)
+    started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    pipeline = options.pipeline
+    Run.new(pipeline, options).status.tap do
+      Hashira::Report::Notices.new.finished(pipeline.project.files.size, elapsed(started))
+    end
+  end
 
-  def self.usage?(options) = Usage::PAGES.include?(options.mode)
+  def elapsed(started) = format("%.1f", Process.clock_gettime(Process::CLOCK_MONOTONIC) - started)
 
-  def self.failure(error)
+  def failure(error)
     Kernel.warn("hashira: #{error.message}")
     MISUSE
   end
 
-  def self.crash(error)
+  def crash(error)
     Hashira::Report::Notices.new.crashed(error)
     BROKEN
   end
-
-  def initialize(options)
-    @started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    @options = options
-    @notices = Hashira::Report::Notices.new
-    @pipeline = options.pipeline
-  end
-
-  def run
-    Run.new(@pipeline, @options).status.tap { @notices.finished(@pipeline.project.files.size, elapsed) }
-  end
-
-  private
-
-  def elapsed = format("%.1f", Process.clock_gettime(Process::CLOCK_MONOTONIC) - @started)
 end

data/lib/hashira/complexity/cognitive_score.rb

@@ -3,37 +3,35 @@
 require "prism"
 
 class Hashira::Complexity::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
-    @nesting = 0
-    visit(def_node.body)
+  HANDLERS = { Prism::IfNode => :on_if, Prism::BeginNode => :on_begin, Prism::BlockNode => :on_block }
+    .merge(Prism::AndNode => :on_boolean, Prism::OrNode => :on_boolean, Prism::CallNode => :on_call)
+    .merge(Prism::UnlessNode => :on_nester, Prism::WhileNode => :on_nester, Prism::UntilNode => :on_nester)
+    .merge(Prism::ForNode => :on_nester, Prism::CaseNode => :on_nester, Prism::CaseMatchNode => :on_nester)
+    .freeze
+
+  LABELS = { Prism::UnlessNode => "unless", Prism::WhileNode => "while", Prism::UntilNode => "until" }
+    .merge(Prism::ForNode => "for", Prism::CaseNode => "case", Prism::CaseMatchNode => "case").freeze
+
+  def initialize(node)
+    @node = node
+  end
+
+  def increments
+    walked
+    @_increments
   end
 
-  attr_reader :increments, :calls, :nesting
+  def calls
+    walked
+    @_calls
+  end
 
-  def total = @increments.sum(&:cost)
+  def nesting
+    walked
+    @_nesting
+  end
+
+  def total = increments.sum(&:cost)
 
   def visit(node)
     return unless node
@@ -41,28 +39,41 @@ class Hashira::Complexity::CognitiveScore
   end
 
   def add(node, cost, label)
-    @increments << Hashira::Complexity::Increment.new(line: node.location.start_line, cost:, label:)
+    @_increments << Hashira::Complexity::Increment.new(line: node.location.start_line, cost:, label:)
   end
 
   def deeper
-    @nesting += 1
+    @_nesting += 1
     yield
-    @nesting -= 1
+    @_nesting -= 1
   end
 
   private
 
+  def walked
+    return if @_walked
+    @_walked = true
+    blank
+    visit(@node.body)
+  end
+
+  def blank
+    @_increments = []
+    @_calls = 0
+    @_nesting = 0
+  end
+
   def descend(node) = node.compact_child_nodes.each { visit(it) }
 
   def on_call(node)
-    @calls += 1
+    @_calls += 1
     descend(node)
   end
 
   def on_block(node) = deeper { descend(node) }
 
   def on_nester(node)
-    add(node, 1 + @nesting, LABELS.fetch(node.class))
+    add(node, 1 + @_nesting, LABELS.fetch(node.class))
     deeper { descend(node) }
   end
 

data/lib/hashira/complexity/method_finding.rb

@@ -3,6 +3,8 @@
 class Hashira::Complexity::MethodFinding
   KIND = "complexity"
 
+  Effort = Data.define(:cognitive, :calls, :site, :dominant)
+
   def initialize(score)
     @score = score
   end
@@ -14,16 +16,16 @@ class Hashira::Complexity::MethodFinding
   private
 
   def detail
-    { cognitive: @score.cognitive, calls: @score.calls, site: "#{@score.file}:#{@score.line}", dominant: }
+    Effort.new(cognitive: @score.cognitive, calls: @score.calls, site: "#{@score.file}:#{@score.line}", dominant:)
   end
 
   def evidence
-    @score.increments.group_by(&:label).map { |label, incs| lines(label, incs) }
+    @score.increments.group_by(&:label).map { |label, increments| lines(label, increments) }
   end
 
-  def lines(label, incs)
-    lines = incs.map(&:line).uniq
-    "#{label} +#{incs.sum(&:cost)} (line#{"s" if lines.size > 1} #{lines.join(", ")})"
+  def lines(label, increments)
+    lines = increments.map(&:line).uniq
+    "#{label} +#{increments.sum(&:cost)} (line#{"s" if lines.size > 1} #{lines.join(", ")})"
   end
 
   def dominant

data/lib/hashira/complexity/method_score.rb

@@ -6,7 +6,7 @@ module Hashira
 
     MethodScore =
       Data.define(:subject, :file, :line, :cognitive, :calls, :increments) do
-        def to_h = { subject:, file:, line:, cognitive:, calls: }
+        def to_h = super.except(:increments)
 
         def cells = [subject, cognitive, calls, "#{file}:#{line}"]
       end

data/lib/hashira/complexity/scores.rb

@@ -5,35 +5,37 @@ class Hashira::Complexity::Scores
 
   def initialize(project, trees)
     @project = project
-    @scores = trees.flat_map { |path, tree| harvest(path, tree) }
+    @trees = trees
   end
 
-  def ranked = @scores.sort_by { -it.cognitive }
+  def ranked = scores.sort_by { -it.cognitive }
 
-  def classes = Hashira::Complexity::Rollup.new(@scores).classes.sort_by { -it.cognitive }
+  def classes = Hashira::Complexity::Rollup.new(scores).classes.sort_by { -it.cognitive }
 
   def findings = flagged.map { Hashira::Complexity::MethodFinding.new(it).to_finding }
 
   private
 
+  def scores = @_scores ||= @trees.flat_map { |path, tree| harvest(path, tree) }
+
   def flagged = ranked.select { it.cognitive >= THRESHOLD }
 
   def harvest(path, tree)
-    rel = @project.relative(path)
-    sites(tree).map { |full, node| score(rel, full, node) }
+    relative = @project.relative(path)
+    sites(tree).map { |full, node| score(relative, full, node) }
   end
 
   def sites(tree)
     found = []
-    Hashira::Analysis::TypeWalk.each(tree) do |type_node, full|
-      Hashira::Analysis::Syntax.direct(type_node).each { found << [full, it] }
+    Hashira::Analysis::TypeWalk.each(tree) do |type, full|
+      Hashira::Analysis::Syntax.direct(type).each { found << [full, it] }
     end
     found
   end
 
-  def score(rel, full, node)
+  def score(relative, full, node)
     Hashira::Complexity::MethodScore.new(
-      subject: subject(full, node), file: rel, line: node.location.start_line,
+      subject: subject(full, node), file: relative, line: node.location.start_line,
       **tallies(Hashira::Complexity::CognitiveScore.new(node))
     )
   end

data/lib/hashira/coupling/audiences.rb

@@ -11,13 +11,13 @@ class Hashira::Coupling::Audiences
 
   def split? = parts.size >= 2
 
-  def parts = @parts ||= [common, *slices].compact.select { it.constants.size >= MIN }
+  def parts = @_parts ||= [common, *slices].compact.select { it.constants.size >= MIN }
 
   private
 
-  def clients = @clients ||= @usage.keys.sort
+  def clients = @_clients ||= @usage.keys.sort
 
-  def shared = @shared ||= tally.select { |_constant, users| users.size * 2 > clients.size }.keys.to_set
+  def shared = @_shared ||= tally.select { |_constant, users| users.size * 2 > clients.size }.keys.to_set
 
   def tally
     clients.each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |client, seen|

data/lib/hashira/coupling/catalog.rb

@@ -5,15 +5,13 @@ class Hashira::Coupling::Catalog
 
   def initialize(definitions)
     @definitions = definitions
-    @naming = Hashira::Coupling::Naming.new(definitions)
-    @entries = definitions.map { |node, full, folder| entry(node, full, folder) }
   end
 
-  def each(&) = @entries.each(&)
+  def each(&) = entries.each(&)
 
-  def prefix = @naming.segments
+  def prefix = naming.segments
 
-  def strip(path) = @naming.strip(path)
+  def strip(path) = naming.strip(path)
 
   def roots = @definitions.roots
 
@@ -21,7 +19,11 @@ class Hashira::Coupling::Catalog
 
   private
 
+  def naming = @_naming ||= Hashira::Coupling::Naming.new(@definitions)
+
+  def entries = @_entries ||= @definitions.map { |node, full, folder| entry(node, full, folder) }
+
   def entry(node, full, folder)
-    Hashira::Coupling::Definition.new(node:, path: @naming.strip(full), folder:)
+    Hashira::Coupling::Definition.new(node:, path: naming.strip(full), folder:)
   end
 end