eager_eye 1.2.5 → 1.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fa0e6e3acb2c37751e7ab49a58826a016a68c7a33cc6305ddb6b82d6787c462
-  data.tar.gz: af81d8c0cfde13914b00a9f64b4b1bef6731b12902a1358c7f27473c2ab9a68d
+  metadata.gz: f996747b6c12e539180e66cc74c11c70acfab4a6e4b84aed4039cc7b58dafe53
+  data.tar.gz: f23d5a21ceecc39c71b0303a5748472a8ea5e0f5f3256ffd5a10084a5af8a39c
 SHA512:
-  metadata.gz: a0e233e5c53c6ee3c7a32239ca20625a58deb1b385af022cb582433d02070f7b861873f44cef5fe786ede0307caee4105202e49844902e8d75e14039623bdc74
-  data.tar.gz: 238ca3ba9a777686867752bc4abbf1d10081d73215e3c0f7ed0e9360f7c380298b4736177c703f1c921fb22b4296e7544379bef69021408f9e9ad86280a3716c
+  metadata.gz: a75d25669ab2d7e96dbccb107ae30f817e5fd6a291651b68bc56dbea21f50bd5c8b24b0633dd21d6faeeb5a8abd999abc6baf57ac9c7e8c3c06aa4542dc570d3
+  data.tar.gz: 7d2e5af151c02923bf4e64f05bc277711228729fa08ddee3dd79699623efc33f3689290c1739c025d7851db0b59d90feeac99e3a65c9a13862fac8f36ddf46b6

data/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.2.6] - 2026-02-25
+
+### Changed
+
+- Extract shared class-inspection logic into `ClassInspector` concern to reduce duplication across detectors
+- Refactor all detectors to use `ClassInspector` for parent class and naming convention checks
+- Simplify `Analyzer` by removing redundant delegation and streamlining detector orchestration
+- Clean up `DelegationParser` with leaner parsing logic
+- Improve `Base` detector with consolidated helper methods
+- Streamline reporter classes (`Base`, `Console`) for clarity and consistency
+
+### Removed
+
+- Remove duplicated class-matching code from `CallbackQuery`, `CountInIteration`, `CustomMethodQuery`, `DecoratorNPlusOne`, `DelegationNPlusOne`, `LoopAssociation`, and `SerializerNesting`
+
 ## [1.2.5] - 2026-02-21
 
 ### Added

data/README.md

@@ -10,7 +10,7 @@
 
 <p align="center">
   <a href="https://github.com/hamzagedikkaya/eager_eye/actions/workflows/main.yml"><img src="https://github.com/hamzagedikkaya/eager_eye/actions/workflows/main.yml/badge.svg" alt="CI"></a>
-  <a href="https://rubygems.org/gems/eager_eye"><img src="https://img.shields.io/badge/gem-v1.2.5-red.svg" alt="Gem Version"></a>
+  <a href="https://rubygems.org/gems/eager_eye"><img src="https://img.shields.io/badge/gem-v1.2.6-red.svg" alt="Gem Version"></a>
   <a href="https://github.com/hamzagedikkaya/eager_eye"><img src="https://img.shields.io/badge/coverage-95%25-brightgreen.svg" alt="Coverage"></a>
   <a href="https://www.ruby-lang.org/"><img src="https://img.shields.io/badge/ruby-%3E%3D%203.1-ruby.svg" alt="Ruby"></a>
   <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>

data/lib/eager_eye/analyzer.rb

@@ -27,38 +27,30 @@ module EagerEye
 
     def run
       @issues = []
-      collect_association_preloads
-      collect_delegation_maps
-      analyze_files
+      collect_model_metadata
+      ruby_files.each { |file_path| analyze_file(file_path) }
       @issues
     end
 
     private
 
-    def collect_association_preloads
+    def collect_model_metadata
       model_files.each do |file_path|
         ast = parse_source(File.read(file_path))
         next unless ast
 
-        parser = AssociationParser.new
-        parser.parse_model(ast, extract_model_name(file_path))
-        @association_preloads.merge!(parser.preloaded_associations)
-      end
-    rescue StandardError
-      nil
-    end
+        model_name = extract_model_name(file_path)
 
-    def collect_delegation_maps
-      model_files.each do |file_path|
-        ast = parse_source(File.read(file_path))
-        next unless ast
+        assoc_parser = AssociationParser.new
+        assoc_parser.parse_model(ast, model_name)
+        @association_preloads.merge!(assoc_parser.preloaded_associations)
 
-        parser = DelegationParser.new
-        parser.parse_model(ast, extract_model_name(file_path))
-        @delegation_maps.merge!(parser.delegation_maps)
+        deleg_parser = DelegationParser.new
+        deleg_parser.parse_model(ast, model_name)
+        @delegation_maps.merge!(deleg_parser.delegation_maps)
+      rescue Errno::ENOENT, Errno::EACCES
+        next
       end
-    rescue StandardError
-      nil
     end
 
     def model_files
@@ -66,25 +58,19 @@ module EagerEye
     end
 
     def extract_model_name(file_path)
-      File.basename(file_path, ".rb").camelize
+      name = File.basename(file_path, ".rb")
+      name.respond_to?(:camelize) ? name.camelize : name.split("_").map(&:capitalize).join
     end
 
-    def analyze_files
-      ruby_files.each { |file_path| analyze_file(file_path) }
+    def ruby_files
+      paths.flat_map { |path| resolve_path(path) }.reject { |file| excluded?(file) }
     end
 
