rubocop-hanami 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f6976191e56400636d7d6b59ab3be6b59fe8bcdbb83385412b7d8c49815c022
-  data.tar.gz: 8d27ebaacb50254b176b175c85c2170dc44e663a4e3a15858cc4d03ecda0c86a
+  metadata.gz: b66d94028f3350e9dc3966897abca014e9ccad980d431858e664b43421293cd2
+  data.tar.gz: 461f52c846ff69d42d92f1ba5e9f88259b88e32607f0f61130e0d650e359e95d
 SHA512:
-  metadata.gz: 9c7df42e38e04d36610528c38c52ca955d39109b0453e75f0222ba29b6d9631f3a001e16c0da165d89e57662137cdf94e1be8a54d11282976b179a045d9762c0
-  data.tar.gz: 0b7d37ba2fc067c567e9f3648080159cf7f694c682286213cdce6c589a85ad4d6078b0a6b354a1fec1a19f0faa9f3e7438214895160de67dc9ebe5fa7f74eae7
+  metadata.gz: c675f410f6986ad1f8d8cce76f009ed5bdec6b33311d1ce4d49c2f0086d301f17cd4dd1f0d93e23406edad78d90ea5429f08bb50927fc2c358e94cda0a8c9e05
+  data.tar.gz: 83e3270654f1717d865a996e5257becb33edc829cb5ce1d8bd0722762586996465683d6d0793c0bb9246f30e0deb9ec21a79171150d1698346e3fd151eba4161

data/CHANGELOG.md

@@ -7,6 +7,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [v0.2.1] - 2026-10-18
+
+### Added
+
+- `AllowedNames` for `Hanami/UnusedDeps`, a list of accessor names the cop never flags in any class. Use it for names
+  read somewhere the cop can't follow. It also hides a real unused dependency of that name, so keep the list short.
+
+### Changed
+
+- `Hanami/UnusedDeps` counts a dependency as used when a parent class, a subclass at any depth, or a module either
+  one includes reads it. A base operation that reads `contract` while each subclass injects its own no longer flags
+  every subclass. The cop parses every file under `app`, `lib` and `slices` to follow them, and stops at constants
+  the project doesn't define, such as `Hanami::Action`.
+- While `Hanami/UnusedDeps` is on, any change to a file under `app`, `lib` or `slices` clears RuboCop's cached
+  results for every cop and every file, since one class's result now depends on others.
+- `Hanami/SliceNamespace` reads the acronyms in `config/app.rb`, so `inflections.acronym "TMAS"` turns
+  `tmas_gate_counts` into `TMASGateCounts` with no cop config. `Inflections` keys now match word by word as well as
+  by whole slice name.
+
+### Fixed
+
+- `Hanami/UnusedDeps` flagged a dependency that `initialize` took as a keyword and read in its body. A keyword only
+  passed on to `super` still counts as unused.
+
 ## [v0.2.0] - 2026-10-07
 
 ### Added
@@ -53,6 +77,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   `ParentClasses` names the superclasses that mark a class as a slice, `Hanami::Slice` by default.
   `RequireExport: false` lets a slice leave out `export`.
 
-[Unreleased]: https://github.com/aaronmallen/rubocop-hanami/compare/0.2.0...HEAD
+[Unreleased]: https://github.com/aaronmallen/rubocop-hanami/compare/0.2.1...HEAD
+[v0.2.1]: https://github.com/aaronmallen/rubocop-hanami/releases/tag/0.2.1
 [v0.2.0]: https://github.com/aaronmallen/rubocop-hanami/releases/tag/0.2.0
 [v0.1.0]: https://github.com/aaronmallen/rubocop-hanami/releases/tag/0.1.0

data/config/default.yml

@@ -75,6 +75,7 @@ Hanami/UnusedDeps:
     - "app/**/*.rb"
     - "slices/**/*.rb"
     - "lib/**/*.rb"
+  AllowedNames: []
 
 Hanami/EnvAccess:
   Description: Checks for `ENV` outside settings and providers.

data/lib/rubocop/cop/hanami/slice_namespace.rb

@@ -8,9 +8,11 @@ module RuboCop
       # `Admin::Actions::Users::Index`. A mismatch raises at load time, often far from the file at
       # fault.
       #
-      # The cop camelizes the slice's directory, so `admin_panel` gives `AdminPanel`, and checks only
-      # the first segment of each name. Name slices that don't camelize plainly in `Inflections`. For
-      # nested slices, the innermost one counts.
+      # The cop camelizes the slice's directory the way Hanami does, word by word, so `admin_panel`
+      # gives `AdminPanel`, and checks only the first segment of each name. It reads the acronyms in
+      # `config/app.rb`, so `inflections.acronym "TMAS"` turns `tmas_gate_counts` into `TMASGateCounts`.
+      # `Inflections` adds to them, keyed by word or by whole slice name. For nested slices, the
+      # innermost one counts.
       #
       # @example
       #   # slices/admin/actions/users/index.rb
