hashira 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 137dafce03e707a097cf684620fbd9c9efc8989347e77b88c13da103102f5da5
-  data.tar.gz: e0ab59d2e1909042c991764b5384217601aaf42b036bd6916042efc2107e0200
+  metadata.gz: 2750af6be7a5e6885421144e92ab4c12e554ece76c110b76d5fd2b52b72a2411
+  data.tar.gz: b2ab7386f4907e297b3cfc623b535808df4f6865423bd9d4f8bae4b487b81317
 SHA512:
-  metadata.gz: 2c4895c6d045e05e610fda4c51ce763e0ef876049d933dbd4a3d9f99ac24c8648583a4a3f39e5c2baadfae263736914ba2a428781024ead0410b2d968585b8b8
-  data.tar.gz: dec6a978383a76ad57fdf34c98b5ea4b571775d44baafc0f5c02c3bbe75b7a56e274609c1586fc77af94e93f65f501579a5b6fa09bfd4db3952bb3cb412c153b
+  metadata.gz: 6a4c401b5d242175899bcf4e1e6792f74b77139346b336564c2496e1b97dd716b5014f147b94fbc076b1870020893c8d99b8f08dadd0ef5e648fa427a6fb3a91
+  data.tar.gz: 812c604c2cafe644d8ab0692b670f74f1c63dde77a1084f235919c1eee72d1a24c53936c403f7e84c2a46c0145c4bd702c6f183e926f9d5f27135d54b366aca6

data/CHANGELOG.md

@@ -5,6 +5,62 @@ 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.9.0] - 2026-08-20
+
+### Fixed
+
+- **A rename stops reading as churn in the ratchet.** A finding is keyed by what
+  it names, so renaming a class reported the twelve findings under it as
+  resolved and new at once, and adding `?` to four predicates did the same. The
+  baseline now records a `traces` map beside `findings` — for each finding, the
+  file it sits in and what its evidence says, with line numbers stripped — and
+  the ratchet pairs a disappeared key with an appeared one carrying the same
+  trace. The match is one for one, so a rename that brought a new finding along
+  still fails, and a renamed method that also got worse still reports WORSE.
+  Acceptance is untouched: `accepted` entries still name a finding by `package`
+  or `digest`. Baselines recorded before this have no traces and behave exactly
+  as they did; the next `--update-baseline` writes them (schema version 5, which
+  older hashira reads too).
+- **A shared namespace stops passing for a shared name.** The duplication
+  near-miss guard raises the mass floor when two sites have no name in common —
+  but `Prism::CallNode` and `Prism::BlockParameterNode` counted `Prism` as
+  common, so two unrelated one-liners that both mention a Prism class slipped
+  under the low floor. A constant is now read by what it points at, not the
+  namespace it sits in.
+- **A nested class is named the way Ruby resolves it.** `class Widget::Broken`
+  written inside `class Widget` was reported as `Widget::Widget::Broken`. The
+  smell census now resolves a compound constant path against the constants the
+  codebase actually declares, the way the coupling graph already did. Findings
+  on such classes change name, so a baseline recorded before this reports them
+  once as resolved-and-new; re-record it with `--update-baseline`.
+
+### Changed
+
+- **`duplicate_method_call` stops flagging calls that are supposed to differ.**
+  `stdout = "".b` next to `stderr = "".b` is two buffers, and
+  `rand(1_000_000_000)` twice is two ids — naming either once writes a bug. The
+  check now excuses calls that mint a fresh value each time (`new`, `dup`,
+  `clone`, `allocate`, `rand`, anything from `SecureRandom` or `Random`, and
+  any call on a literal) and repeats that no single run can reach twice: the
+  two arms of an `if` or `unless`, two `when` or `in` branches, a body and its
+  `rescue`. Nothing can be hoisted across those, and a `raise` has no result to
+  name.
+- **`instance_variable_assumption` asks whether anything assigns, not whether
+  `initialize` does.** Assignment through a mixin, a superclass, an
+  `attr_writer`, a reopening of the class, or a private method the constructor
+  calls all count now — every shape that made the old check report a class that
+  was perfectly fine. What survives is the ivar nothing the class can reach ever
+  sets: a typo, or state another object is expected to install. When a class
+  inherits or includes something the codebase can't see, the check stays quiet
+  rather than guess.
+- **A run of declarative macros is a schema, not a clone.** Two models opening
+  with the same `has_many ..., dependent: :destroy` lines, or two serializers
+  with the same `typelize`/`attribute` pairs, were reported as duplication whose
+  only fix was to hide the schema behind a class method. A fragment built purely
+  from directives — receiverless calls with literal arguments — no longer
+  clusters. A block, a method, a variable, a receiver, or a branch anywhere in
+  the fragment makes it code again.
+
 ## [0.8.0] - 2026-08-15
 
 ### Added