-    def ruby_files
-      all_files = paths.flat_map do |path|
-        if File.file?(path)
-          [path]
-        elsif File.directory?(path)
-          Dir.glob(File.join(path, "**", "*.rb"))
-        else
-          Dir.glob(path)
-        end
-      end
+    def resolve_path(path)
+      return [path] if File.file?(path)
+      return Dir.glob(File.join(path, "**", "*.rb")) if File.directory?(path)
 
-      all_files.reject { |file| excluded?(file) }
+      Dir.glob(path)
     end
 
     def excluded?(file_path)
@@ -103,9 +89,10 @@ module EagerEye
 
       enabled_detectors.each do |detector|
         file_issues = detector.detect(*detector_args(detector, ast, file_path))
-        file_issues.reject! { |issue| comment_parser.disabled_at?(issue.line_number, issue.detector) }
-        file_issues.select! { |issue| issue.meets_minimum_severity?(min_severity) }
-        @issues.concat(file_issues)
+        @issues.concat(file_issues.select do |issue|
+          !comment_parser.disabled_at?(issue.line_number, issue.detector) &&
+            issue.meets_minimum_severity?(min_severity)
+        end)
       end
     rescue Errno::ENOENT, Errno::EACCES => e
       warn "EagerEye: Could not read file #{file_path}: #{e.message}"
@@ -126,8 +113,7 @@ module EagerEye
 
     def enabled_detectors
       @enabled_detectors ||= EagerEye.configuration.enabled_detectors.filter_map do |name|
-        detector_class = DETECTOR_CLASSES[name]
-        detector_class&.new
+        DETECTOR_CLASSES[name]&.new
       end
     end
   end

data/lib/eager_eye/comment_parser.rb

@@ -5,7 +5,6 @@ module EagerEye
     FILE_DISABLE_PATTERN = /eager_eye:disable-file\s+(.+?)(?:\s+--|$)/i
     NEXT_LINE_PATTERN = /eager_eye:disable-next-line(?:\s+(.+?))?(?:\s+--|$)/i
     BLOCK_START_PATTERN = /eager_eye:disable-block(?:\s+(.+?))?(?:\s+--|$)/i
-    BLOCK_END_PATTERN = /eager_eye:enable-block(?:\s+(.+?))?(?:\s+--|$)/i
     INLINE_DISABLE_PATTERN = /eager_eye:disable\s+(.+?)(?:\s+--|$)/i
     ENABLE_PATTERN = /eager_eye:enable(?:\s+(.+?))?(?:\s+--|$)/i
 

data/lib/eager_eye/delegation_parser.rb

@@ -24,50 +24,42 @@ module EagerEye
     end
 
     def check_delegate(node, model_name)
-      return unless bare_delegate_call?(node)
+      return unless delegate_call?(node)
 
       args = node.children[2..]
-      methods = delegate_methods(args)
+      methods = extract_sym_args(args)
       return if methods.empty?
 
       to_target = extract_to_target(args)
       return unless to_target
 
-      register_delegates(model_name, methods, to_target)
+      @delegation_maps[model_name] ||= {}
+      methods.each { |m| @delegation_maps[model_name][m] = to_target }
     end
 
-    def bare_delegate_call?(node)
+    def delegate_call?(node)
       node.type == :send && node.children[0].nil? && node.children[1] == :delegate
     end
 
-    def delegate_methods(args)
+    def extract_sym_args(args)
       args.select { |a| a&.type == :sym }.map { |a| a.children[0] }
     end
 
-    def register_delegates(model_name, methods, to_target)
-      @delegation_maps[model_name] ||= {}
-      methods.each { |m| @delegation_maps[model_name][m] = to_target }
-    end
-
     def extract_to_target(args)
       hash_arg = args.find { |a| a&.type == :hash }
       return unless hash_arg
 
-      to_pair = hash_arg.children.find { |p| to_key_pair?(p) }
-      extract_sym_value(to_pair)
-    end
-
-    def extract_sym_value(node)
-      return unless node
+      to_pair = find_to_pair(hash_arg)
+      return unless to_pair
 
-      value = node.children[1]
+      value = to_pair.children[1]
       value.children[0] if value&.type == :sym
     end
 
-    def to_key_pair?(pair)
-      pair.type == :pair &&
-        pair.children[0]&.type == :sym &&
-        pair.children[0].children[0] == :to
+    def find_to_pair(hash_node)
+      hash_node.children.find do |p|
+        p.type == :pair && p.children[0]&.type == :sym && p.children[0].children[0] == :to
+      end
     end
   end
 end

data/lib/eager_eye/detectors/base.rb

@@ -22,13 +22,12 @@ module EagerEye
       protected
 
       def create_issue(file_path:, line_number:, message:, severity: nil, suggestion: nil)
-        resolved_severity = severity || configured_severity
         Issue.new(
           detector: self.class.detector_name,
           file_path: file_path,
           line_number: line_number,
           message: message,
-          severity: resolved_severity,
+          severity: severity || configured_severity,
           suggestion: suggestion
         )
       end
@@ -73,6 +72,34 @@ module EagerEye
           symbols.add(key.children[0]) if key&.type == :sym
         end
       end
