hashira 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 574b35721d888046d7d8bbe02129896ebb6305aca89c30127c5372cb855bff74
-  data.tar.gz: ecd9eae0bf5a0cb5baf9b7637401ce0e12afdebcaa7e61e1c3f58b155e16a7bc
+  metadata.gz: 698031b3fff8e705bf80379be16ee05ecacfa9c137459ab8beb855cee1c624dd
+  data.tar.gz: c50d6bc7ee142f665c8764d56d7fdf07de381b00529715e37682aed6f0f1856d
 SHA512:
-  metadata.gz: 5b08c0cb5f567948aa66f6e1e69d5c610b4eeb75811940b7d833e3c08d279372d5d27100c1efa3f0b3917e0f9fbd32d675e7284039e57086044c8e26e7edb509
-  data.tar.gz: 10a1128b98b097b168adbaca6b2c0408a712d992725f5c41d1146fcc43cf975511cbc9dd4dd31a3bc3bfc42b2279906859233f66cde4eada83d96f20f3449aae
+  metadata.gz: 4ce8b38adba57e0d1bdf6343362efb3e205c6455d5634bf3cd07c2b429870423268fc4263215ad3ea767284a7acc906901259acbbec7570d386db7fc0759626b
+  data.tar.gz: 3670d8b067f2535d745c3785d52087f2aa189909511566e8452818da408e82882077fe428a72b16470640f60bddcdcbd0fbc6109fc412d64652648c20b1bcb9c

data/CHANGELOG.md

@@ -5,6 +5,33 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.1] - 2026-08-05
+
+### Fixed
+
+- The churn scan passes `--no-renames` to `git log`, counting a move as a
+  delete plus an add. Rename detection needs blob contents, so on a partial
+  clone (`--filter=blob:none`) the old command lazy-fetched objects from the
+  network one at a time — on a long history the scan stalled for minutes and
+  looked like a hang. It also made the tally depend on which blobs git could
+  see, so the same tree could report different churn (and different
+  findings) run to run. A dogfood run against a large open-source app fell
+  from 3m39s to under 9 seconds.
+- A bare reference to a Ruby core constant (`String`, `Regexp`, `File`, …)
+  no longer couples to whichever package defines a namespaced namesake such
+  as `Sql::Nodes::Regexp` — Ruby would resolve it to the core class, so
+  hashira now drops the edge. The registry answers these through `rooted`,
+  which skips the shorthand tails: a lexical namesake still shadows the core
+  name as Ruby's own lookup does, and a project that reopens the class at
+  top level still owns it. Dogfooding against a large open-source library,
+  this deleted a phantom `mixed_audience` finding built entirely on `Array`,
+  `String`, and `File`.
+- Constants assigned in a class body (`Node = Struct.new(:path)`) now join the
+  census as definitions, so a bare reference resolves to the local constant
+  instead of a foreign package's namesake — a karat run had minted two phantom
+  edges this way. For usage counts they still collapse into their enclosing
+  type: `wide_edge` measures classes, not the constants they carry.
+
 ## [0.5.0] - 2026-08-04
 
 ### Added
@@ -266,6 +293,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Output formats: text, JSON, Graphviz dot, Mermaid (`--format`, `--json`).
 - `--help` and `--version`.
 
+[0.5.1]: https://github.com/giacope/hashira/releases/tag/v0.5.1
 [0.5.0]: https://github.com/giacope/hashira/releases/tag/v0.5.0
 [0.4.0]: https://github.com/giacope/hashira/releases/tag/v0.4.0
 [0.3.0]: https://github.com/giacope/hashira/releases/tag/v0.3.0

data/README.md

@@ -26,11 +26,10 @@ package       TC  Ca  Ce     I  Cyc
 billing        1   1   1  0.50  YES
 shipping       1   1   1  0.50  YES
 