@@ -37,6 +39,14 @@ module RuboCop
         MSG = "Files in `slices/%<slice>s` belong in the `%<namespace>s` namespace."
         SLICE = %r{(?:\A|/)slices/([^/]+)(?=/)}
 
+        def_node_search :acronyms, "(send _ :acronym $...)"
+
+        # Lets RuboCop's result cache drop stale results when the app's inflections change.
+        def external_dependency_checksum
+          path = app_config_path
+          Digest::SHA1.hexdigest(File.read(path)) if File.file?(path)
+        end
+
         def on_new_investigation
           slice = slice_name
           return unless slice && processed_source.ast
@@ -51,8 +61,31 @@ module RuboCop
 
         private
 
+        # Hanami camelizes a slice's name with its parent's inflector. Only the app's is read, so a nested
+        # slice ignores acronyms set in its parent slice.
+        def app_acronyms
+          ast = app_config_ast
+          return {} unless ast
+
+          words = acronyms(ast).to_a.flatten.select { |arg| arg.type?(:str, :sym) }
+          words.to_h { |word| [word.value.to_s.downcase, word.value.to_s] }
+        end
+
+        def app_config_ast
+          path = app_config_path
+          return unless File.file?(path)
+
+          source = processed_source
+          ProcessedSource.from_file(path, source.ruby_version, parser_engine: source.parser_engine).ast
+        end
+
+        def app_config_path
+          File.join(config.base_dir_for_path_parameters, "config", "app.rb")
+        end
+
         def namespace_for(slice)
-          (cop_config["Inflections"] || {}).fetch(slice) { slice.split("_").map(&:capitalize).join }.to_s
+          rules = app_acronyms.merge(cop_config["Inflections"] || {})
+          rules.fetch(slice) { slice.split("_").map { |word| rules.fetch(word) { word.capitalize } }.join }.to_s
         end
 
         def root_name(const)

data/lib/rubocop/cop/hanami/unused_deps.rb

@@ -7,13 +7,19 @@ module RuboCop
       # dependency still gets resolved, still boots its provider and still shows up as a constructor
       # argument.
       #
-      # A read is a bare call or a call on `self`, the instance variable the kwargs strategy sets, or
-      # `send`, `public_send`, `__send__` or `method` with a literal symbol. The cop skips a class
+      # A read is a bare call or a call on `self`, the instance variable the kwargs strategy sets,
+      # `send`, `public_send`, `__send__` or `method` with a literal symbol, or a keyword argument
+      # of `initialize` read outside `super`. The cop skips a class
       # that passes `Deps` anything but literal keys, or calls `send` with a name it can't read. It
       # skips modules, since `include Deps` in a module serves whatever class includes it.
       #
-      # The cop sees one file, so it flags a dependency that only a subclass reads. Disable it with a
-      # comment on that key.
+      # A dependency also counts as used when a parent class, a subclass at any depth, or a mixin of
+      # either reads it. The cop indexes the classes and modules under `app`, `lib` and `slices` to
+      # follow them, and stops at constants the project doesn't define, such as `Hanami::Action`. It
+      # skips the class if one of them calls `send` with a name it can't read.
+      #
+      # It still flags a dependency read somewhere it can't follow. Disable it with a comment on that
+      # key, or name it in `AllowedNames` to never flag it.
       #
       # @example
       #   # bad
@@ -33,23 +39,38 @@ module RuboCop
       #       user_repo.create(input)
       #     end
       #   end
+      #
+      # @example AllowedNames: [contract]
+      #   # good
+      #   class Operations::SaveTask < MyApp::Operation
+      #     include Deps[contract: "contracts.task"]
+      #   end
       class UnusedDeps < Base
         include DepsKeys
 
         MSG = "`%<name>s` from `Deps[\"%<key>s\"]` is never used."
 
         def_node_matcher :dynamic_send?, "(send _ {:send :public_send :__send__} !sym ...)"
+        def_node_search :initializers, "(def :initialize ...)"
         def_node_matcher :literal_send, "(send _ {:send :public_send :__send__ :method} (sym $_) ...)"
 
+        # Lets RuboCop's result cache drop stale results when a parent class or mixin changes.
+        def external_dependency_checksum
+          RuboCop::Hanami::ClassIndex.checksum(config.base_dir_for_path_parameters)
+        end
+
         def on_class(node)
           arguments = deps_arguments_in(node)
           return unless checkable?(node, arguments)
 