+
+      def extract_block_variable(block_node)
+        args = block_node&.children&.[](1)
+        first_arg = args&.children&.first
+        first_arg&.type == :arg ? first_arg.children[0] : nil
+      end
+
+      def receiver_chain_starts_with?(node, target_var)
+        return false unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :lvar then node.children[0] == target_var
+        when :send then receiver_chain_starts_with?(node.children[0], target_var)
+        else false
+        end
+      end
+
+      def reconstruct_chain(node)
+        return "" unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :lvar then node.children[0].to_s
+        when :send
+          receiver_str = reconstruct_chain(node.children[0])
+          receiver_str.empty? ? node.children[1].to_s : "#{receiver_str}.#{node.children[1]}"
+        else ""
+        end
+      end
     end
   end
 end

data/lib/eager_eye/detectors/callback_query.rb

@@ -41,7 +41,6 @@ module EagerEye
         @issues = []
         @file_path = file_path
         @callback_methods = {}
-
         return @issues unless ast
 
         find_callback_definitions(ast)
@@ -67,9 +66,7 @@ module EagerEye
         node.children[2..].each do |arg|
           next unless arg.is_a?(Parser::AST::Node) && arg.type == :sym
 
-          method_name = arg.children[0]
-          callback_type = node.children[1]
-          @callback_methods[method_name] = callback_type
+          @callback_methods[arg.children[0]] = node.children[1]
         end
       end
 
@@ -77,9 +74,8 @@ module EagerEye
         return unless node.is_a?(Parser::AST::Node)
 
         if node.type == :def && @callback_methods.key?(node.children[0])
-          method_name = node.children[0]
           body = node.children[2]
-          find_iterations_with_queries(body, method_name, @callback_methods[method_name]) if body
+          find_iterations_with_queries(body, node.children[0], @callback_methods[node.children[0]]) if body
         end
 
         node.children.each { |child| check_callback_methods(child) }
@@ -131,7 +127,6 @@ module EagerEye
       end
 
       def add_query_issue(node, method_name, callback_type)
-        query_method = node.children[1]
         suggestion = if transactional_callback?(callback_type)
                        "Callbacks run on every save/create/update. Move the query outside the iteration or preload data"
                      else
@@ -141,7 +136,7 @@ module EagerEye
         @issues << create_issue(
           file_path: @file_path,
           line_number: node.loc.line,
-          message: "Query method `.#{query_method}` found in `#{callback_type}` callback `:#{method_name}`",
+          message: "Query method `.#{node.children[1]}` found in `#{callback_type}` callback `:#{method_name}`",
           severity: :warning,
           suggestion: suggestion
         )
@@ -167,29 +162,6 @@ module EagerEye
         TRANSACTIONAL_CALLBACKS.include?(callback_type)
       end
 
-      def extract_block_variable(block_node)
-        args_node = block_node.children[1]
-        return nil unless args_node&.type == :args
-
-        first_arg = args_node.children[0]
-        return nil unless first_arg&.type == :arg
-
-        first_arg.children[0]
-      end
-
-      def receiver_chain_starts_with?(node, block_var)
-        return false unless node.is_a?(Parser::AST::Node)
-
-        case node.type
-        when :lvar
-          node.children[0] == block_var
-        when :send
-          receiver_chain_starts_with?(node.children[0], block_var)
-        else
-          false
-        end
-      end
-
       def non_ar_collection?(node)
         ns = root_namespace(node)
         ns && NON_AR_NAMESPACES.include?(ns)
@@ -199,10 +171,8 @@ module EagerEye
         return nil unless node.is_a?(Parser::AST::Node)
 
         case node.type
-        when :const
-          node.children[0].nil? ? node.children[1].to_s : root_namespace(node.children[0])
-        when :send, :block
-          root_namespace(node.children[0])
+        when :const then node.children[0].nil? ? node.children[1].to_s : root_namespace(node.children[0])
+        when :send, :block then root_namespace(node.children[0])
         end
       end
 

data/lib/eager_eye/detectors/concerns/class_inspector.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module EagerEye
+  module Detectors
+    module Concerns
+      module ClassInspector
+        HAS_MANY_ASSOCIATIONS = %w[
+          authors users owners creators admins members customers clients
+          posts articles comments categories tags children companies organizations
+          projects tasks items orders products accounts profiles settings
+          images avatars photos attachments documents
+        ].freeze
+
+        ACTIVE_STORAGE_METHODS = %i[
+          attached? attach attachment attachments blob blobs purge purge_later variant preview
+        ].freeze
+
+        private
+
+        def const_to_string(node)
+          return nil unless node&.type == :const
+
+          parts = []
+          current = node
+          while current&.type == :const
+            parts.unshift(current.children[1].to_s)
+            current = current.children[0]
+          end
+          parts.join("::")
+        end
+
+        def extract_class_name(class_node)
+          name_node = class_node.children[0]
+          name_node.children[1].to_s if name_node&.type == :const
+        end
+
+        def likely_association?(method_name)
+          HAS_MANY_ASSOCIATIONS.include?(method_name.to_s)
+        end
+
+        def collect_active_storage_lines(body)
+          lines = Set.new
+          traverse_ast(body) do |node|
+            lines << node.loc.line if node.type == :send && ACTIVE_STORAGE_METHODS.include?(node.children[1])
+          end
+          lines
+        end
+      end
+    end
+  end
+end

data/lib/eager_eye/detectors/count_in_iteration.rb

@@ -15,7 +15,6 @@ module EagerEye
       def detect(ast, file_path)
         @issues = []
         @file_path = file_path