-Findings (2):
-  cycle: billing can reach itself: billing -> shipping -> billing — any change
-  may ripple back around. The lightest edge on this cycle is billing -> shipping (1 ref).
-      · billing/client.rb:3: Shipping::Rate
-      · shipping/rate.rb:3: Billing::Client
+Findings (1):
+  cycle: billing can reach itself: billing -> shipping -> billing — any change may ripple back around. The lightest edge on this cycle is billing -> shipping (1 ref).
+      · billing/client.rb:5: Shipping::Rate
+      · shipping/rate.rb:8: Billing::Client
 ```
 
 A healthy project reports `Findings (0): none ✓ — structure is healthy`.

data/lib/hashira/analysis/syntax.rb

@@ -33,9 +33,13 @@ module Hashira
         roots.include?(segments.first(1)) ? segments : (stack.last || []) + segments
       end
 
-      def direct(type_node)
+      def direct(type_node) = statements(type_node).grep(Prism::DefNode)
+
+      def constants(type_node) = statements(type_node).grep(Prism::ConstantWriteNode)
+
+      def statements(type_node)
         body = type_node.body
-        (body.is_a?(Prism::StatementsNode) ? body.body : [body]).grep(Prism::DefNode)
+        body.is_a?(Prism::StatementsNode) ? body.body : [body]
       end
     end
   end

data/lib/hashira/churn.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Hashira::Churn
-  LOG = "git log --name-only --format= 2>/dev/null"
+  LOG = "git log --no-renames --name-only --format= 2>/dev/null"
   SITES_THAT_DRIFT_APART = 2
 
   def self.scan = new(tally(`#{LOG}`))

data/lib/hashira/cli/command_line.rb

@@ -1,47 +1,30 @@
 # frozen_string_literal: true
 
 class Hashira::CLI::CommandLine
-  DEFAULT_BASELINE = "hashira_baseline.json"
-
-  FORMATS = %w[text json dot mermaid].freeze
-
-  CI_FLAGS = { "--update-baseline" => :update, "--ratchet" => :ratchet }.freeze
-
   def initialize(argv)
     @arguments = Hashira::CLI::Arguments.new(argv)
   end
 
-  def options = shortcuts || parsed
+  def options = page || parsed
 
   private
 
-  def shortcuts
-    return usage(:help) if delete("--help") || delete("-h")
-    usage(:version) if delete("--version")
+  def page
+    flag = Hashira::CLI::FLAGS.select(&:page?).find { seen?(it) }
+    Hashira::CLI::Options.page(flag.mode) if flag
   end
 
-  def usage(mode)
-    Hashira::CLI::Options.new(directories: [], mode:, baseline: nil, fail_on: [], skip: [], packaging: :auto)
-  end
+  def seen?(flag) = flag.names.any? { @arguments.delete(it) }
 
   def parsed
-    values = flags
-    values[:mode] = mode(values[:fail_on])
-    Hashira::CLI::Options.new(directories: @arguments.rest, **values)
+    parses = Hashira::CLI::FLAGS.reject(&:page?).to_h { [it, it.read(@arguments)] }
+    Hashira::CLI::Options.new(directories: @arguments.rest, mode: mode(parses), **fields(parses))
   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 grouping = Hashira::CLI::PackageBy.parse(take("--package-by", ""))
+  def fields(parses) = parses.to_h { |flag, value| [flag.field, value] }.except(nil)
 
-  def mode(fail_on)
-    case (asked = requested(fail_on).uniq(&:last))
+  def mode(parses)
+    case (asked = parses.filter_map { |flag, value| flag.bid(value) }.uniq(&:last))
     in [] then :text
     in [[_flag, mode]] then mode
     else conflict(asked)
@@ -51,26 +34,4 @@ class Hashira::CLI::CommandLine
   def conflict(asked)
     raise(Hashira::Error, "conflicting options: #{asked.map(&:first).join(" and ")}")
   end
-
-  def requested(fail_on)
-    CI_FLAGS.filter_map { |flag, mode| [flag, mode] if delete(flag) } + gate(fail_on) + formats
-  end
-
-  def gate(fail_on) = fail_on.empty? ? [] : [["--fail-on", :fail_on]]
-
-  def formats
-    chosen = format
-    modes = chosen.empty? ? [] : [["--format #{chosen}", chosen.to_sym]]
-    delete("--json") ? modes + [["--json", :json]] : modes
-  end
-
-  def format
-    wanted = take("--format", "")
-    return wanted if wanted.empty? || FORMATS.include?(wanted)
-    raise(Hashira::Error.unknown("--format", wanted, FORMATS))
-  end
-
-  def take(flag, default) = @arguments.take(flag, default)
-
-  def delete(flag) = @arguments.delete(flag)
 end

