hashira 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 574b35721d888046d7d8bbe02129896ebb6305aca89c30127c5372cb855bff74
-  data.tar.gz: ecd9eae0bf5a0cb5baf9b7637401ce0e12afdebcaa7e61e1c3f58b155e16a7bc
+  metadata.gz: a0b871ab3e0bf096a2752a48a4c3776d2dbe2ee0cae33b2df8af89649d0952ca
+  data.tar.gz: b1058810a8d965e1010044691d1b11571f21b077581f5e435d40b0d263f133b9
 SHA512:
-  metadata.gz: 5b08c0cb5f567948aa66f6e1e69d5c610b4eeb75811940b7d833e3c08d279372d5d27100c1efa3f0b3917e0f9fbd32d675e7284039e57086044c8e26e7edb509
-  data.tar.gz: 10a1128b98b097b168adbaca6b2c0408a712d992725f5c41d1146fcc43cf975511cbc9dd4dd31a3bc3bfc42b2279906859233f66cde4eada83d96f20f3449aae
+  metadata.gz: 24d9aae54c58e39a54799efdf9749f501000162c8ea8f9a38e02523fb6ee3122a98daf6591cfaf7816f3a2cd66f20218c08ff27579bc1b58a269e4ce7bddda92
+  data.tar.gz: 158bf3af24e081df3483e3d124833f6943404cfdab6ca1f2f7235115a400cfb1c48f885fb16b290fc529ebc1556c8eb5ed97119f635c9869ae881b44be51c599

data/CHANGELOG.md

@@ -5,6 +5,63 @@ 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.6.0] - 2026-08-05
+
+### Changed
+
+- **feature_envy now respects ownership.** The classic remedy — move the
+  method onto the envied object — assumes the envied class is yours to edit.
+  The smell now stays quiet when the method body itself proves otherwise:
+  the name is type-guarded only against constants the analyzed code never
+  defines (`node.is_a?(Prism::CallNode)`); every call on it is a literal-key
+  read (`msg["id"]`, `values_at`, `dig`, `key?` — wire data, not an object);
+  it was built from a literal in the method itself (`options = { ... }`); it
+  was derived by calling a foreign name or foreign constant
+  (`value = node.unescaped`, `app = Rails.application`); it was rescued from
+  a foreign or implied error class (`rescue => e`); the method dispatches on
+  it through a constant table keyed entirely by foreign classes
+  (`TABLE[node.class]`); or the method is a stateless converter whose last
+  act is building a typed object. Guards against types the codebase does
+  define — including by suffix, and including subclasses of gem classes —
+  still flag, as do rescues from error classes the codebase defines and
+  tables keyed by owned classes, so anemic-model envy in Rails apps is
+  untouched.
+
+### Added
+
+- **boundary_sprawl** — the aggregate the suppression above makes room for:
+  when 12+ methods across 3+ files each type-guard against the same foreign
+  root (`Prism`, `ActiveRecord`, ...), one finding proposes fronting that
+  boundary with an adapter. One method inspecting a foreign type is a fact of
+  life; a codebase-wide sprawl of them is a missing seam.
+
+## [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 +323,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`.
@@ -295,7 +294,7 @@ it does inside Ruby:
 ## Code smells
 
 RuboCop counts lines and branches inside one method; design smells are about how
-objects treat each other, and no line count sees that. hashira ships the eleven
+objects treat each other, and no line count sees that. hashira ships the twelve
 smells that carry that design signal — the object-relationship kinds, not the
 naming, size, and style checks a linter already argues about — read from the
 same parse trees the other analyzers already built:
@@ -311,7 +310,16 @@ Findings (2):
 What each one catches:
 
 - **feature_envy** — a method refers to another object more than to itself; the
-  behavior probably belongs over there.
+  behavior probably belongs over there. Stays quiet when the method's own body
+  proves the envied thing is foreign — type-guarded (or table-dispatched) only
+  against constants the codebase never defines, read purely through literal
+  keys (`msg["id"]`), built from a literal or derived from a foreign call in
+  the method itself, rescued from a foreign error class, or consumed by a
+  stateless converter that ends by building a typed object — because "move
+  the method" needs a destination you own.
+- **boundary_sprawl** — 12+ methods across 3+ files each type-guard against the
+  same foreign root (`Prism`, `ActiveRecord`, ...). One method inspecting a
+  foreign type is a fact of life; a sprawl of them is a missing adapter.
 - **utility_function** — a public instance method that touches no instance state;
   it isn't really a method of this class. Private stateless helpers are fine, and
   `module_function` modules are exempt — that's what they're for.
@@ -335,7 +343,7 @@ What each one catches:
   cheapest type there is.
 
 Smell findings gate and ratchet like every other kind — `--fail-on smells` covers
-all eleven, or name one (`--fail-on feature_envy`); `--skip smells` drops the
+all twelve, or name one (`--fail-on feature_envy`); `--skip smells` drops the
 analyzer entirely.
 
 ## Hotspots

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,17 @@
 
 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) + [Hashira::Smells::BoundarySprawl::KIND]
+  ).sort.freeze
+
   def initialize(project, enabled: ANALYZERS, packaging: :auto)
     @project = project
     @enabled = enabled

data/lib/hashira/report/smell_phrases.rb

@@ -19,6 +19,12 @@ module Hashira::Report::Phrases
       "Name the result in a local variable."
   end
 
+  def on_boundary_sprawl(finding)
+    detail = finding.detail
+    "#{detail[:count]} methods across #{detail[:files]} files each pick apart #{finding.package}'s " \
+      "internals. Front the boundary with one adapter the rest can lean on."
+  end
+
   def on_feature_envy(finding)
     detail = finding.detail
     names = detail[:names]

data/lib/hashira/smells/boundary_sprawl.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class Hashira::Smells::BoundarySprawl
+  KIND = "boundary_sprawl"
+
+  METHOD_FLOOR = 12
+
+  FILE_FLOOR = 3
+
+  SHOWN = 4
+
+  def initialize(subjects, ownership)
+    @subjects = subjects
+    @ownership = ownership
+  end
+
+  def findings
+    reaches.filter_map { |root, contexts| finding(root, contexts) }
+  end
+
+  private
+
+  def reaches
+    @subjects.each_with_object({}) do |subject, map|
+      Hashira::Smells::Foreign.new(subject, @ownership).reaches.each { (map[it] ||= []) << subject }
+    end
+  end
+
+  def finding(root, contexts)
+    files = contexts.map(&:file).uniq
+    build(root, contexts, files) if wide?(contexts.size, files.size)
+  end
+
+  def wide?(methods, files) = methods >= METHOD_FLOOR && files >= FILE_FLOOR
+
+  def build(root, contexts, files)
+    Hashira::Analysis::Finding.new(
+      kind: KIND, package: root,
+      detail: { count: contexts.size, files: files.size },
+      evidence: contexts.first(SHOWN).map(&:site)
+    )
+  end
+end

data/lib/hashira/smells/census.rb

@@ -6,8 +6,11 @@ class Hashira::Smells::Census
   def initialize(project, trees)
     @project = project
     @trees = trees
+    @ownership = Hashira::Smells::Ownership.new(trees.values)
   end
 
+  attr_reader :ownership
+
   def types = @trees.flat_map { |path, tree| harvest(@project.relative(path), tree) }
 
   private
@@ -26,7 +29,7 @@ class Hashira::Smells::Census
 
   def defs(name, node, file)
     Hashira::Smells::Visibility.new(node).entries.map do |def_node, section|
-      Hashira::Smells::MethodContext.new(owner: name, node: def_node, file:, section:)
+      Hashira::Smells::MethodContext.new(owner: name, node: def_node, file:, section:, ownership: @ownership)
     end
   end
 end

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/contexts.rb

@@ -32,7 +32,7 @@ module Hashira
     end
 
     MethodContext =
-      Data.define(:owner, :node, :file, :section) do
+      Data.define(:owner, :node, :file, :section, :ownership) do
         def subject = "#{owner}#{singleton? ? "." : "#"}#{node.name}"
 
         def line = node.location.start_line

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/feature_envy.rb

@@ -9,7 +9,9 @@ class Hashira::Smells::FeatureEnvy < Hashira::Smells::Check
 
   def refs = @refs ||= Hashira::Smells::Refs.new(subject.node)
 
-  def envied = @envied ||= refs.envious
+  def envied = @envied ||= refs.envious.reject { foreign.dismiss?(it) }
+
+  def foreign = @foreign ||= Hashira::Smells::Foreign.new(subject, subject.ownership)
 
   def detail = { site:, names: envied }
 

data/lib/hashira/smells/foreign.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Smells::Foreign
+  TYPE_TESTS = %i[is_a? kind_of? instance_of?].freeze
+
+  KEYED_READS = %i[[] fetch values_at dig key?].freeze
+
+  KEYS = [Prism::StringNode, Prism::SymbolNode].freeze
+
+  LITERALS = [Prism::HashNode, Prism::KeywordHashNode, Prism::ArrayNode, Prism::StringNode].freeze
+
+  STATE = [
+    Prism::InstanceVariableReadNode, Prism::InstanceVariableWriteNode,
+    Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableAndWriteNode,
+    Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableTargetNode
+  ].freeze
+
+  def initialize(subject, ownership)
+    node = subject.node
+    @body = Hashira::Smells::Scope.inside(node)
+    @tail = tail(node)
+    @ownership = ownership
+  end
+
+  def dismiss?(name)
+    convert? || fenced?(name) || wire?(name) || built?(name) ||
+      derived?(name) || rescued?(name)
+  end
+
+  def reaches
+    tests { true }.reject { @ownership.owned?(it) }.map(&:first).uniq
+  end
+
+  private
+
+  def convert?
+    @tail.is_a?(Prism::CallNode) && @tail.name == :new &&
+      Hashira::Analysis::Syntax.segments(@tail.receiver).any? && stateless?
+  end
+
+  def stateless? = @body.none? { STATE.include?(it.class) }
+
+  def fenced?(name)
+    tested = tests { it == name }
+    tested.any? && tested.none? { @ownership.owned?(it) }
+  end
+
+  def wire?(name)
+    calls = @body.grep(Prism::CallNode).select { |call| local?(call.receiver) { it == name } }
+    calls.any? && calls.all? { keyed?(it) } && reassignments(name).none?
+  end
+
+  def built?(name)
+    writes(name).any? { LITERALS.include?(it.value.class) }
+  end
+
+  def derived?(name)
+    writes(name).any? { spawned?(it.value) }
+  end
+
+  def rescued?(name)
+    snares(name).any? { alien?(it.exceptions) }
+  end
+
+  def keyed?(call)
+    names = call.arguments&.arguments
+    KEYED_READS.include?(call.name) && names&.any? &&
+      names.all? { KEYS.include?(it.class) }
+  end
+
+  def writes(name) = among(Prism::LocalVariableWriteNode, name)
+
+  def reassignments(name) = among(Prism::LocalVariableOperatorWriteNode, name)
+
+  def among(kind, name)
+    @body.grep(kind).select { it.name == name }
+  end
+
+  def snares(name)
+    @body.grep(Prism::RescueNode).select { it.reference&.name == name }
+  end
+
+  def alien?(exceptions)
+    exceptions.map { Hashira::Analysis::Syntax.segments(it) }.none? { @ownership.owned?(it) }
+  end
+
+  def spawned?(value)
+    value.is_a?(Prism::CallNode) && stranger?(value.receiver)
+  end
+
+  def stranger?(node)
+    case node
+    when Prism::LocalVariableReadNode then fenced?(node.name)
+    when Prism::ConstantReadNode, Prism::ConstantPathNode then unowned?(node)
+    else false
+    end
+  end
+
+  def unowned?(node)
+    !@ownership.owned?(Hashira::Analysis::Syntax.segments(node))
+  end
+
+  def tests(&)
+    (probes(&) + arms(&)).map { Hashira::Analysis::Syntax.segments(it) }.reject(&:empty?) + lookups(&)
+  end
+
+  def probes(&)
+    @body.grep(Prism::CallNode).select { TYPE_TESTS.include?(it.name) && local?(it.receiver, &) }.filter_map { key(it) }
+  end
+
+  def arms(&)
+    @body.grep(Prism::CaseNode).select { local?(it.predicate, &) }.flat_map(&:conditions).flat_map(&:conditions)
+  end
+
+  def lookups(&)
+    @body.grep(Prism::CallNode).select { it.name == :[] && sorts?(key(it), &) }.flat_map { @ownership.keys(Hashira::Analysis::Syntax.segments(it.receiver)) }
+  end
+
+  def sorts?(argument, &)
+    argument.is_a?(Prism::CallNode) && argument.name == :class &&
+      local?(argument.receiver, &)
+  end
+
+  def local?(node, &) = node.is_a?(Prism::LocalVariableReadNode) && yield(node.name)
+
+  def key(call) = call.arguments&.arguments&.first
+
+  def tail(def_node) = Hashira::Analysis::Syntax.statements(def_node).compact.last
+end

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/ownership.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class Hashira::Smells::Ownership
+  def initialize(trees)
+    @suffixes = Set.new
+    @tables = {}
+    trees.each { survey(it) }
+  end
+
+  def owned?(segments) = @suffixes.include?(segments.join("::"))
+
+  def keys(segments) = @tables.fetch(segments.join("::"), [])
+
+  private
+
+  def survey(tree)
+    Hashira::Analysis::TypeWalk.each(tree) do |node, full|
+      absorb(full)
+      Hashira::Analysis::Syntax.constants(node).each { record(full, it) }
+    end
+  end
+
+  def record(full, constant)
+    path = full + [constant.name.to_s]
+    absorb(path)
+    chart(path, thaw(constant.value))
+  end
+
+  def absorb(path)
+    @suffixes.merge(suffixes(path))
+  end
+
+  def chart(path, value)
+    return unless value.is_a?(Prism::HashNode)
+    keys = value.elements.map { spine(it) }
+    return if keys.empty? || keys.any?(&:nil?)
+    suffixes(path).each { @tables[it] = keys }
+  end
+
+  def thaw(value)
+    frozen?(value) ? value.receiver : value
+  end
+
+  def frozen?(value) = value.is_a?(Prism::CallNode) && value.name == :freeze
+
+  def spine(element)
+    return unless element.is_a?(Prism::AssocNode)
+    segments = Hashira::Analysis::Syntax.segments(element.key)
+    segments unless segments.empty?
+  end
+
+  def suffixes(path)
+    path.each_index.map { path.drop(it).join("::") }
+  end
+end

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,42 @@
 # frozen_string_literal: true
 
+require_relative "boundary_sprawl"
+require_relative "check"
+require_relative "control_parameter"
+require_relative "data_clump"
+require_relative "duplicate_method_call"
+require_relative "feature_envy"
+require_relative "foreign"
+require_relative "instance_variable_assumption"
+require_relative "manual_dispatch"
+require_relative "module_initialize"
+require_relative "nil_check"
+require_relative "ownership"
+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
+    @census = Hashira::Smells::Census.new(project, trees)
+    @types = @census.types
   end
 
-  def findings = @findings ||= sniff(@types, judges) + sniff(@types.flat_map(&:defs), probes)
+  def findings = @findings ||= sniff(@types, JUDGES) + sniff(methods, PROBES) + sprawl
 
   private
 
-  def sniff(subjects, checks) = subjects.flat_map { |subject| verdicts(subject, checks) }
+  def methods = @types.flat_map(&:defs)
 
-  def verdicts(subject, checks) = checks.filter_map { |check| check.new(subject).finding }
+  def sprawl = Hashira::Smells::BoundarySprawl.new(methods, @census.ownership).findings
 
-  def judges
-    [
-      Hashira::Smells::DataClump, Hashira::Smells::InstanceVariableAssumption,
-      Hashira::Smells::ModuleInitialize, Hashira::Smells::RepeatedConditional,
-      Hashira::Smells::TooManyInstanceVariables
-    ]
-  end
+  def sniff(subjects, checks) = subjects.flat_map { |subject| verdicts(subject, checks) }
 
-  def probes
-    [
-      Hashira::Smells::ControlParameter, Hashira::Smells::DuplicateMethodCall,
-      Hashira::Smells::FeatureEnvy, Hashira::Smells::ManualDispatch,
-      Hashira::Smells::NilCheck, Hashira::Smells::UtilityFunction
-    ]
-  end
+  def verdicts(subject, checks) = checks.filter_map { |check| check.new(subject).finding }
 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.6.0"
 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.6.0
 platform: ruby
 authors:
 - Giacomo GK
@@ -10,10 +10,10 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: Measures package coupling (Ca/Ce/instability, SDP violations, cycles),
-  per-method cognitive complexity, and near-miss code duplication in a Ruby codebase
-  from the AST, then ranks files by cost against git churn. Findings are backed by
-  file-level evidence, and a baseline ratchets edges and findings for CI — direction,
-  not a score.
+  per-method cognitive complexity, near-miss code duplication, and twelve design smells
+  in a Ruby codebase from the AST, then ranks files by cost against git churn. Findings
+  are backed by file-level evidence, and a baseline ratchets edges and findings for
+  CI — direction, not a score.
 email:
 - giaco@hey.com
 executables:
@@ -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
@@ -123,6 +126,7 @@ files:
 - lib/hashira/report/smell_phrases.rb
 - lib/hashira/report/text.rb
 - lib/hashira/report/view.rb
+- lib/hashira/smells/boundary_sprawl.rb
 - lib/hashira/smells/census.rb
 - lib/hashira/smells/check.rb
 - lib/hashira/smells/conditions.rb
@@ -131,10 +135,12 @@ files:
 - lib/hashira/smells/data_clump.rb
 - lib/hashira/smells/duplicate_method_call.rb
 - lib/hashira/smells/feature_envy.rb
+- lib/hashira/smells/foreign.rb
 - lib/hashira/smells/instance_variable_assumption.rb
 - lib/hashira/smells/manual_dispatch.rb
 - lib/hashira/smells/module_initialize.rb
 - lib/hashira/smells/nil_check.rb
+- lib/hashira/smells/ownership.rb
 - lib/hashira/smells/param_check.rb
 - lib/hashira/smells/refs.rb
 - lib/hashira/smells/repeated_conditional.rb
@@ -168,5 +174,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.17
 specification_version: 4
-summary: Coupling, cognitive-complexity, and duplication metrics for Ruby, via Prism
+summary: Coupling, cognitive-complexity, duplication and code-smell metrics for Ruby,
+  via Prism
 test_files: []