-
         return @issues unless ast
 
         find_iteration_blocks(ast) do |block_body, block_var|
@@ -60,64 +59,23 @@ module EagerEye
       def array_returning_method?(node)
         return false unless node.is_a?(Parser::AST::Node) && node.type == :send
 
-        method_name = node.children[1].to_s
-        ARRAY_METHOD_SUFFIXES.any? { |suffix| method_name.end_with?(suffix) }
+        ARRAY_METHOD_SUFFIXES.any? { |suffix| node.children[1].to_s.end_with?(suffix) }
       end
 
       def association_call_on_block_var?(node, block_var)
-        return false unless node.is_a?(Parser::AST::Node) && node.type == :send
-
-        receiver = node.children[0]
-        return false unless receiver.is_a?(Parser::AST::Node)
-
-        return true if receiver.type == :lvar && receiver.children[0] == block_var
-
-        receiver.type == :send && chain_starts_with_block_var?(receiver, block_var)
-      end
-
-      def chain_starts_with_block_var?(node, block_var)
-        return false unless node.is_a?(Parser::AST::Node)
-
-        case node.type
-        when :lvar then node.children[0] == block_var
-        when :send then chain_starts_with_block_var?(node.children[0], block_var)
-        else false
-        end
-      end
-
-      def extract_block_variable(block_node)
-        args_node = block_node.children[1]
-        return nil unless args_node&.type == :args
-
-        first_arg = args_node.children[0]
-        first_arg&.type == :arg ? first_arg.children[0] : nil
+        node.is_a?(Parser::AST::Node) && node.type == :send &&
+          receiver_chain_starts_with?(node.children[0], block_var)
       end
 
       def add_issue(node)
-        receiver_chain = reconstruct_chain(node.children[0])
-
+        chain = reconstruct_chain(node.children[0])
         @issues << create_issue(
           file_path: @file_path,
           line_number: node.loc.line,
-          message: "`.count` called on `#{receiver_chain}` inside iteration always executes a COUNT query",
+          message: "`.count` called on `#{chain}` inside iteration always executes a COUNT query",
           suggestion: "Use `.size` instead (uses loaded collection) or add `counter_cache: true`"
         )
       end
-
-      def reconstruct_chain(node)
-        return "" unless node.is_a?(Parser::AST::Node)
-
-        case node.type
-        when :lvar
-          node.children[0].to_s
-        when :send
-          receiver_str = reconstruct_chain(node.children[0])
-          method = node.children[1]
-          receiver_str.empty? ? method.to_s : "#{receiver_str}.#{method}"
-        else
-          ""
-        end
-      end
     end
   end
 end

data/lib/eager_eye/detectors/custom_method_query.rb

@@ -22,8 +22,7 @@ module EagerEye
         @file_path = file_path
 
         find_iteration_blocks(ast) do |block_body, block_var, collection, definitions|
-          is_array_collection = collection_is_array?(collection, definitions)
-          check_block_for_query_methods(block_body, block_var, is_array_collection)
+          check_block_for_query_methods(block_body, block_var, collection_is_array?(collection, definitions))
         end
 
         @issues
@@ -71,52 +70,29 @@ module EagerEye
         return true if receiver_ends_with_safe_transform_method?(node.children[0])
 
         SAFE_QUERY_METHODS.include?(node.children[1]) &&
-          is_array_collection && receiver_is_only_block_var?(node.children[0], block_var)
+          is_array_collection && direct_block_var?(node.children[0], block_var)
       end
 
-      def receiver_is_only_block_var?(node, block_var)
+      def direct_block_var?(node, block_var)
         node.is_a?(Parser::AST::Node) && node.type == :lvar && node.children[0] == block_var
       end
 
-      def receiver_chain_starts_with?(node, block_var)
-        return false unless node.is_a?(Parser::AST::Node)
-
-        case node.type
-        when :lvar then node.children[0] == block_var
-        when :send then receiver_chain_starts_with?(node.children[0], block_var)
-        else false
-        end
-      end
-
-      def extract_block_variable(block_node)
-        args_node = block_node.children[1]
-        return nil unless args_node&.type == :args
-
-        first_arg = args_node.children[0]
-        first_arg&.type == :arg ? first_arg.children[0] : nil
-      end
-
       def collection_is_array?(node, definitions = {}, visited = Set.new)
         return false unless node.is_a?(Parser::AST::Node)
-        return false if visited.include?(node.object_id)
-
-        visited.add(node.object_id)
+        return false unless visited.add?(node.object_id)
 
         return true if %i[array hash].include?(node.type)
-        return check_lvar_collection?(node, definitions, visited) if node.type == :lvar
-        return check_send_collection?(node, definitions, visited) if node.type == :send
-
-        false
-      end
 
-      def check_lvar_collection?(node, definitions, visited)
-        return false unless definitions
-
-        definition = definitions[node.children[0]]
-        definition ? collection_is_array?(definition, definitions, visited) : false
+        case node.type
+        when :lvar
+          defn = definitions[node.children[0]]
+          defn && collection_is_array?(defn, definitions, visited)
+        when :send then send_returns_array?(node, definitions, visited)
+        else false
+        end
       end
 
-      def check_send_collection?(node, definitions, visited)
+      def send_returns_array?(node, definitions, visited)
         method_name = node.children[1]
         return true if %i[map select collect flat_map uniq compact].include?(method_name)
         return true if SAFE_TRANSFORM_METHODS.include?(method_name)