data/lib/hashira/cli/fail_on.rb

@@ -3,19 +3,13 @@
 require_relative "../pipeline"
 
 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
-
   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" => SMELLS, **SMELLS.to_h { [it, it] }
+    "smells" => Hashira::Pipeline::SMELLS, **Hashira::Pipeline::SMELLS.to_h { [it, it] }
   }.freeze
 
   module_function

data/lib/hashira/cli/flag.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Hashira::CLI
+  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 read(arguments) = arg ? take(arguments) : arguments.delete(name)
+
+      def take(arguments)
+        raw = arguments.take(name, default)
+        parse ? parse.parse(raw) : raw
+      end
+
+      def bid(value)
+        case [mode, value]
+        in [nil, _] | [_, nil] | [_, []] then nil
+        in [:parsed, chosen] then ["#{name} #{chosen}", chosen]
+        else [name, mode]
+        end
+      end
+
+      def label = [name, arg].compact.join(" ")
+
+      def names = name.split(", ")
+
+      def page? = Hashira::CLI::Usage::PAGES.include?(mode)
+    end
+end

data/lib/hashira/cli/flags.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "fail_on"
+require_relative "flag"
+require_relative "format"
+require_relative "package_by"
+require_relative "skip"
+
+class Hashira::CLI
+  FLAGS = [
+    Flag.new(
+      name: "--format", arg: "FORMAT", parse: Format, mode: :parsed,
+      text: ["text (default), json, dot, or mermaid"]
+    ),
+    Flag.new(name: "--json", mode: :json, text: ["shorthand for --format json"]),
+    Flag.new(
+      name: "--fail-on", arg: "KINDS", field: :fail_on, parse: FailOn, mode: :fail_on,
+      text: [
+        "exit 1 if findings exist; comma-separated",
+        "kinds: cycles, sdp, mixed_audience, wide_edge,",
+        "roll_call, complexity, duplication, smells (all",
+        "of them), or one smell kind such as feature_envy"
+      ]
+    ),
+    Flag.new(
+      name: "--skip", arg: "ANALYZERS", field: :skip, parse: Skip,
+      text: ["drop an analyzer; comma-separated: coupling,", "complexity, duplication, smells"]
+    ),
+    Flag.new(
+      name: "--package-by", arg: "WHAT", field: :packaging, parse: PackageBy,
+      text: [
+        "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"
+      ]
+    ),
+    Flag.new(
+      name: "--ratchet", mode: :ratchet,
+      text: ["fail when edges or findings appear that the", "baseline lacks"]
+    ),
+    Flag.new(name: "--update-baseline", mode: :update, text: ["record the current edges and findings"]),
+    Flag.new(
+      name: "--baseline", arg: "PATH", field: :baseline, default: "hashira_baseline.json",
+      text: ["baseline file (default: hashira_baseline.json)"]
+    ),
+    Flag.new(name: "-h, --help", mode: :help, text: ["print this help"]),
+    Flag.new(name: "--version", mode: :version, text: ["print the version"])
+  ].freeze
+end

data/lib/hashira/cli/format.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Hashira::CLI::Format
+  CHOICES = %w[text json dot mermaid].freeze
+
+  module_function
+
+  def parse(value)
+    return if value.empty?
+    return value.to_sym if CHOICES.include?(value)
+    raise(Hashira::Error.unknown("--format", value, CHOICES))
+  end
+end

data/lib/hashira/cli/options.rb

@@ -5,6 +5,8 @@ class Hashira::CLI
     Data.define(:directories, :mode, :baseline, :fail_on, :skip, :packaging) do
       def self.parse(argv) = CommandLine.new(argv).options
 
+      def self.page(mode) = new(directories: [], mode:, baseline: "", fail_on: [], skip: [], packaging: :auto)
+
       def pipeline
         Hashira::Pipeline.new(Hashira::Project.detect(directories), enabled: analyzers, packaging:)
       end

data/lib/hashira/cli/usage.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
+require_relative "flags"
+
 module Hashira::CLI::Usage