data/README.md

@@ -288,6 +288,12 @@ it does inside Ruby:
 - **Lists aren't clones.** A run of identically shaped statements — a require
   block, a routes file, a column of registrations — is skipped, so windows cut
   out of one don't report a match at every offset.
+- **Declarations aren't clones either.** A fragment built only from directives —
+  receiverless macro calls with literal arguments, the `has_many` /
+  `validates` / `attribute` spine of a model or a serializer — is a schema, not
+  copied logic; extracting it only hides what the class declares. Two models
+  that open the same way are two models. As soon as a fragment carries logic —
+  a block, a method, a variable, a receiver, a branch — it counts again.
 - **Clusters, not pairs.** All copies of one thing collapse into a single
   finding with N sites, so the report reads as "fix this once," not a wall of
   pairwise matches.
@@ -343,13 +349,21 @@ What each one catches:
 - **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.
+  inside one method; name the result once. Quiet wherever naming it would be
+  wrong: calls that mint a fresh value every time (`"".b`, `rand`, `dup`,
+  `SecureRandom.hex`) are meant to differ, and a repeat no single run can reach
+  twice — the two arms of an `if`, two `when` branches, a body and its `rescue`
+  — has nothing to hoist.
 - **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.
+- **instance_variable_assumption** — an ivar read that nothing the class can
+  reach ever assigns: not `initialize`, not another of its own methods, not an
+  `attr_writer`, not a reopening of the class, not a module it mixes in or a
+  class it inherits. Usually a typo, or state some other object is expected to
+  install. Silent when the class inherits or includes something the codebase
+  can't see, because the assignment may live in there.
 - **manual_dispatch** — `respond_to?` then send: a type check wearing a duck
   costume.
 - **module_initialize** — `initialize` in a mixin; construction order becomes
@@ -460,6 +474,17 @@ WORSE FINDING (was 13, now 24):
 Baselines written by earlier versions still work: they record identity only, so
 they ratchet on appearance until the next `--update-baseline` records magnitudes.
 