-          used = used_names(node)
-          each_deps_key(arguments) do |key_node, name|
-            next if name.nil? || used.include?(name)
+          unused = unused_keys(arguments, used_names(node) + Array(cop_config["AllowedNames"]))
+          return if unused.empty?
+
+          related = related_reads(node)
+          return unless related
 
-            add_offense(key_node, message: format(MSG, name: name, key: key_node.value))
+          unused.each do |key_node, name|
+            add_offense(key_node, message: format(MSG, name: name, key: key_node.value)) unless related.include?(name)
           end
         end
 
@@ -61,22 +82,54 @@ module RuboCop
           node.each_descendant(:send).none? { |send| dynamic_send?(send) }
         end
 
+        def class_index
+          RuboCop::Hanami::ClassIndex.for(config.base_dir_for_path_parameters, processed_source) do |node|
+            used_names(node) if node.each_descendant(:send).none? { |send| dynamic_send?(send) }
+          end
+        end
+
         def deps_arguments_in(node)
           body = node.body
           children = body&.begin_type? ? body.children : [body]
           children.compact.filter_map { |child| deps_arguments(child) }.flatten
         end
 
+        # Passing a keyword on to `super` doesn't count, since the kwargs strategy needs that to inject it.
+        def keyword_reads(method)
+          keywords = method.arguments.select { |argument| argument.type?(:kwarg, :kwoptarg) }.map(&:name)
+          reads = method.each_descendant(:lvar).select { |lvar| lvar.each_ancestor(:super).none? }.map(&:name)
+          (keywords & reads).map(&:to_s)
+        end
+
         def literal?(argument)
           argument.str_type? || (argument.hash_type? && argument.pairs.all? { |pair| literal_alias?(pair) })
         end
 
-        def used_names(node)
-          node.each_descendant(:send, :ivar).to_set do |read|
-            next read.children.first.to_s.delete_prefix("@") if read.ivar_type?
+        def read_name(read)
+          return read.children.first.to_s.delete_prefix("@") if read.ivar_type?
 
-            literal_send(read)&.to_s || (read.method_name.to_s if read.receiver.nil? || read.receiver.self_type?)
+          literal_send(read)&.to_s || (read.method_name.to_s if read.receiver.nil? || read.receiver.self_type?)
+        end
+
+        # The names every parent, child and mixin of `node` reads, or nil when one of them reads names
+        # the cop can't see.
+        def related_reads(node)
+          index = class_index
+          reads = index.related(index.definition(node, nil)).map(&:reads)
+          reads.sum(Set[]) if reads.all?
+        end
+
+        def unused_keys(arguments, used)
+          unused = []
+          each_deps_key(arguments) do |key_node, name|
+            unused << [key_node, name] unless name.nil? || used.include?(name)
           end
+          unused
+        end
+
+        def used_names(node)
+          reads = node.each_descendant(:send, :ivar).to_set { |read| read_name(read) }
+          reads.merge(initializers(node).flat_map { |method| keyword_reads(method) })
         end
       end
     end