-  TEXT = <<~HELP
+  PAGES = %i[help version].freeze
+
+  HEADER = <<~TEXT
     Usage: hashira [DIRECTORY ...] [options]
 
     Coupling, cognitive-complexity, duplication, and code-smell metrics
@@ -9,38 +13,30 @@ module Hashira::CLI::Usage
     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, mixed_audience, wide_edge,
-                           roll_call, complexity, duplication, smells (all
-                           of them), or one smell kind such as feature_envy
-      --skip ANALYZERS     drop an analyzer; comma-separated: coupling,
-                           complexity, duplication, smells
-      --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
+  TEXT
+
+  FOOTER = <<~TEXT
 
     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
+  TEXT
 
   module_function
 
-  def help = emit(TEXT)
+  def help = emit(HEADER + options + FOOTER)
 
   def version = emit("hashira #{Hashira::VERSION}")
 
+  def options = Hashira::CLI::FLAGS.map { rows(it) }.join
+
+  def rows(flag)
+    first, *rest = flag.text
+    ["  #{flag.label.ljust(21)}#{first}\n", *rest.map { "#{" " * 23}#{it}\n" }].join
+  end
+
   def emit(output)
     puts(output)
     0

data/lib/hashira/cli.rb

@@ -8,7 +8,7 @@ class Hashira::CLI
     failure(error)
   end
 
-  def self.usage?(options) = %i[help version].include?(options.mode)
+  def self.usage?(options) = Usage::PAGES.include?(options.mode)
 
   def self.failure(error)
     warn("hashira: #{error.message}")

data/lib/hashira/complexity/method_finding.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
 class Hashira::Complexity::MethodFinding
+  KIND = "complexity"
+
   def initialize(score)
     @score = score
   end
 
   def to_finding
-    Hashira::Analysis::Finding.new(kind: "complexity", package: @score.subject, detail:, evidence:)
+    Hashira::Analysis::Finding.new(kind: KIND, package: @score.subject, detail:, evidence:)
   end
 
   private

data/lib/hashira/coupling/census.rb

@@ -38,7 +38,7 @@ class Hashira::Coupling::Census
 
   private
 
-  def type?(segments) = @roster.origins.key?(segments.join("::"))
+  def type?(segments) = @roster.type?(segments)
 
   def tally
     Hashira::Coupling::Roster.new(@placement.placed.map { |definition, package| [definition, translate(package)] })

data/lib/hashira/coupling/constant_registry.rb

@@ -16,10 +16,9 @@ class Hashira::Coupling::ConstantRegistry
     (1...path.length).each { claim(@shorthand, path.drop(it), package) }
   end
 
-  def package(path)
-    found = anchored(path) || enclosing(path)
-    found unless found == AMBIGUOUS
-  end
+  def package(path) = settle(anchored(path) || enclosing(path))
+
+  def rooted(path) = settle(@origins[path.join("::")] || enclosing(path))
 
   def exact(path) = @origins[path.join("::")]
 
@@ -32,6 +31,8 @@ class Hashira::Coupling::ConstantRegistry
     claims[key] = claims.fetch(key, package) == package ? package : AMBIGUOUS
   end
 
+  def settle(found) = (found unless found == AMBIGUOUS)
+
   def anchored(path)
     key = path.join("::")
     @origins[key] || @shorthand[key]

data/lib/hashira/coupling/definition.rb

@@ -16,7 +16,11 @@ module Hashira
 
         def superclass = node.superclass
 
-        def counted? = klass? || !Hashira::Analysis::Syntax.direct(node).empty?
+        def module? = node.is_a?(Prism::ModuleNode)
+
+        def type? = klass? || module?
+
+        def counted? = klass? || (module? && !Hashira::Analysis::Syntax.direct(node).empty?)
       end
   end
 end

data/lib/hashira/coupling/definitions.rb

@@ -26,6 +26,9 @@ class Hashira::Coupling::Definitions
 
   def scan(file, tree)
     package = @project.package(file)
-    Hashira::Analysis::TypeWalk.each(tree, roots: roots) { |node, full| yield(node, full, package) }
+    Hashira::Analysis::TypeWalk.each(tree, roots: roots) do |node, full|
+      yield(node, full, package)
+      Hashira::Analysis::Syntax.constants(node).each { yield(it, full + [it.name.to_s], package) }
+    end
   end
 end