@@ -128,41 +104,23 @@ module EagerEye
         return false unless node.is_a?(Parser::AST::Node) && node.type == :send
 
         method_name = node.children[1]
-        SAFE_TRANSFORM_METHODS.include?(method_name) || array_column_method?(method_name)
+        SAFE_TRANSFORM_METHODS.include?(method_name) ||
+          ARRAY_COLUMN_SUFFIXES.any? { |suffix| method_name.to_s.end_with?(suffix) }
       end
 
       def receiver_is_query_chain?(node)
         node.is_a?(Parser::AST::Node) && node.type == :send && QUERY_METHODS.include?(node.children[1])
       end
 
-      def array_column_method?(method_name)
-        method_str = method_name.to_s
-        ARRAY_COLUMN_SUFFIXES.any? { |suffix| method_str.end_with?(suffix) }
-      end
-
       def add_issue(node)
-        method_name = node.children[1]
-        association_chain = reconstruct_chain(node.children[0])
-
+        chain = reconstruct_chain(node.children[0])
         @issues << create_issue(
           file_path: @file_path,
           line_number: node.loc.line,
-          message: "Query method `.#{method_name}` called on `#{association_chain}` inside iteration",
+          message: "Query method `.#{node.children[1]}` called on `#{chain}` inside iteration",
           suggestion: "This query executes on each iteration. Consider preloading data or restructuring the query."
         )
       end
-
-      def reconstruct_chain(node)
-        return "" unless node.is_a?(Parser::AST::Node)
-
-        case node.type
-        when :lvar then node.children[0].to_s
-        when :send
-          receiver_str = reconstruct_chain(node.children[0])
-          receiver_str.empty? ? node.children[1].to_s : "#{receiver_str}.#{node.children[1]}"
-        else ""
-        end
-      end
     end
   end
 end

data/lib/eager_eye/detectors/decorator_n_plus_one.rb

@@ -1,18 +1,14 @@
 # frozen_string_literal: true
 
+require_relative "concerns/class_inspector"
+
 module EagerEye
   module Detectors
     class DecoratorNPlusOne < Base
+      include Concerns::ClassInspector
+
       DECORATOR_PATTERNS = %w[Draper::Decorator SimpleDelegator Delegator].freeze
       OBJECT_REFS = %i[object __getobj__ source model].freeze
-      ACTIVE_STORAGE_METHODS = %i[attached? attach attachment attachments blob blobs purge purge_later variant
-                                  preview].freeze
-      HAS_MANY_ASSOCIATIONS = %w[
-        authors users owners creators admins members customers clients
-        posts articles comments categories tags children companies organizations
-        projects tasks items orders products accounts profiles settings
-        images avatars photos attachments documents
-      ].freeze
 
       def self.detector_name
         :decorator_n_plus_one
@@ -22,34 +18,21 @@ module EagerEye
         return [] unless ast
 
         issues = []
-
         traverse_ast(ast) do |node|
-          next unless decorator_class?(node)
+          next unless node.type == :class && decorator_class?(node)
 
           find_association_accesses(node, file_path, issues)
         end
-
         issues
       end
 
       private
 
       def decorator_class?(node)
-        return false unless node.type == :class
-
         class_name = extract_class_name(node)
         return false unless class_name
 
-        decorator_name_pattern?(class_name) || inherits_from_decorator?(node)
-      end
-
-      def decorator_name_pattern?(class_name)
-        class_name.end_with?("Decorator", "Presenter", "ViewObject")
-      end
-
-      def extract_class_name(class_node)
-        name_node = class_node.children[0]
-        name_node.children[1].to_s if name_node&.type == :const
+        class_name.end_with?("Decorator", "Presenter", "ViewObject") || inherits_from_decorator?(node)
       end
 
       def inherits_from_decorator?(class_node)
@@ -60,18 +43,6 @@ module EagerEye
         DECORATOR_PATTERNS.any? { |p| parent_name&.include?(p.split("::").last) }
       end
 
-      def const_to_string(node)
-        return nil unless node&.type == :const
-
-        parts = []
-        current = node
-        while current&.type == :const
-          parts.unshift(current.children[1].to_s)
-          current = current.children[0]
-        end
-        parts.join("::")
-      end
-
       def find_association_accesses(class_node, file_path, issues)
         body = class_node.children[2]
         return unless body
@@ -88,49 +59,25 @@ module EagerEye
 
         storage_lines = collect_active_storage_lines(method_body)
         traverse_ast(method_body) do |node|
-          next unless association_access?(node, storage_lines)
+          next unless node.type == :send
+          next if storage_lines.include?(node.loc.line)
 
           receiver = node.children[0]
           method_name = node.children[1]
-          issues << create_decorator_issue(file_path, node.loc.line, receiver, method_name)
+          next unless object_reference?(receiver) && likely_association?(method_name)
+
+          ref = receiver.children[1]
+          issues << create_issue(
+            file_path: file_path,
+            line_number: node.loc.line,
+            message: "N+1 in decorator: `#{ref}.#{method_name}` loads association on each decorated object",
+            suggestion: "Eager load :#{method_name} in the controller before decorating the collection"
+          )
         end
       end
 
-      def association_access?(node, storage_lines)
-        return false unless node.type == :send
-        return false if storage_lines.include?(node.loc.line)
-
-        object_reference?(node.children[0]) && likely_association?(node.children[1])
-      end
-
-      def collect_active_storage_lines(body)
-        lines = Set.new
-        traverse_ast(body) do |node|
-          next unless node.type == :send && ACTIVE_STORAGE_METHODS.include?(node.children[1])
-
-          lines << node.loc.line
-        end
-        lines
-      end
-
       def object_reference?(node)