data/lib/rubocop/hanami/class_index.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Hanami
+    # Indexes the classes and modules defined under a project's `app`, `lib` and `slices`, so a cop can
+    # follow a class to the parents and mixins it inherits from, and to the classes that inherit from
+    # it, across files.
+    class ClassIndex
+      extend NodePattern::Macros
+
+      GLOB = "{app,lib,slices}/**/*.rb"
+      # ponytail: rescans at most once a second, so a language server may lint against a one second old
+      # project. Watch files instead if that ever matters.
+      TTL = 1
+
+      # `parents` holds each superclass or mixin as written, with the lexical scopes to resolve it in.
+      # `reads` is the set of names the body reads, or nil when it reads names the cop can't see.
+      Definition = Struct.new(:name, :parents, :reads)
+
+      def_node_matcher :mixin_arguments, "(send nil? {:include :prepend} $...)"
+
+      @indexes = {}
+
+      class << self
+        # Changes whenever a file under the indexed roots is added, removed or touched.
+        def checksum(root)
+          Digest::SHA1.hexdigest(Dir.glob(GLOB, base: root).sort.map { |path| "#{path}#{mtime(root, path)}" }.join)
+        end
+
+        # One index per project root, shared by every file in the run. `reads` takes a class or module
+        # node and returns its Definition#reads.
+        def for(root, processed_source, &reads)
+          index = @indexes[root] ||= new(root, processed_source, reads)
+          index.refresh
+          index
+        end
+
+        def mtime(root, path)
+          File.mtime(File.join(root, path)).to_f
+        rescue Errno::ENOENT
+          nil
+        end
+
+        # The constant's full name, as Module#name would give it.
+        def name_of(node)
+          name = node.identifier.source
+          return name.delete_prefix("::") if name.start_with?("::")
+
+          outer = node.each_ancestor(:class, :module).first
+          outer ? "#{name_of(outer)}::#{name}" : name
+        end
+
+        # The full names of the classes and modules around `node`, innermost first.
+        def scopes_of(node)
+          node.each_ancestor(:class, :module).map { |scope| name_of(scope) }
+        end
+      end
+
+      def initialize(root, processed_source, reads)
+        @root = root
+        @ruby_version = processed_source.ruby_version
+        @parser_engine = processed_source.parser_engine
+        @reads = reads
+        @files = {}
+      end
+
+      # Every definition `definition` inherits from, through superclasses and mixins, that the project
+      # defines. A constant from outside the project, such as `Hanami::Action`, ends the walk.
+      def ancestors(definition, seen = Set[definition.name])
+        definition.parents.flat_map do |constant, scopes|
+          name = resolve(constant, scopes, definition.name)
+          next [] unless name && seen.add?(name)
+
+          @definitions[name].flat_map { |parent| [parent, *ancestors(parent, seen)] }
+        end
+      end
+
+      # Every definition that inherits from `name`, at any depth.
+      def descendants(name, seen = Set[name])
+        @children.fetch(name, []).flat_map do |child|
+          seen.add?(child.name) ? [child, *descendants(child.name, seen)] : []
+        end
+      end
+
+      def definition(node, reads = @reads.call(node))
+        name = self.class.name_of(node)
+        scopes = self.class.scopes_of(node)
+        parents = mixins(node).map { |constant| [constant.source, [name, *scopes]] }
+        parents.unshift([node.parent_class.source, scopes]) if node.class_type? && node.parent_class&.const_type?
+        Definition.new(name, parents, reads)
+      end
+
+      # Parses only the files added or touched since the last scan.
+      def refresh
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        return if @checked_at && now - @checked_at < TTL
+
+        @checked_at = now
+        @files = Dir.glob(GLOB, base: @root).to_h { |path| [path, file_entry(path)] }
+        definitions = @files.values.flat_map(&:last)
+        @definitions = definitions.group_by(&:name)
+        @children = children_of(definitions)
+      end
+
+      # Everything whose reads count for `definition`: its ancestors, its descendants, and the ancestors
+      # of those descendants, such as a mixin a subclass includes.
+      def related(definition)
+        family = [definition, *descendants(definition.name)]
+        (family.drop(1) + family.flat_map { |member| ancestors(member) }).uniq
+      end
+
+      private
+
+      def children_of(definitions)
+        children = Hash.new { |hash, name| hash[name] = [] }
+        definitions.each do |child|
+          child.parents.each do |constant, scopes|
+            name = resolve(constant, scopes, child.name)
+            children[name] << child if name
+          end
+        end
+        children
+      end
+
+      def file_entry(path)
+        mtime = self.class.mtime(@root, path)
+        cached = @files[path]
+        cached&.first == mtime ? cached : [mtime, parse(path)]
+      end
+
+      def mixins(node)
+        body = node.body
+        children = body&.begin_type? ? body.children : [body]
+        children.compact.flat_map { |child| mixin_arguments(child) || [] }.select(&:const_type?)
+      end
+
+      def parse(path)
+        ast = ProcessedSource.from_file(File.join(@root, path), @ruby_version, parser_engine: @parser_engine).ast
+        ast ? ast.each_node(:class, :module).map { |node| definition(node) } : []
+      rescue Errno::ENOENT
+        []
+      end
+
+      # Looks the constant up the way Ruby would, from the innermost scope out, skipping the class that
+      # names it so `class Operation < Operation` finds the outer one.
+      def resolve(constant, scopes, skip)
+        candidates = [*scopes.map { |scope| "#{scope}::#{constant}" }, constant]
+        candidates = [constant.delete_prefix("::")] if constant.start_with?("::")
+        candidates.find { |name| name != skip && @definitions.key?(name) }
+      end
+    end
+  end
+end

data/lib/rubocop-hanami.rb

@@ -2,6 +2,7 @@
 
 require "rubocop"
 
+require_relative "rubocop/hanami/class_index"
 require_relative "rubocop/hanami/plugin"
 require_relative "rubocop/cop/hanami/mixin/deps_keys"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-hanami
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Aaron Allen
@@ -61,6 +61,7 @@ files:
 - lib/rubocop/cop/hanami/unused_deps.rb
 - lib/rubocop/cop/hanami/unvalidated_params.rb
 - lib/rubocop/cop/hanami/unwrapped_step.rb
+- lib/rubocop/hanami/class_index.rb
 - lib/rubocop/hanami/plugin.rb
 homepage: https://github.com/aaronmallen/rubocop-hanami
 licenses: