hashira 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b806d4d5704515b3371235d38cdd4e60a0c37b98194c91922d57a8f5c448ffab
-  data.tar.gz: 774766f13fa3b820557cb613e9d9b0c7ffcca2d220c30611562d1467a21f142b
+  metadata.gz: 574b35721d888046d7d8bbe02129896ebb6305aca89c30127c5372cb855bff74
+  data.tar.gz: ecd9eae0bf5a0cb5baf9b7637401ce0e12afdebcaa7e61e1c3f58b155e16a7bc
 SHA512:
-  metadata.gz: 8bd5fc6feb807c1255adec14ee18405842a7125dbb4d661c777f85454a831f357484090d90ef39cdc2e1d854df037f61147ede6ef1dfa1854b945bfbb27cd686
-  data.tar.gz: c853f3b158e0a1e501aeb48333c793eb92fcf0e51c9dabbdd538e643889dfd36141c1bfacfcd8bbebc03934cb0ec96690508cd7747cea99fb4b3e081b1aca4b9
+  metadata.gz: 5b08c0cb5f567948aa66f6e1e69d5c610b4eeb75811940b7d833e3c08d279372d5d27100c1efa3f0b3917e0f9fbd32d675e7284039e57086044c8e26e7edb509
+  data.tar.gz: 10a1128b98b097b168adbaca6b2c0408a712d992725f5c41d1146fcc43cf975511cbc9dd4dd31a3bc3bfc42b2279906859233f66cde4eada83d96f20f3449aae

data/CHANGELOG.md

@@ -5,6 +5,159 @@ 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.0] - 2026-08-04
+
+### Added
+
+- `wide_edge` coupling finding: an edge carrying five or more distinct
+  constants is an interface with that many reasons to change — front the
+  target with one facade. Found from the same constant-level usage data as
+  `mixed_audience`. Its first run flagged the pipeline's own five-constant
+  reach into `coupling`, dissolved by the new `Coupling::Report` facade.
+- `roll_call` coupling finding: a list of three or more words (symbols or
+  string keys in array and hash literals) maintained by hand in three or more
+  files across two or more packages is a registry in disguise. Its first run
+  flagged the analyzer names synced between the pipeline, `--fail-on`, and the
+  JSON report — dissolved by deriving `--fail-on` kinds from
+  `Pipeline::ANALYZERS` and the coupling rule roster.
+- `Hashira/ProsePlacement` cop: sentence-length string literals are presentation
+  and belong under `report/` or `ci/` — domain classes pass data. All finding
+  messages now render in `Report::Phrases` from structured `Finding#detail`;
+  `Finding` no longer carries a `message` member (the JSON report still emits
+  a phrased `message` per finding).
+- Coverage floors raised to 100% line and 100% branch — and CI now gates
+  `wide_edge` and `roll_call` alongside cycles, SDP, and mixed audiences.
+
+- `mixed_audience` coupling finding: a package whose constants split into
+  parts with disjoint client bases — one set of packages leaning on one slice,
+  another set on another — is separate packages in disguise. Detected from
+  constant-level inbound references: clients whose touched constants overlap
+  merge into one audience; constants used by a strict majority of clients are
+  set aside as the shared base layer; two or more remaining parts of at least
+  two constants each name the seam. Gate with `--fail-on mixed_audience`.
+  Hashira's first run on itself flagged its own oldest namespace, `analysis` —
+  and the split below dissolved it.
+
+### Changed
+
+- **Breaking:** the coupling machinery moved out of `Hashira::Analysis` into
+  `Hashira::Coupling` (`Graph`, `Census`, `Cycles`, the structural findings,
+  packaging and resolution), matching the `--skip coupling` analyzer name.
+  `Hashira::Analysis` now holds only the substrate every analyzer shares:
+  `Syntax`, `NodeWalk`, `TypeWalk`, and `Finding`. Exactly the seam the new
+  `mixed_audience` finding pointed at; hashira now gates itself with
+  `--fail-on cycles,sdp,mixed_audience` and an empty-findings baseline.
+
+## [0.4.0] - 2026-08-02
+
+### Added
+
+- Code smells analyzer: eleven design smells — the object-relationship kinds
+  no line count sees —
+  `control_parameter`, `data_clump`, `duplicate_method_call`, `feature_envy`,
+  `instance_variable_assumption`, `manual_dispatch`, `module_initialize`,
+  `nil_check`, `repeated_conditional`, `too_many_instance_variables`, and
+  `utility_function` — reported as findings with file:line evidence, gated and
+  ratcheted like every other kind. On by default; `--skip smells` drops the
+  analyzer; `--fail-on smells` gates all eleven, or name a single kind
+  (`--fail-on feature_envy`). `@x ||=` memoization counts neither as class
+  state nor as an ivar assumption, `module_function` methods are exempt, and
+  `utility_function` flags public instance methods only. Methods born inside
+  blocks or `class << self` are seen like any other, and safe navigation
+  counts wherever a plain call would.
+
+- Rails awareness. A directory with `config/application.rb` inside it (the
+  Rails root) or beside it (its `app` folder) is detected as a Rails app:
+  coupling defaults to namespace packaging, and under namespace packaging
+  references to app-defined `Application*` base classes (`ApplicationRecord`,
+  `ApplicationJob`, `ApplicationSerializer`, `ApplicationPolicy`, …) are
+  skipped as framework plumbing. An explicit `--package-by folder` keeps the
+  full legacy edge set, `Application*` references included.
+- Baselines record their packaging mode (schema v3; older baselines read as
+  folder). `--ratchet` refuses a baseline recorded under another mode with
+  instructions to rerun with `--package-by <recorded>` or refresh via
+  `--update-baseline`, instead of failing every edge as drift after the
+  Rails default flips packaging.
+- `--package-by folder|namespace`. Namespace packaging groups types by
+  top-level constant (`Billing`, `Ci`, `User`) across layer folders, so the
+  coupling tables and findings answer the domain question — does `Billing`
+  reach into `Ci`? — instead of restating Rails layout (`models -> jobs`).
+  Folder packaging stays the default outside Rails and remains available
+  everywhere via the flag.
+
+### Changed
+
+- **Breaking (Ruby API only; the CLI is unchanged.)** Names throughout the
+  library are now single-word, following rubocop-elegant: `Graph#dependents_of`
+  is `#incoming`, `Graph#edge_list` is `#edges`, `Project#package_for` is
+  `#package`, `Churn.from_git` is `Churn.scan`, and `Similarity#at_least?` is
+  `#meets?`. Cycle queries moved off `Graph` onto `Graph#cycles`:
+  `graph.cyclic?(p)`, `graph.cycle(p)`, and `graph.weakest(path)` are now
+  `graph.cycles.through?(p)`, `graph.cycles.path(p)`, and
+  `graph.cycles.weakest(path)`.
+- One cycle finding per distinct loop, reported from its smallest member,
+  instead of one per participating package.
+- Under namespace packaging, a top-level class that anchors no namespace of
+  its own and inherits from an app-defined class folds into its base's
+  package, transitively — a flat family of notification subclasses reports
+  as one package, not twenty.
+- Past 25 rows, the metrics table hides single-type packages with no
+  outgoing edges and at most one incoming behind a count line; they stay in
+  the graph, so their afferent weight still counts. A heavily depended-upon
+  package (high Ca) always keeps its row — its stability is the point of
+  the table.
+- Under namespace packaging in a Rails app, a singleton class named by
+  convention (`SandboxResource`, `UserSerializer`, `AccountPolicy`,
+  `PlanDecorator`) folds into its domain's package when that package exists;
+  an app-defined superclass still takes precedence over the name.
+- Every fold is disclosed: a `Folded` list under the coupling tables and a
+  `folds` array in `--json`, each entry naming the fold and whether it came
+  from a base class or a naming suffix.
+- Classes count toward TC even when their body is pure DSL (Alba resources,
+  notifiers); only modules still need a directly defined method.
+
+### Fixed
+
+- References into `Application*` namespaces (`ApplicationCable::Channel`)
+  are skipped in Rails apps like the bases themselves, and no longer pull
+  channels into a plumbing package.
+- A proper prefix of a reference only matches exact definition paths: with
+  an app-defined `Billing::Stripe`, the gem constant `Stripe::RateLimitError`
+  no longer resolves to `Billing` when `RateLimitError` is unknown.
+  Whole-reference suffix shorthand is untouched.
+- Constants resolve through their lexical nesting, like Ruby. A bare
+  `Authentication` inside `class User` now resolves to `User::Authentication`
+  before a top-level `Authentication` in another package, superclasses
+  resolve in the enclosing scope (but are charged to the class they define),
+  and a scoped hit claimed by several packages resolves to nothing rather
+  than falling through to a namesake. Kills phantom cross-package edges in
+  Rails apps, where nested concerns routinely shadow top-level names.
+- `::`-anchored references resolve at top level only, like Ruby: `::User`
+  inside `module Admin` binds to the top-level `User`, never a nested
+  `Admin::User` namesake.
+- A constant under a namespaced class (`Invoice::STATES` with
+  `Admin::Invoice` defined, referenced inside `Admin`) resolves through the
+  enclosing scope by longest registered prefix, so the edge to the class's
+  package is kept.
+- A compact reopen (`class Foo::Bar` inside `module Baz`) anchors its root
+  like Ruby — innermost enclosing scope that defines it, else top level —
+  so its types and references are charged to `Foo`, not `Baz`.
+- A class reopened across files counts once toward TC, and a lone subclass
+  reopened in a later-sorting file keeps its base fold; fold results no
+  longer depend on file order.
+- Mutually-linked folds (a base fold one way, a suffix fold the other)
+  merge into one package instead of swapping the two packages' identities,
+  and a fold link from a package to itself is dropped instead of being
+  disclosed as `X -> X`.
+- A superclass resolves only against registered definition paths: a bare
+  `Base` no longer folds its subclass into an unrelated `Admin::Base`
+  matched by suffix shorthand.
+- Namespace-prefix inference votes with every distinct definition path and
+  requires a wrapper to enclose all of them, so a domain namespace sharing
+  a single folder with top-level classes is kept as a package instead of
+  being stripped as a gem wrapper.
+- `--package-by auto` is accepted as the explicit spelling of the default.
+
 ## [0.3.0] - 2026-07-26
 
 ### Changed
@@ -113,6 +266,8 @@ 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.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
 [0.2.0]: https://github.com/giacope/hashira/releases/tag/v0.2.0
 [0.1.0]: https://github.com/giacope/hashira/releases/tag/v0.1.0

data/README.md

@@ -1,17 +1,17 @@
 # hashira
 
-🏛️ **Coupling, cognitive-complexity and duplication metrics for Ruby, read straight from the AST via [Prism](https://github.com/ruby/prism).**
+🏛️ **Coupling, cognitive-complexity, duplication and code-smell metrics for Ruby, read straight from the AST via [Prism](https://github.com/ruby/prism).**
 
-hashira tells you which file to open first. It reads a Ruby codebase three ways —
-which packages depend on which, how hard each method is to follow, and what has been
-copy-pasted — then ranks every file by what it costs you against how often you
-actually change it. Every finding names the file and line behind it, and a committed
+hashira tells you which file to open first. It reads a Ruby codebase four ways —
+which packages depend on which, how hard each method is to follow, what has been
+copy-pasted, and which objects handle each other's data — then ranks every file by
+what it costs you against how often you actually change it. Every finding names the file and line behind it, and a committed
 baseline ratchets the whole set in CI, so the build fails on what *this commit* made
 worse rather than on a score nobody agrees on.
 
 - **Zero runtime dependencies.** Prism ships with Ruby 3.4+; nothing else to install.
 - **Reads the AST, never strings.** Every signal comes from the parse tree. Comments and string literals are invisible.
-- **Three analyzers, opt-out.** Coupling, complexity, and duplication run together by default; `--skip` drops any.
+- **Four analyzers, opt-out.** Coupling, complexity, duplication, and smells run together by default; `--skip` drops any.
 - **Ranked, not graded.** The hotspot rollup orders files by cost × churn — a work queue, not a letter that reads the same on every healthy repo.
 - **Findings, not just a dashboard.** Cycles, SDP violations, complexity hotspots, and clone clusters — each backed by file-level evidence and a plain-language fix.
 - **Made for CI.** Ratchet edges *and* findings against a baseline, so no clean slate is required. Or gate outright with `--fail-on`.
@@ -39,7 +39,7 @@ A healthy project reports `Findings (0): none ✓ — structure is healthy`.
 
 ## Contents
 
-[Install](#install) · [Getting started](#getting-started) · [Coupling: how to read the numbers](#coupling-how-to-read-the-numbers) · [Cognitive complexity](#cognitive-complexity) · [Duplication](#duplication) · [Hotspots](#hotspots) · [How it works](#how-it-works) · [CI](#ci) · [Other formats](#other-formats) · [Why cognitive complexity](#why-cognitive-complexity) · [Why no A, D, or zones](#why-no-a-d-or-zones)
+[Install](#install) · [Getting started](#getting-started) · [Coupling: how to read the numbers](#coupling-how-to-read-the-numbers) · [Rails apps](#rails-apps) · [Cognitive complexity](#cognitive-complexity) · [Duplication](#duplication) · [Code smells](#code-smells) · [Hotspots](#hotspots) · [How it works](#how-it-works) · [CI](#ci) · [Other formats](#other-formats) · [Why cognitive complexity](#why-cognitive-complexity) · [Why no A, D, or zones](#why-no-a-d-or-zones)
 
 ## Install
 
@@ -83,25 +83,28 @@ hashira's own source:
 
 ```console
 $ hashira
-Package (layer) metrics for lib/hashira  (9 packages, 75 files)
+Package (layer) metrics for lib/hashira  (11 packages, 111 files)
 
 package       TC  Ca  Ce     I  Cyc
 ----------------------------------------
-analysis      14   3   0  0.00  -
+analysis       3   4   0  0.00  -
 diagram        3   1   0  0.00  -
 hotspots       1   1   0  0.00  -
 duplication   14   2   1  0.33  -
 report         8   2   1  0.33  -
+ci             8   1   1  0.50  -
 complexity     7   1   1  0.50  -
-(root)         3   2   4  0.67  -
-ci             8   1   2  0.67  -
-cli            6   0   4  1.00  -
+coupling      24   1   1  0.50  -
+smells        21   1   1  0.50  -
+(root)         4   1   5  0.83  -
+cli            8   0   4  1.00  -
 
 Legend: TC total types, Ca afferent (incoming), Ce efferent (outgoing),
         I=Ce/(Ce+Ca) instability (0=maximally stable, 1=maximally unstable)
 
 Dependencies (DependsUpon(refs) -> | <- UsedBy):
-  (root)       -> analysis(4), complexity(1), duplication(1), hotspots(1) <- ci, cli
+  (root)       -> complexity(1), coupling(5), duplication(1), hotspots(1), smells(1) <- cli
+  analysis     -> (none)                           <- complexity, coupling, duplication, smells
   duplication  -> analysis(3)                      <- (root), report
   ...
 
@@ -109,27 +112,27 @@ Cognitive complexity — worst methods (Cog = how hard to read, Calls = message
 
 method                                        Cog  Calls  Loc
 -------------------------------------------------------------
-Hashira::Report::Text#print                     3      7  report/text.rb:11
-Hashira::Analysis::CycleSearch#cycle?           3      3  analysis/cycle_search.rb:19
-Hashira::CLI::CommandLine#usage_options         3      5  cli/command_line.rb:20
-Hashira::Duplication::Delta#kind                3      6  duplication/delta.rb:21
+Hashira::Coupling::NamespacePrefix#wrapper      4      8  coupling/namespace_prefix.rb:19
+Hashira::Analysis::Syntax#anchor                4     12  analysis/syntax.rb:26
+Hashira::Smells::Conditions#branches            4     10  smells/conditions.rb:23
+Hashira::Coupling::Roster#admit                 3      4  coupling/roster.rb:19
 ...
 
 Per-class rollup (Cog total survives extract-method; Peak is the worst method it hides):
 
 class                              Cog  Methods   Peak
 ------------------------------------------------------
-Hashira::CLI::CommandLine           16       15      3
-Hashira::Analysis::CycleSearch       8        5      3
+Hashira::Project                    12       15      3
+Hashira::CLI::CommandLine           12       15      3
 ...
 
 Hotspots — cost × churn (where refactoring pays the most):
 
 file                                             Cog   Dup  Churn    Rank
 -------------------------------------------------------------------------
-cli/run.rb                                         1    36      2      74
-cli/command_line.rb                               16     0      3      48
-pipeline.rb                                        7     0      3      21
+pipeline.rb                                       10     0      6      60
+cli/command_line.rb                               12     0      4      48
+project.rb                                        12     0      4      48
 ...
 
 Findings (0):
@@ -154,10 +157,63 @@ domain layer near 0.00. The findings are about arrows pointing the wrong way:
   Stable Dependencies Principle ("depend in the direction of stability"), one of
   Robert C. Martin's [package principles](https://en.wikipedia.org/wiki/Package_principles).
 - **Cycle** — packages depending on each other in a loop.
+- **Mixed audience** — the constants of one package split into parts with
+  separate client bases: one set of packages leans on one slice, another set on
+  a disjoint slice. Each part is a separate package in disguise; the finding
+  names the seam, and — when most clients also share a few constants — the
+  shared base layer to extract. Composition roots blur the picture only if they
+  touch a constant some other client also touches, which facades avoid.
+- **Wide edge** — one package reaches into another through five or more
+  distinct constants. Every constant on the edge is a reason for the client to
+  change; a facade narrows the interface to one.
+- **Roll call** — the same list of three or more words (symbols, string keys)
+  is maintained by hand in three or more files across packages. The list wants
+  to be data with a single owner — a registry the other sites derive from.
 
 Each finding comes with file-level evidence; for cycles, the shortest cycle
 path and its lightest edge. What a finding means for your design is your call.
 
+## Rails apps
+
+Rails layer folders are framework layout, not architecture: models will always
+touch jobs and mailers, so folder packages under `app/` report idioms as
+findings. When the analyzed directory contains a `config/application.rb` (the
+Rails root) or sits beside one (its `app` folder), hashira switches to
+**namespace packaging**: types group by top-level constant
+(`Billing`, `Ci`, `User`) across the layer folders, edges join domains, and the
+findings answer the question a Rails monolith actually has — does `Billing`
+reach into `Ci`?
+
+```console
+$ hashira app
+package       TC  Ca  Ce     I  Cyc
+----------------------------------------
+Account       26  21  18  0.46  YES
+Billing      116  12  11  0.48  YES
+Ci           107   9  16  0.64  YES
+...
+  cycle: Account can reach itself: Account -> User -> Account — any change
+  may ripple back around. The lightest edge on this cycle is Account -> User (1 ref).
+      · models/account.rb:36: User
+      · models/user/signup.rb:32: Account
+```
+
+Under namespace packaging, references to app-defined `Application*` base
+classes (`ApplicationRecord`, `ApplicationJob`, …) are skipped as framework
+plumbing; `--package-by folder` keeps them, so the legacy layer view stays
+complete. Constant resolution
+follows Ruby's lexical nesting everywhere — a bare `Authentication` inside
+`class User` is `User::Authentication`, not a top-level namesake in another
+package — which matters most in Rails apps, where nested concerns routinely
+shadow top-level names.
+
+Either grouping can be forced anywhere:
+
+```sh
+hashira app --package-by folder      # layer view, even in a Rails app
+hashira lib/gem --package-by namespace
+```
+
 ## Cognitive complexity
 
 hashira scores every method with **cognitive complexity**, not an ABC or call-count
@@ -236,10 +292,56 @@ it does inside Ruby:
   are called out — that's where one copy gets fixed and the other silently
   drifts. Silent when git isn't there; no configuration either way.
 
+## 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
+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:
+
+```console
+Findings (2):
+  feature_envy: Cart#price refers to 'item' more than to self (cart.rb:12). The behavior may belong on item.
+      · item (lines 13, 14)
+  control_parameter: Report#write is steered by 'quoted' (report.rb:31). Split the method, or pass a strategy instead of a flag.
+      · quoted (line 32)
+```
+
+What each one catches:
+
+- **feature_envy** — a method refers to another object more than to itself; the
+  behavior probably belongs over there.
+- **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.
+- **control_parameter** — an argument used only to pick an execution path; the
+  caller already knew which branch it wanted.
+- **data_clump** — the same two-plus parameters travel through three or more
+  methods; a value object is missing.
+- **duplicate_method_call** — the identical receiver-and-arguments call repeated
+  inside one method; name the result once.
+- **repeated_conditional** — one class testing the same condition in three or
+  more places; polymorphism is overdue.
+- **too_many_instance_variables** — more than four per class. Memoization
+  (`@x ||=`) doesn't count as state.
+- **instance_variable_assumption** — an ivar read that no `initialize` ever
+  assigns; the reader is assuming another method ran first.
+- **manual_dispatch** — `respond_to?` then send: a type check wearing a duck
+  costume.
+- **module_initialize** — `initialize` in a mixin; construction order becomes
+  anyone's guess.
+- **nil_check** — `nil?`, `== nil`, `when nil`: simulated polymorphism on the
+  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
+analyzer entirely.
+
 ## Hotspots
 
-The three analyzers each answer a different question. The rollup joins them per
-file and adds the one signal that isn't in the AST — how often the file actually
+Each analyzer answers a different question. The hotspot rollup joins the cost
+signals — complexity and duplication — per file and adds the one signal that isn't in the AST — how often the file actually
 changes — because cost you never pay isn't worth paying down:
 
 ```console
@@ -299,7 +401,7 @@ it. Git is asked once, lazily, and only if something needs churn.
 at all. It only works on a codebase that starts clean.
 
 ```sh
-hashira --fail-on cycles,sdp,complexity,duplication   # any subset, comma-separated
+hashira --fail-on cycles,sdp,mixed_audience,wide_edge,roll_call,smells   # any subset
 ```
 
 The ratchet is the one you can adopt today. Commit a baseline of what's true now

data/lib/hashira/analysis/finding.rb

@@ -2,14 +2,15 @@
 
 module Hashira
   module Analysis
-    Finding = Data.define(:kind, :package, :message, :evidence, :cycle, :digest) do
-      def initialize(cycle: nil, digest: nil, **rest) = super
+    Finding =
+      Data.define(:kind, :package, :detail, :evidence, :cycle, :digest) do
+        def initialize(cycle: nil, digest: nil, detail: nil, **rest) = super
 
-      def signature = "#{kind}:#{identity}"
+        def signature = "#{kind}:#{identity}"
 
-      def identity = digest || package
+        def identity = digest || package
 
-      def to_h = super.compact
-    end
+        def to_h = super.compact
+      end
   end
 end

data/lib/hashira/analysis/node_walk.rb

@@ -5,14 +5,14 @@ module Hashira
     module NodeWalk
       module_function
 
-      def each_node(node, &)
+      def each(node, &)
         yield(node)
-        node.compact_child_nodes.each { each_node(it, &) }
+        node.compact_child_nodes.each { each(it, &) }
       end
 
       def collect(node)
         found = []
-        each_node(node) { found << it }
+        each(node) { found << it }
         found
       end
     end

data/lib/hashira/analysis/syntax.rb

@@ -7,20 +7,35 @@ module Hashira
     module Syntax
       module_function
 
-      def path_segments(node)
+      def segments(node)
         case node
         when Prism::ConstantReadNode then [node.name.to_s]
-        when Prism::ConstantPathNode then path_segments(node.parent) + name_of(node)
+        when Prism::ConstantPathNode then segments(node.parent) + label(node)
         else []
         end
       end
 
-      def name_of(node) = [node.name.to_s]
+      def label(node) = [node.name.to_s]
 
-      def direct_definitions(type_node)
+      def cbase?(node)
+        return false unless node.is_a?(Prism::ConstantPathNode)
+        parent = node.parent
+        !parent || cbase?(parent)
+      end
+
+      def anchor(stack, segments, roots)
+        return (stack.last || []) + segments if segments.length < 2 || !roots
+        base = stack.reverse_each.find { roots.include?(it + segments.first(1)) }
+        base ? base + segments : hoist(stack, segments, roots)
+      end
+
+      def hoist(stack, segments, roots)
+        roots.include?(segments.first(1)) ? segments : (stack.last || []) + segments
+      end
+
+      def direct(type_node)
         body = type_node.body
-        statements = body.is_a?(Prism::StatementsNode) ? body.body : [body]
-        statements.grep(Prism::DefNode)
+        (body.is_a?(Prism::StatementsNode) ? body.body : [body]).grep(Prism::DefNode)
       end
     end
   end

data/lib/hashira/analysis/type_walk.rb

@@ -7,19 +7,17 @@ module Hashira
     module TypeWalk
       module_function
 
-      def each_definition(node, prefix = [], &)
-        return each_child_definition(node, prefix, &) unless type_node?(node)
-
-        full = prefix + Syntax.path_segments(node.constant_path)
+      def each(node, stack = [], roots: nil, &)
+        return descend(node, stack, roots, &) unless type?(node)
+        full = Syntax.anchor(stack, Syntax.segments(node.constant_path), roots)
         yield(node, full)
-        each_child_definition(node.body, full, &)
+        descend(node.body, stack + [full], roots, &)
       end
 
-      def type_node?(node) = node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)
+      def type?(node) = node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)
 
-      def each_child_definition(node, prefix, &)
-        children = node ? node.compact_child_nodes : []
-        children.each { each_definition(it, prefix, &) }
+      def descend(node, stack, roots, &)
+        (node ? node.compact_child_nodes : []).each { each(it, stack, roots:, &) }
       end
     end
   end

data/lib/hashira/churn.rb

@@ -1,22 +1,20 @@
 # frozen_string_literal: true
 
-module Hashira
-  class Churn
-    LOG = "git log --name-only --format= 2>/dev/null"
-    SITES_THAT_DRIFT_APART = 2
+class Hashira::Churn
+  LOG = "git log --name-only --format= 2>/dev/null"
+  SITES_THAT_DRIFT_APART = 2
 
-    def self.from_git = new(tally(`#{LOG}`))
+  def self.scan = new(tally(`#{LOG}`))
 
-    def self.tally(output) = output.split("\n").map(&:strip).reject(&:empty?).tally
+  def self.tally(output) = output.split("\n").map(&:strip).reject(&:empty?).tally
 
-    def initialize(counts)
-      @counts = counts
-    end
+  def initialize(counts)
+    @counts = counts
+  end
 
-    def hits(file) = @counts.select { |path, _| path.end_with?(file) }.values.max || 0
+  def hits(file) = @counts.select { |path, _| path.end_with?(file) }.values.max || 0
 
-    def hot?(members) = changing(members) >= SITES_THAT_DRIFT_APART
+  def hot?(members) = changing(members) >= SITES_THAT_DRIFT_APART
 
-    def changing(members) = members.count { |member| hits(member.file).positive? }
-  end
+  def changing(members) = members.count { |member| hits(member.file).positive? }
 end

data/lib/hashira/ci/accepted.rb

@@ -2,47 +2,43 @@
 
 require "json"
 
-module Hashira
-  module CI
-    class Accepted
-      Screened = Data.define(:all, :accepted)
+class Hashira::CI::Accepted
+  Screened = Data.define(:all, :accepted)
 
-      Entry = Data.define(:kind, :package, :digest, :reason) do
-        def self.from(hash)
-          new(kind: hash["kind"], package: hash["package"], digest: hash["digest"], reason: hash["reason"])
-        end
-
-        def matches?(finding) = kind == finding.kind && identity == finding.identity
+  Entry =
+    Data.define(:kind, :package, :digest, :reason) do
+      def self.from(hash)
+        new(kind: hash["kind"], package: hash["package"], digest: hash["digest"], reason: hash["reason"])
+      end
 
-        def identity = digest || package
+      def matches?(finding) = kind == finding.kind && identity == finding.identity
 
-        def label = reason || "accepted (no reason recorded)"
+      def identity = digest || package
 
-        def to_h = { kind:, package:, digest:, reason: }.compact
-      end
+      def label = reason || "accepted (no reason recorded)"
 
-      def self.load(path)
-        return new([]) unless path && File.exist?(path)
+      def to_h = { kind:, package:, digest:, reason: }.compact
+    end
 
-        new(JSON.parse(File.read(path)).fetch("accepted", []))
-      end
+  def self.load(path)
+    return new([]) unless path && File.exist?(path)
+    new(JSON.parse(File.read(path)).fetch("accepted", []))
+  end
 
-      def initialize(entries)
-        @entries = entries.map { Entry.from(it) }
-      end
+  def initialize(entries)
+    @entries = entries.map { Entry.from(it) }
+  end
 
-      def entries = @entries.map(&:to_h)
+  def entries = @entries.map(&:to_h)
 
-      def screen(findings)
-        accepted, live = findings.map { [it, reason_for(it)] }.partition(&:last)
-        Screened.new(all: live.map(&:first), accepted:)
-      end
+  def screen(findings)
+    accepted, live = findings.map { [it, reason(it)] }.partition(&:last)
+    Screened.new(all: live.map(&:first), accepted:)
+  end
 
-      private
+  private
 
-      def reason_for(finding)
-        @entries.find { it.matches?(finding) }&.label
-      end
-    end
+  def reason(finding)
+    @entries.find { it.matches?(finding) }&.label
   end
 end