-        return false unless node&.type == :send
-
-        node.children[0].nil? && OBJECT_REFS.include?(node.children[1])
-      end
-
-      def likely_association?(method_name)
-        HAS_MANY_ASSOCIATIONS.include?(method_name.to_s)
-      end
-
-      def create_decorator_issue(file_path, line, receiver, method_name)
-        ref = receiver.children[1]
-        create_issue(
-          file_path: file_path,
-          line_number: line,
-          message: "N+1 in decorator: `#{ref}.#{method_name}` loads association on each decorated object",
-          suggestion: "Eager load :#{method_name} in the controller before decorating the collection"
-        )
+        node&.type == :send && node.children[0].nil? && OBJECT_REFS.include?(node.children[1])
       end
     end
   end

data/lib/eager_eye/detectors/delegation_n_plus_one.rb

@@ -23,14 +23,11 @@ module EagerEye
           next unless iteration_block?(node)
 
           block_var = extract_block_variable(node)
-          next unless block_var
-
           block_body = node.children[2]
-          next unless block_body
+          next unless block_var && block_body
 
           collection_node = node.children[0]
-          model_name = infer_model_name(collection_node)
-          delegates = build_delegates(model_name, delegation_maps, local_delegates)
+          delegates = build_delegates(infer_model_name(collection_node), delegation_maps, local_delegates)
           next if delegates.empty?
 
           included = extract_included_associations(collection_node)
@@ -45,17 +42,13 @@ module EagerEye
       def collect_local_delegates(ast)
         delegates = {}
         traverse_ast(ast) do |node|
-          next unless delegate_call?(node)
+          next unless node.type == :send && node.children[0].nil? && node.children[1] == :delegate
 
           extract_delegate_info(node, delegates)
         end
         delegates
       end
 
-      def delegate_call?(node)
-        node.type == :send && node.children[0].nil? && node.children[1] == :delegate
-      end
-
       def extract_delegate_info(node, delegates)
         args = node.children[2..]
         methods = args.select { |a| a&.type == :sym }.map { |a| a.children[0] }
@@ -71,21 +64,17 @@ module EagerEye
         hash_arg = args.find { |a| a&.type == :hash }
         return unless hash_arg
 
-        to_pair = hash_arg.children.find { |p| to_key_pair?(p) }
-        extract_sym_value(to_pair)
-      end
-
-      def extract_sym_value(node)
-        return unless node
+        to_pair = find_to_pair(hash_arg)
+        return unless to_pair
 
-        value = node.children[1]
+        value = to_pair.children[1]
         value.children[0] if value&.type == :sym
       end
 
-      def to_key_pair?(pair)
-        pair.type == :pair &&
-          pair.children[0]&.type == :sym &&
-          pair.children[0].children[0] == :to
+      def find_to_pair(hash_node)
+        hash_node.children.find do |p|
+          p.type == :pair && p.children[0]&.type == :sym && p.children[0].children[0] == :to
+        end
       end
 
       def build_delegates(model_name, delegation_maps, local_delegates)
@@ -94,26 +83,14 @@ module EagerEye
       end
 
       def iteration_block?(node)
-        node.type == :block &&
-          node.children[0]&.type == :send &&
+        node.type == :block && node.children[0]&.type == :send &&
           ITERATION_METHODS.include?(node.children[0].children[1])
       end
 
-      def extract_block_variable(block_node)
-        args = block_node&.children&.[](1)
-        first_arg = args&.children&.first
-        first_arg&.type == :arg ? first_arg.children[0] : nil
-      end
-
       def infer_model_name(node)
-        root = find_root_receiver(node)
-        root&.type == :const ? root.children[1].to_s : nil
-      end
-
-      def find_root_receiver(node)
         current = node
         current = current.children[0] while current&.type == :send
-        current
+        current&.type == :const ? current.children[1].to_s : nil
       end
 
       def extract_included_associations(collection_node)
@@ -122,55 +99,45 @@ module EagerEye
 
         current = collection_node
         while current&.type == :send
-          extract_from_preload(current, included) if PRELOAD_METHODS.include?(current.children[1])
+          if PRELOAD_METHODS.include?(current.children[1])
+            included.merge(extract_symbols_from_args(extract_method_args(current)))
+          end
           current = current.children[0]
         end
         included
       end
 
-      def extract_from_preload(method_node, included_set)
-        args = extract_method_args(method_node)
-        included_set.merge(extract_symbols_from_args(args))
-      end
-
       def find_delegated_calls(block_body, block_var, delegates, included, file_path, issues)
         reported = Set.new
         traverse_ast(block_body) do |node|
           target_assoc = delegation_target(node, block_var, delegates, included, reported)
           next unless target_assoc
 
-          issues << create_delegation_issue(node, block_var, target_assoc, file_path)
+          method = node.children[1]
+          issues << create_issue(
+            file_path: file_path,
+            line_number: node.loc.line,
+            message: "Potential N+1: `#{block_var}.#{method}` is delegated to `#{target_assoc}` — " \
+                     "loads `#{target_assoc}` on each iteration",
+            suggestion: "Use `includes(:#{target_assoc})` before iterating"
+          )
         end
       end
 
       def delegation_target(node, block_var, delegates, included, reported)
-        return unless node.type == :send
-        return unless block_var_receiver?(node, block_var)
+        return unless node.type == :send && block_var_receiver?(node, block_var)
 
         method = node.children[1]
         target_assoc = delegates[method]
-        return unless target_assoc
-        return if included.include?(target_assoc)
-        return unless reported.add?("#{node.loc.line}:#{method}")
+        return unless target_assoc && !included.include?(target_assoc)
 
-        target_assoc
+        reported.add?("#{node.loc.line}:#{method}") ? target_assoc : nil
       end
 
       def block_var_receiver?(node, block_var)
         receiver = node.children[0]
         receiver&.type == :lvar && receiver.children[0] == block_var
       end
-
-      def create_delegation_issue(node, block_var, target_assoc, file_path)
-        method = node.children[1]
-        create_issue(
-          file_path: file_path,
-          line_number: node.loc.line,
-          message: "Potential N+1: `#{block_var}.#{method}` is delegated to `#{target_assoc}` — " \
-                   "loads `#{target_assoc}` on each iteration",
-          suggestion: "Use `includes(:#{target_assoc})` before iterating"
-        )
-      end
     end
   end
 end

data/lib/eager_eye/detectors/loop_association.rb

@@ -51,8 +51,7 @@ module EagerEye
 
           included = extract_included_associations(collection_node)
           included.merge(extract_variable_preloads(collection_node))
-          model_name = infer_model_name_from_collection(collection_node)
-          included.merge(get_association_preloads(model_name))
+          included.merge(get_association_preloads(infer_model_name_from_collection(collection_node)))
 
           find_association_calls(block_body, block_var, file_path, issues, included)
         end
@@ -63,10 +62,9 @@ module EagerEye
       private
 
       def get_association_preloads(model_name)
-        key = "#{model_name}#*"
         preloaded = Set.new
-        @association_preloads&.each do |assoc_key, assocs|
-          preloaded.merge(assocs) if assoc_key.start_with?(key)
+        @association_preloads&.each do |key, assocs|
+          preloaded.merge(assocs) if key.start_with?("#{model_name}#")
         end
         preloaded
       end
@@ -83,12 +81,6 @@ module EagerEye
           ITERATION_METHODS.include?(node.children[0].children[1])
       end
 
-      def extract_block_variable(block_node)
-        args = block_node&.children&.[](1)
-        first_arg = args&.children&.first
-        first_arg&.type == :arg ? first_arg.children[0] : nil
-      end
-
       def extract_included_associations(collection_node)
         included = Set.new
         return included unless collection_node&.type == :send
@@ -142,12 +134,12 @@ module EagerEye
 
       def find_last_send_method(node)
         current = node
-        current = current.children[0] while current&.type == :send && !single_record_method?(current)
-        current&.type == :send ? current.children[1] : nil
-      end
+        while current&.type == :send
+          return current.children[1] if SINGLE_RECORD_METHODS.include?(current.children[1])
 
-      def single_record_method?(node)
-        SINGLE_RECORD_METHODS.include?(node.children[1])
+          current = current.children[0]
+        end
+        nil
       end
 
       def single_record_iteration?(node)
@@ -158,47 +150,40 @@ module EagerEye
       end
 
       def extract_includes_from_method(method_node, included_set)
-        args = extract_method_args(method_node)
-        included_set.merge(extract_symbols_from_args(args))
+        included_set.merge(extract_symbols_from_args(extract_method_args(method_node)))
       end
 
       def find_association_calls(node, block_var, file_path, issues, included_associations = Set.new)
         reported = Set.new
         traverse_ast(node) do |child|
-          next unless should_report_issue?(child, block_var, reported, included_associations)
-
-          add_n_plus_one_issue(child, block_var, file_path, issues, reported)
+          next unless reportable_association_call?(child, block_var, reported, included_associations)
+
+          method = child.children[1]
+          issues << create_issue(
+            file_path: file_path,
+            line_number: child.loc.line,
+            message: "Potential N+1 query: `#{block_var}.#{method}` called inside loop",
+            suggestion: "Use `includes(:#{method})` before iterating"
+          )
         end
       end
 
-      def should_report_issue?(child, block_var, reported, included)
-        return false unless child.type == :send
+      def reportable_association_call?(node, block_var, reported, included)
+        return false unless node.type == :send
 
-        receiver = child.children[0]
-        method = child.children[1]
+        receiver = node.children[0]
+        method = node.children[1]
         return false unless receiver&.type == :lvar && receiver.children[0] == block_var
-        return false if excluded?(method, included)
+        return false if excluded_method?(method, included)
 
-        key = "#{child.loc.line}:#{method}"
-        !reported.include?(key) && reported.add(key)
+        reported.add?("#{node.loc.line}:#{method}")
       end
 
-      def excluded?(method, included)
+      def excluded_method?(method, included)
         EXCLUDED_METHODS.include?(method) ||
           !ASSOCIATION_NAMES.include?(method.to_s) ||
           included.include?(method)
       end
-
-      def add_n_plus_one_issue(node, block_var, file_path, issues, reported)
-        method = node.children[1]
-        reported << "#{node.loc.line}:#{method}"
-        issues << create_issue(
-          file_path: file_path,
-          line_number: node.loc.line,
-          message: "Potential N+1 query: `#{block_var}.#{method}` called inside loop",
-          suggestion: "Use `includes(:#{method})` before iterating"
-        )
-      end
     end
   end
 end