data/lib/hashira/coupling/roster.rb

@@ -4,6 +4,7 @@ class Hashira::Coupling::Roster
   def initialize(placed)
     @registry = Hashira::Coupling::ConstantRegistry.new
     @types = Hash.new(0)
+    @typed = Set.new
     counted = Set.new
     placed.each { |definition, package| admit(definition, package, counted) }
   end
@@ -12,6 +13,8 @@ class Hashira::Coupling::Roster
 
   def origins = @registry.origins
 
+  def type?(path) = @typed.include?(path)
+
   def packages = @types.keys | @registry.packages
 
   private
@@ -20,6 +23,7 @@ class Hashira::Coupling::Roster
     return unless package
     path = definition.path
     @registry.register(path, package)
+    @typed << path if definition.type?
     @types[package] += 1 if definition.counted? && counted.add?(path)
   end
 end

data/lib/hashira/coupling/scope.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 class Hashira::Coupling::Scope
+  CORE = Object.constants.select { Object.const_source_location(it) == [] }.to_set(&:to_s).freeze
+
   def initialize(registry, catalog, placement)
     @registry = registry
     @catalog = catalog
@@ -10,7 +12,7 @@ class Hashira::Coupling::Scope
   def resolve(segments, nesting)
     return if @placement.skip?(segments)
     scoped = nesting.reverse_each.filter_map { descend(it, segments) }.first
-    scoped ? qualify(scoped) : @registry.package(@catalog.strip(segments))
+    scoped ? qualify(scoped) : outward(@catalog.strip(segments))
   end
 
   def pinpoint(segments)
@@ -20,6 +22,8 @@ class Hashira::Coupling::Scope
 
   private
 
+  def outward(path) = CORE.include?(path.first) ? @registry.rooted(path) : @registry.package(path)
+
   def descend(entry, segments)
     segments.length.downto(1).filter_map { @registry.exact(@catalog.strip(entry + segments.first(it))) }.first
   end

data/lib/hashira/duplication/duplication_finding.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 class Hashira::Duplication::DuplicationFinding
+  KIND = "duplication"
+
   def initialize(cluster, churn)
     @cluster = cluster
     @churn = churn
@@ -8,7 +10,7 @@ class Hashira::Duplication::DuplicationFinding
 
   def to_finding
     site = @cluster.canonical
-    Hashira::Analysis::Finding.new(kind: "duplication", package: site.location, digest: site.digest, detail:, evidence:)
+    Hashira::Analysis::Finding.new(kind: KIND, package: site.location, digest: site.digest, detail:, evidence:)
   end
 
   private

data/lib/hashira/pipeline.rb

@@ -2,12 +2,15 @@
 
 require "prism"
 require_relative "coupling/report"
+require_relative "smells/report"
 
 class Hashira::Pipeline
   ANALYZERS = %i[coupling complexity duplication smells].freeze
 
   STRUCTURAL = Hashira::Coupling::Report::RULES.map { it::KIND }.freeze
 
+  SMELLS = Hashira::Smells::Report::CHECKS.map(&:kind).sort.freeze
+
   def initialize(project, enabled: ANALYZERS, packaging: :auto)
     @project = project
     @enabled = enabled

data/lib/hashira/smells/check.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 class Hashira::Smells::Check
+  def self.kind = name.split("::").last.gsub(/(?<=[a-z])(?=[A-Z])/, "_").downcase
+
+  def self.judge? = false
+
   def initialize(subject)
     @subject = subject
   end
@@ -14,7 +18,7 @@ class Hashira::Smells::Check
 
   attr_reader :subject
 
-  def kind = self.class.name.split("::").last.gsub(/(?<=[a-z])(?=[A-Z])/, "_").downcase
+  def kind = self.class.kind
 
   def label = subject.subject
 

data/lib/hashira/smells/data_clump.rb

@@ -5,6 +5,8 @@ class Hashira::Smells::DataClump < Hashira::Smells::Check
 
   MIN_SIZE = 2
 
+  def self.judge? = true
+
   private
 
   def smelly? = clumps.any?

data/lib/hashira/smells/instance_variable_assumption.rb

@@ -26,6 +26,8 @@ class Hashira::Smells::InstanceVariableAssumption < Hashira::Smells::Check
     end
   end
 
+  def self.judge? = true
+
   private
 
   def smelly? = subject.kind == :class && assumed.any?

data/lib/hashira/smells/module_initialize.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 class Hashira::Smells::ModuleInitialize < Hashira::Smells::Check
+  def self.judge? = true
+
   private
 
   def smelly? = subject.kind == :module && flagged

data/lib/hashira/smells/repeated_conditional.rb

@@ -5,6 +5,8 @@ require "prism"
 class Hashira::Smells::RepeatedConditional < Hashira::Smells::Check
   LIMIT = 2
 
+  def self.judge? = true
+
   private
 
   def smelly? = subject.kind == :class && repeats.any?

data/lib/hashira/smells/report.rb

@@ -1,31 +1,34 @@
 # frozen_string_literal: true
 
+require_relative "check"
+require_relative "control_parameter"
+require_relative "data_clump"
+require_relative "duplicate_method_call"
+require_relative "feature_envy"
+require_relative "instance_variable_assumption"
+require_relative "manual_dispatch"
+require_relative "module_initialize"
+require_relative "nil_check"
+require_relative "repeated_conditional"
+require_relative "too_many_instance_variables"
+require_relative "utility_function"
+
 class Hashira::Smells::Report
+  CHECKS = Hashira::Smells::Check.subclasses.sort_by(&:name).freeze
+
+  JUDGES = CHECKS.select(&:judge?).freeze
+
+  PROBES = CHECKS.reject(&:judge?).freeze
+
   def initialize(project, trees)
     @types = Hashira::Smells::Census.new(project, trees).types
   end
 
-  def findings = @findings ||= sniff(@types, judges) + sniff(@types.flat_map(&:defs), probes)
+  def findings = @findings ||= sniff(@types, JUDGES) + sniff(@types.flat_map(&:defs), PROBES)
 
   private
 
   def sniff(subjects, checks) = subjects.flat_map { |subject| verdicts(subject, checks) }
 
   def verdicts(subject, checks) = checks.filter_map { |check| check.new(subject).finding }
-
-  def judges
-    [
-      Hashira::Smells::DataClump, Hashira::Smells::InstanceVariableAssumption,
-      Hashira::Smells::ModuleInitialize, Hashira::Smells::RepeatedConditional,
-      Hashira::Smells::TooManyInstanceVariables
-    ]
-  end
-
-  def probes
-    [
-      Hashira::Smells::ControlParameter, Hashira::Smells::DuplicateMethodCall,
-      Hashira::Smells::FeatureEnvy, Hashira::Smells::ManualDispatch,
-      Hashira::Smells::NilCheck, Hashira::Smells::UtilityFunction
-    ]
-  end
 end

data/lib/hashira/smells/too_many_instance_variables.rb

@@ -10,6 +10,8 @@ class Hashira::Smells::TooManyInstanceVariables < Hashira::Smells::Check
     Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableTargetNode
   ].freeze
 
+  def self.judge? = true
+
   private
 
   def smelly? = subject.kind == :class && names.size > LIMIT

data/lib/hashira/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hashira
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

data/lib/hashira.rb

@@ -47,6 +47,9 @@ require_relative "hashira/cli"
 require_relative "hashira/cli/arguments"
 require_relative "hashira/cli/command_line"
 require_relative "hashira/cli/fail_on"
+require_relative "hashira/cli/flag"
+require_relative "hashira/cli/flags"
+require_relative "hashira/cli/format"
 require_relative "hashira/cli/options"
 require_relative "hashira/cli/package_by"
 require_relative "hashira/cli/run"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hashira
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Giacomo GK
@@ -44,6 +44,9 @@ files:
 - lib/hashira/cli/arguments.rb
 - lib/hashira/cli/command_line.rb
 - lib/hashira/cli/fail_on.rb
+- lib/hashira/cli/flag.rb
+- lib/hashira/cli/flags.rb
+- lib/hashira/cli/format.rb
 - lib/hashira/cli/options.rb
 - lib/hashira/cli/package_by.rb
 - lib/hashira/cli/run.rb