+It also records a *trace* of each finding — the file it sits in and what it says,
+with the line numbers left out. A finding is keyed by what it names
+(`Class#method`), so renaming a class, or adding a `?` to four predicates, would
+otherwise report every finding under it as resolved and new in the same breath.
+When a key disappears and another appears carrying the same trace, the ratchet
+reads them as one finding that changed name. The match is one for one: a rename
+that *brought* a new finding with it still fails, and a renamed method that also
+got more complex still reports WORSE. Moving the file changes the trace, because
+that is a relocation rather than a rename — re-record it. Baselines without
+traces behave exactly as they did before.
+
 A regression prints in full, with the evidence that introduced it:
 
 ```console

data/lib/hashira/analysis/finding.rb

@@ -4,6 +4,8 @@ module Hashira
   module Analysis
     MAGNITUDES = { "complexity" => :cognitive, "duplication" => :mass, "boundary_sprawl" => :count }.freeze
 
+    TRACKS = [/ \(lines? [\d, ]+\)/, /:[\d, -]+\z/, /:\d+(?=:)/].freeze
+
     Finding =
       Data.define(:kind, :package, :detail, :evidence, :cycle, :digest) do
         def initialize(cycle: nil, digest: nil, detail: nil, **rest) = super
@@ -14,6 +16,14 @@ module Hashira
 
         def identity = digest || package
 
+        def trace
+          "#{kind}|#{plain(site)}|#{evidence.map { plain(it) }.join(";")}" unless digest
+        end
+
+        def site = detail.to_h[:site].to_s
+
+        def plain(text) = TRACKS.reduce(text) { |left, mark| left.gsub(mark, "") }
+
         def to_h = super.merge(detail: detail&.to_h).compact
       end
   end

data/lib/hashira/analysis/type_walk.rb

@@ -7,6 +7,10 @@ module Hashira
     module TypeWalk
       module_function
 
+      def roots(trees)
+        trees.each_value.with_object(Set.new) { |tree, set| each(tree) { |_node, full| set << full } }
+      end
+
       def each(node, stack = [], roots: nil, &)
         return descend(node, stack, roots, &) unless type?(node)
         full = Syntax.anchor(stack, Syntax.segments(node.constant_path), roots)

data/lib/hashira/ci/baseline.rb

@@ -3,7 +3,7 @@
 require "json"
 
 class Hashira::CI::Baseline
-  SCHEMA_VERSION = 4
+  SCHEMA_VERSION = 5
 
   def initialize(path, analyzers: [], targets: [])
     @path = path
@@ -25,6 +25,10 @@ class Hashira::CI::Baseline
 
   def findings = keyed(recorded.fetch("findings", {}))
 
+  def marks = findings.to_h { |key, magnitude| [key, Hashira::CI::Mark.new(magnitude:, trace: traces[key])] }
+
+  def traces = recorded.fetch("traces", {})
+
   def findings? = recorded.key?("findings")
 
   def accepted = recorded.fetch("accepted", [])
@@ -37,8 +41,8 @@ class Hashira::CI::Baseline
 
   def wanted = scope.to_h
 
-  def write(edges, findings, packaging:)
-    File.write(@path, JSON.pretty_generate(payload(edges, findings, packaging)) << "\n")
+  def write(edges, marks, packaging:)
+    File.write(@path, JSON.pretty_generate(payload(edges, marks, packaging)) << "\n")
   end
 
   private
@@ -57,9 +61,21 @@ class Hashira::CI::Baseline
 
   def scope = Hashira::CI::Scope.new(analyzers: @analyzers, targets: @targets)
 
-  def payload(edges, findings, packaging)
-    base = { version: SCHEMA_VERSION, packaging: }.merge(scope.to_h).merge(edges:, findings:)
-    kept = Hashira::CI::Accepted.new(accepted).entries
-    kept.empty? ? base : base.merge(accepted: kept)
+  def payload(edges, marks, packaging)
+    stem(packaging).merge(edges:, findings: sized(marks)).merge(traced(marks)).merge(kept)
+  end
+
+  def stem(packaging) = { version: SCHEMA_VERSION, packaging: }.merge(scope.to_h)
+
+  def sized(marks) = marks.transform_values(&:magnitude)
+
+  def traced(marks)
+    found = marks.transform_values(&:trace).compact
+    found.empty? ? {} : { traces: found }
+  end
+
+  def kept
+    entries = Hashira::CI::Accepted.new(accepted).entries
+    entries.empty? ? {} : { accepted: entries }
   end
 end

data/lib/hashira/ci/comparison.rb

@@ -7,17 +7,26 @@ class Hashira::CI::Comparison
   end
 
   def diff
-    current = @current.keys
-    recorded = @recorded.keys
-    Hashira::CI::Diff.new(added: current - recorded, removed: recorded - current, worsened:)
+    moved = renamed
+    Hashira::CI::Diff.new(added: fresh - moved.keys, removed: gone - moved.values, worsened: worsened(moved))
   end
 
   private
 
-  def worsened
-    (@current.keys & @recorded.keys).filter_map { entry(it, @recorded[it], @current[it]) }
+  def fresh = @current.keys - @recorded.keys
+
+  def gone = @recorded.keys - @current.keys
+
+  def renamed = fresh.to_h { [it, pool[@current[it].trace]&.shift] }.compact
+
+  def pool = @_pool ||= gone.group_by { @recorded[it].trace }.except(nil)
+
+  def worsened(moved)
+    paired(moved).filter_map { |key, was| entry(key, @recorded[was].magnitude, @current[key].magnitude) }
   end
 
+  def paired(moved) = (@current.keys & @recorded.keys).to_h { [it, it] }.merge(moved)
+
   def entry(key, before, after)
     [key, before, after] if before.is_a?(Integer) && after.is_a?(Integer) && after > before
   end

data/lib/hashira/ci/mark.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Hashira
+  module CI
+    Mark = Data.define(:magnitude, :trace)
+  end
+end

data/lib/hashira/ci/ratchet.rb

@@ -63,9 +63,11 @@ class Hashira::CI::Ratchet
   def tally(compared) = compared.counts("#{@graph.edges.size} edges", "#{@findings.size} findings").join(", ")
 
   def scored
-    @_scored ||= @findings.group_by(&:signature).sort.to_h { |key, group| [key, group.filter_map(&:magnitude).max] }
+    @_scored ||= @findings.group_by(&:signature).sort.to_h { |key, group| [key, mark(group)] }
   end
 
+  def mark(group) = Hashira::CI::Mark.new(magnitude: group.filter_map(&:magnitude).max, trace: group.first.trace)
+
   def drift = Hashira::CI::Diff.new(added: fresh, removed: @baseline.edges - edges)
 
   def fresh = @graph.edges.reject { @baseline.edges.include?(it.to_s) }

data/lib/hashira/ci/slice.rb

@@ -9,9 +9,13 @@ class Hashira::CI::Slice
 
   def edges(_diff) = SETTLED
 
-  def findings(scored) = Hashira::CI::Comparison.new(scored, seen(scored)).diff
-
-  def seen(scored) = @baseline.findings.slice(*scored.keys)
+  def findings(marks) = Hashira::CI::Comparison.new(marks, seen(marks, traces(marks))).diff.with(removed: [])
 
   def counts(_edges, findings) = [findings]
+
+  private
+
+  def traces(marks) = marks.each_value.filter_map(&:trace)
+
+  def seen(marks, traces) = @baseline.marks.select { |key, mark| marks.key?(key) || traces.include?(mark.trace) }
 end

data/lib/hashira/ci/sweep.rb

@@ -7,7 +7,7 @@ class Hashira::CI::Sweep
 
   def edges(diff) = diff
 
-  def findings(scored) = Hashira::CI::Comparison.new(scored, @baseline.findings).diff
+  def findings(marks) = Hashira::CI::Comparison.new(marks, @baseline.marks).diff
 
   def counts(edges, findings) = [edges, findings]
 end

data/lib/hashira/coupling/definitions.rb

@@ -14,16 +14,10 @@ class Hashira::Coupling::Definitions
 
   def packages = @trees.keys.map { @project.package(it) }.uniq
 
-  def roots
-    @_roots ||= @trees.each_value.with_object(Set.new) { |tree, set| survey(tree, set) }
-  end
+  def roots = @_roots ||= Hashira::Analysis::TypeWalk.roots(@trees)
 
   private
 
-  def survey(tree, set)
-    Hashira::Analysis::TypeWalk.each(tree) { |_node, full| set << full }
-  end
-
   def scan(file, tree)
     package = @project.package(file)
     Hashira::Analysis::TypeWalk.each(tree, roots: roots) do |node, full|

data/lib/hashira/duplication/clusters.rb

@@ -19,7 +19,7 @@ class Hashira::Duplication::Clusters
 
   private
 
-  def fragments = @_fragments ||= @all.select { |fragment| fragment.mass >= PREFILTER }
+  def fragments = @_fragments ||= @all.select { |fragment| fragment.mass >= PREFILTER }.reject(&:schema?)
 
   def sets = @_sets ||= Hashira::Duplication::UnionFind.new
 

data/lib/hashira/duplication/fragment.rb

@@ -1,10 +1,17 @@
 # frozen_string_literal: true
 
 require "digest"
+require "prism"
 
 class Hashira::Duplication::Fragment
   DIGEST_LENGTH = 12
 
+  SCHEMA = %i[
+    class_node module_node statements_node arguments_node assoc_node
+    array_node hash_node keyword_hash_node constant_read_node constant_path_node
+    symbol_node string_node integer_node float_node true_node false_node nil_node
+  ].freeze
+
   def initialize(file, roots)
     @file = file
     @roots = roots
@@ -20,6 +27,8 @@ class Hashira::Duplication::Fragment
 
   def mass = types.size
 
+  def schema? = nodes.all? { directive?(it) }
+
   def line = @roots.first.location.start_line
 
   def finish = @roots.last.location.end_line
@@ -35,4 +44,13 @@ class Hashira::Duplication::Fragment
   def touches?(others) = others.any? { overlaps?(it) }
 
   def nodes = @_nodes ||= @roots.flat_map { Hashira::Analysis::NodeWalk.collect(it) }
+
+  private
+
+  def directive?(node)
+    return SCHEMA.include?(node.type) unless node.is_a?(Prism::CallNode)
+    !node.receiver && !node.block && literals?(node.arguments)
+  end
+
+  def literals?(arguments) = Hashira::Duplication::Literal.new(arguments).literals?
 end

data/lib/hashira/duplication/literal.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Duplication::Literal
+  TYPES = [
+    Prism::ArrayNode, Prism::AssocNode, Prism::FalseNode, Prism::FloatNode,
+    Prism::HashNode, Prism::IntegerNode, Prism::KeywordHashNode, Prism::NilNode,
+    Prism::StringNode, Prism::SymbolNode, Prism::TrueNode
+  ].freeze
+
+  def initialize(node)
+    @node = node
+  end
+
+  def literal? = TYPES.include?(@node.class) && parts.all?(&:literal?)
+
+  def literals? = parts.all?(&:literal?)
+
+  private
+
+  def parts = children.map { Hashira::Duplication::Literal.new(it) }
+
+  def children = Array(@node&.compact_child_nodes)
+end

data/lib/hashira/duplication/variance.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "prism"
+
 class Hashira::Duplication::Variance
   LITERALS = %i[integer_node float_node string_node symbol_node].freeze
   VALUED = %i[integer_node float_node].freeze
@@ -27,7 +29,11 @@ class Hashira::Duplication::Variance
 
   def pairs = @canonical.nodes.zip(@other.nodes)
 
-  def named = @_named ||= pairs.select { |left, _| NAMED.include?(left.type) }
+  def named = @_named ||= pairs.select { |left, _| NAMED.include?(left.type) && !inner?(left) }
+
+  def inner?(node) = nested.any? { it.equal?(node) }
+
+  def nested = @_nested ||= @canonical.nodes.grep(Prism::ConstantPathNode).filter_map(&:parent)
 
   def differing = pairs.select { |pair| varies?(*pair) }.map(&:first)
 

data/lib/hashira/report/smell_phrases.rb

@@ -33,8 +33,8 @@ module Hashira::Report::Phrases
   end
 
   def on_instance_variable_assumption(finding)
-    "#{finding.package} reads instance variables never set in initialize (#{finding.detail[:site]}). " \
-      "Assign them in initialize, or pass the data explicitly."
+    "#{finding.package} reads instance variables nothing in the class assigns (#{finding.detail[:site]}). " \
+      "Assign them where the object is built, or pass the data explicitly."
   end
 
   def on_manual_dispatch(finding)

data/lib/hashira/smells/branches.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Smells::Branches
+  def initialize(root)
+    @root = root
+  end
+
+  def together?(nodes) = nodes.combination(2).any? { |left, right| meet?(trail(left), trail(right)) }
+
+  private
+
+  def meet?(left, right) = shared(left, right).none? { parted?(*it) }
+
+  def shared(left, right) = left.zip(right).select(&:last)
+
+  def parted?(here, there) = here.first.equal?(there.first) && here.last != there.last
+
+  def trail(node) = trails.fetch(node)
+
+  def trails
+    return @_trails if @_trails
+    @_trails = {}.compare_by_identity
+    chart(@root, [])
+    @_trails
+  end
+
+  def chart(node, trail)
+    @_trails[node] = trail
+    node.compact_child_nodes.each { chart(it, trail + taken(node, it)) }
+  end
+
+  def taken(node, child)
+    return arm_for(node, child) if node.is_a?(Prism::BeginNode)
+    arm = arms(node).index { it.equal?(child) }
+    arm ? [[node, arm]] : []
+  end
+
+  def arm_for(node, child)
+    rescued = node.rescue_clause
+    return [] unless [node.statements, rescued, node.else_clause].any? { it.equal?(child) }
+    [[node, rescued.equal?(child) ? 1 : 0]]
+  end
+
+  def arms(node) = (clauses(node) || conditions(node)).compact
+
+  def clauses(node)
+    case node
+    when Prism::IfNode, Prism::RescueNode then [node.statements, node.subsequent]
+    when Prism::UnlessNode then [node.statements, node.else_clause]
+    when Prism::RescueModifierNode then [node.expression, node.rescue_expression]
+    end
+  end
+
+  def conditions(node)
+    case node
+    when Prism::CaseNode, Prism::CaseMatchNode then node.conditions + [node.else_clause]
+    else []
+    end
+  end
+end

data/lib/hashira/smells/census.rb

@@ -10,13 +10,19 @@ class Hashira::Smells::Census
 
   def ownership = @_ownership ||= Hashira::Smells::Ownership.new(@trees.values)
 
-  def types = @trees.flat_map { |path, tree| harvest(@project.relative(path), tree) }
+  def types = @_types ||= placed(@trees.flat_map { |path, tree| harvest(@project.relative(path), tree) })
 
   private
 
+  def placed(found) = settled(found, Hashira::Smells::Lineage.new(found))
+
+  def settled(found, lineage) = found.map { it.with(assigned: lineage.assigned(it)) }
+
+  def roots = @_roots ||= Hashira::Analysis::TypeWalk.roots(@trees)
+
   def harvest(file, tree)
     found = []
-    Hashira::Analysis::TypeWalk.each(tree) { |node, full| found << context(file, node, full.join("::")) }
+    Hashira::Analysis::TypeWalk.each(tree, roots:) { |node, full| found << context(file, node, full.join("::")) }
     found
   end
 

data/lib/hashira/smells/contexts.rb

@@ -51,7 +51,9 @@ module Hashira
       end
 
     TypeContext =
-      Data.define(:name, :node, :kind, :file, :defs) do
+      Data.define(:name, :node, :kind, :file, :defs, :assigned) do
+        def initialize(assigned: nil, **rest) = super
+
         def line = node.location.start_line
 
         def subject = name

data/lib/hashira/smells/duplicate_method_call.rb

@@ -5,23 +5,43 @@ require "prism"
 class Hashira::Smells::DuplicateMethodCall < Hashira::Smells::Check
   LIMIT = 1
 
+  MINTS = %i[new dup clone allocate rand srand].freeze
+
+  SOURCES = %w[SecureRandom Random].freeze
+
+  LITERALS = [
+    Prism::StringNode, Prism::SymbolNode, Prism::ArrayNode, Prism::HashNode,
+    Prism::IntegerNode, Prism::FloatNode, Prism::RegularExpressionNode
+  ].freeze
+
   private
 
   def smelly? = repeats.any?
 
-  def calls = @_calls ||= Hashira::Smells::Scope.inside(subject.node).grep(Prism::CallNode)
+  def calls
+    @_calls ||= Hashira::Smells::Scope.inside(subject.node).grep(Prism::CallNode).reject { minted?(it) }
+  end
+
+  def minted?(node) = mints?(node.name) || spawns?(node.receiver)
+
+  def mints?(name) = MINTS.include?(name)
+
+  def spawns?(receiver) = LITERALS.include?(receiver.class) || SOURCES.include?(receiver&.slice)
 
   def plain?(node)
     !node.receiver && !node.arguments && !node.block.is_a?(Prism::BlockArgumentNode)
   end
 
   def repeats
-    @_repeats ||= usual.reject { |_handle, nodes| whole.value?(nodes) }.merge(whole)
+    @_repeats ||= together(usual.reject { |_handle, nodes| whole.value?(nodes) }.merge(whole))
   end
 
+  def together(groups) = groups.select { |_handle, nodes| branches.together?(nodes) }
+
+  def branches = @_branches ||= Hashira::Smells::Branches.new(subject.node)
+
   def usual
-    calls.reject { plain?(it) || it.name == :new }
-      .group_by { handle(it) }.select { |_handle, group| group.size > LIMIT }
+    calls.reject { plain?(it) }.group_by { handle(it) }.select { |_handle, group| group.size > LIMIT }
   end
 
   def whole

data/lib/hashira/smells/instance_variable_assumption.rb

@@ -3,12 +3,6 @@
 require "prism"
 
 class Hashira::Smells::InstanceVariableAssumption < Hashira::Smells::Check
-  SETTERS = [
-    Prism::InstanceVariableWriteNode, Prism::InstanceVariableOrWriteNode,
-    Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableOperatorWriteNode,
-    Prism::InstanceVariableTargetNode
-  ].freeze
-
   MAYBES = [
     Prism::LocalVariableOrWriteNode, Prism::InstanceVariableOrWriteNode,
     Prism::ClassVariableOrWriteNode, Prism::GlobalVariableOrWriteNode,
@@ -28,19 +22,15 @@ class Hashira::Smells::InstanceVariableAssumption < Hashira::Smells::Check
 
   private
 
-  def smelly? = subject.kind == :class && assumed.any?
+  def smelly? = subject.kind == :class && assigned && assumed.any?
+
+  def assigned = subject.assigned
 
-  def assumed = @_assumed ||= (read - prepared).uniq.sort.reject { cache?(it) }
+  def assumed = @_assumed ||= (read - assigned).uniq.sort.reject { cache?(it) }
 
   def cache?(name) = name.start_with?("@_")
 
   def read = subject.owned.flat_map { Harvest.reads(it.node) }
 
-  def prepared
-    starters.flat_map { Hashira::Smells::Scope.inside(it.node) }.select { SETTERS.include?(it.class) }.map(&:name)
-  end
-
-  def starters = subject.owned.select { it.node.name == :initialize }
-
   def evidence = assumed.map(&:to_s)
 end

data/lib/hashira/smells/lineage.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Hashira::Smells::Lineage
+  MIXINS = %i[include prepend].freeze
+
+  EXTENSIONS = %i[extend].freeze
+
+  WRITERS = %i[attr_writer attr_accessor].freeze
+
+  SETTERS = [
+    Prism::InstanceVariableWriteNode, Prism::InstanceVariableOrWriteNode,
+    Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableOperatorWriteNode,
+    Prism::InstanceVariableTargetNode
+  ].freeze
+
+  def initialize(types)
+    @types = types
+  end
+
+  def assigned(context) = kin(context)&.flat_map { writes(it) }&.uniq
+
+  private
+
+  def index = @_index ||= @types.group_by(&:name)
+
+  def kin(context) = walk([context.name], [])&.flat_map { index.fetch(it) }
+
+  def walk(queue, known)
+    return known if queue.empty?
+    name, *rest = queue
+    return walk(rest, known) if known.include?(name)
+    onward(rest, known + [name], parents(index.fetch(name)))
+  end
+
+  def onward(queue, known, found)
+    walk(queue + found, known) if found
+  end
+
+  def parents(kin)
+    found = kin.flat_map { pointed(it) }
+    found unless found.include?(nil) || kin.any? { opaque?(it) }
+  end
+
+  def opaque?(type) = extensions(type).any? { !resolve(type.name, Hashira::Analysis::Syntax.segments(it)) }
+
+  def extensions(type) = named(type, EXTENSIONS)
+
+  def pointed(type) = references(type).map { resolve(type.name, it) }
+
+  def references(type)
+    (named(type, MIXINS) + [parent(type)].compact).map { Hashira::Analysis::Syntax.segments(it) }
+  end
+
+  def parent(type) = (type.node.superclass if type.kind == :class)
+
+  def resolve(owner, segments) = candidates(owner, segments).find { index.key?(it) }
+
+  def candidates(owner, segments)
+    segments.empty? ? [] : scopes(owner).map { (it + segments).join("::") }
+  end
+
+  def scopes(owner)
+    parts = owner.split("::")
+    parts.size.downto(0).map { parts.first(it) }
+  end
+
+  def writes(type)
+    definitions(type).flat_map { setters(it) } + attributes(type)
+  end
+
+  def definitions(type) = sweep(type).grep(Prism::DefNode).reject(&:receiver)
+
+  def setters(node) = Hashira::Smells::Scope.sweep(node).select { SETTERS.include?(it.class) }.map(&:name)
+
+  def attributes(type)
+    named(type, WRITERS).select { it.is_a?(Prism::SymbolNode) || it.is_a?(Prism::StringNode) }.map { :"@#{it.unescaped}" }
+  end
+
+  def named(type, names) = passed(calls(type).select { names.include?(it.name) })
+
+  def passed(calls) = calls.flat_map { it.arguments.arguments }
+
+  def calls(type) = sweep(type).grep(Prism::CallNode).reject(&:receiver).select(&:arguments)
+
+  def sweep(type) = swept.fetch(type.node) { store(it) }
+
+  def store(node) = swept[node] = Hashira::Smells::Scope.sweep(node)
+
+  def swept = @_swept ||= {}.compare_by_identity
+end

data/lib/hashira/version.rb

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

data/lib/hashira.rb

@@ -43,6 +43,7 @@ require_relative "hashira/ci/edge_diff_report"
 require_relative "hashira/ci/finding_diff_report"
 require_relative "hashira/ci/gate"
 require_relative "hashira/ci/improvement"
+require_relative "hashira/ci/mark"
 require_relative "hashira/ci/ratchet"
 require_relative "hashira/ci/ratchet_report"
 require_relative "hashira/ci/scope"
@@ -116,6 +117,7 @@ require_relative "hashira/duplication/fragment"
 require_relative "hashira/duplication/grouping"
 require_relative "hashira/duplication/harvest"
 require_relative "hashira/duplication/index"
+require_relative "hashira/duplication/literal"
 require_relative "hashira/duplication/maximal"
 require_relative "hashira/duplication/near_miss"
 require_relative "hashira/duplication/sequence"
@@ -141,6 +143,7 @@ require_relative "hashira/report/phrases"
 require_relative "hashira/report/smell_phrases"
 require_relative "hashira/report/text"
 require_relative "hashira/report/view"
+require_relative "hashira/smells/branches"
 require_relative "hashira/smells/census"
 require_relative "hashira/smells/check"
 require_relative "hashira/smells/kind"
@@ -151,6 +154,7 @@ require_relative "hashira/smells/data_clump"
 require_relative "hashira/smells/duplicate_method_call"
 require_relative "hashira/smells/feature_envy"
 require_relative "hashira/smells/instance_variable_assumption"
+require_relative "hashira/smells/lineage"
 require_relative "hashira/smells/manual_dispatch"
 require_relative "hashira/smells/module_initialize"
 require_relative "hashira/smells/nil_check"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hashira
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Giacomo GK
@@ -39,6 +39,7 @@ files:
 - lib/hashira/ci/finding_diff_report.rb
 - lib/hashira/ci/gate.rb
 - lib/hashira/ci/improvement.rb
+- lib/hashira/ci/mark.rb
 - lib/hashira/ci/ratchet.rb
 - lib/hashira/ci/ratchet_report.rb
 - lib/hashira/ci/scope.rb
@@ -113,6 +114,7 @@ files:
 - lib/hashira/duplication/grouping.rb
 - lib/hashira/duplication/harvest.rb
 - lib/hashira/duplication/index.rb
+- lib/hashira/duplication/literal.rb
 - lib/hashira/duplication/maximal.rb
 - lib/hashira/duplication/near_miss.rb
 - lib/hashira/duplication/sequence.rb
@@ -140,6 +142,7 @@ files:
 - lib/hashira/report/text.rb
 - lib/hashira/report/view.rb
 - lib/hashira/smells/boundary_sprawl.rb
+- lib/hashira/smells/branches.rb
 - lib/hashira/smells/census.rb
 - lib/hashira/smells/check.rb
 - lib/hashira/smells/conditions.rb
@@ -151,6 +154,7 @@ files:
 - lib/hashira/smells/foreign.rb
 - lib/hashira/smells/instance_variable_assumption.rb
 - lib/hashira/smells/kind.rb
+- lib/hashira/smells/lineage.rb
 - lib/hashira/smells/manual_dispatch.rb
 - lib/hashira/smells/module_initialize.rb
 - lib/hashira/smells/nil_check.rb