data/lib/eager_eye/detectors/serializer_nesting.rb

@@ -1,19 +1,15 @@
 # frozen_string_literal: true
 
+require_relative "concerns/class_inspector"
+
 module EagerEye
   module Detectors
     class SerializerNesting < Base
+      include Concerns::ClassInspector
+
       SERIALIZER_PATTERNS = %w[ActiveModel::Serializer ActiveModelSerializers::Model Blueprinter::Base Alba::Resource].freeze
       ATTRIBUTE_METHODS = %i[attribute field attributes].freeze
       OBJECT_REFS = %i[object record resource].freeze
-      ACTIVE_STORAGE_METHODS = %i[attached? attach attachment attachments blob blobs purge purge_later variant
-                                  preview].freeze
-      HAS_MANY_ASSOCIATIONS = %w[
-        authors users owners creators admins members customers clients
-        posts articles comments categories tags children companies organizations
-        projects tasks items orders products accounts profiles settings
-        images avatars photos attachments documents
-      ].freeze
 
       def self.detector_name
         :serializer_nesting
@@ -23,21 +19,17 @@ module EagerEye
         return [] unless ast
 
         issues = []
-
         traverse_ast(ast) do |node|
-          next unless serializer_class?(node)
+          next unless node.type == :class && serializer_class?(node)
 
           find_nested_associations(node, file_path, issues)
         end
-
         issues
       end
 
       private
 
       def serializer_class?(node)
-        return false unless node.type == :class
-
         class_name = extract_class_name(node)
         return false unless class_name
 
@@ -45,11 +37,6 @@ module EagerEye
           inherits_from_serializer?(node) || includes_serializer_module?(node)
       end
 
-      def extract_class_name(class_node)
-        name_node = class_node.children[0]
-        name_node.children[1].to_s if name_node&.type == :const
-      end
-
       def inherits_from_serializer?(class_node)
         parent_node = class_node.children[1]
         return false unless parent_node
@@ -73,18 +60,6 @@ module EagerEye
         arg && const_to_string(arg)&.include?("Alba")
       end
 
-      def const_to_string(node)
-        return nil unless node&.type == :const
-
-        parts = []
-        current = node
-        while current&.type == :const
-          parts.unshift(current.children[1].to_s)
-          current = current.children[0]
-        end
-        parts.join("::")
-      end
-
       def find_nested_associations(class_node, file_path, issues)
         body = class_node.children[2]
         return unless body
@@ -121,16 +96,6 @@ module EagerEye
         end
       end
 
-      def collect_active_storage_lines(block_body)
-        lines = Set.new
-        traverse_ast(block_body) do |node|
-          next unless node.type == :send && ACTIVE_STORAGE_METHODS.include?(node.children[1])
-
-          lines << node.loc.line
-        end
-        lines
-      end
-
       def object_reference?(node)
         return false unless node
 
@@ -148,10 +113,6 @@ module EagerEye
         else "object"
         end
       end
-
-      def likely_association?(method_name)
-        HAS_MANY_ASSOCIATIONS.include?(method_name.to_s)
-      end
     end
   end
 end

data/lib/eager_eye/reporters/base.rb

@@ -19,17 +19,13 @@ module EagerEye
         issues.group_by(&:file_path)
       end
 
-      def info_count
-        issues.count { |i| i.severity == :info }
+      def severity_counts
+        @severity_counts ||= issues.map(&:severity).tally
       end
 
-      def warning_count
-        issues.count { |i| i.severity == :warning }
-      end
-
-      def error_count
-        issues.count { |i| i.severity == :error }
-      end
+      def info_count = severity_counts.fetch(:info, 0)
+      def warning_count = severity_counts.fetch(:warning, 0)
+      def error_count = severity_counts.fetch(:error, 0)
     end
   end
 end

data/lib/eager_eye/reporters/console.rb

@@ -73,12 +73,12 @@ module EagerEye
       end
 
       def summary
-        t = issues.size
-        e = error_count
-        w = warning_count
-        i = info_count
-        "Total: #{t} issue#{"s" unless t == 1} " \
-          "(#{e} error#{"s" unless e == 1}, #{w} warning#{"s" unless w == 1}, #{i} info)"
+        "Total: #{pluralize(issues.size, "issue")} " \
+          "(#{pluralize(error_count, "error")}, #{pluralize(warning_count, "warning")}, #{info_count} info)"
+      end
+
+      def pluralize(count, word)
+        "#{count} #{word}#{"s" unless count == 1}"
       end
 
       def colorize(text, color)

data/lib/eager_eye/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EagerEye
-  VERSION = "1.2.5"
+  VERSION = "1.2.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eager_eye
 version: !ruby/object:Gem::Version
-  version: 1.2.5
+  version: 1.2.6
 platform: ruby
 authors:
 - hamzagedikkaya
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-22 00:00:00.000000000 Z
+date: 2026-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast
@@ -67,6 +67,7 @@ files:
 - lib/eager_eye/delegation_parser.rb
 - lib/eager_eye/detectors/base.rb
 - lib/eager_eye/detectors/callback_query.rb
+- lib/eager_eye/detectors/concerns/class_inspector.rb
 - lib/eager_eye/detectors/concerns/non_ar_source_detector.rb
 - lib/eager_eye/detectors/count_in_iteration.rb
 - lib/eager_eye/detectors/custom_method_query.rb