eager_eye 1.2.4 → 1.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2dee00b4a1b227d3fe506af3663b4a00730c312d61f9a1db876c4a59e7cbbd62
-  data.tar.gz: 1ce8596e9752c3b2f4fc2fa2d9463fcb9eeca1f50f9031c9ef1acbaef95ba08f
+  metadata.gz: 6fa0e6e3acb2c37751e7ab49a58826a016a68c7a33cc6305ddb6b82d6787c462
+  data.tar.gz: af81d8c0cfde13914b00a9f64b4b1bef6731b12902a1358c7f27473c2ab9a68d
 SHA512:
-  metadata.gz: 1c453c88107dfa5b3fbbdf1c66a2f2ca5fc2d2df3a99f91e27827f36a720e59d4974e9f880fad2668adf05116a81bcd69b8cdca6d3a0c0e24b8f3332f3c886a1
-  data.tar.gz: a1bc480d5b3d1d82eb8eccb7697ff50cab9ba94fbf127a08cd39f3278dfe90a95ebc14df28cf518e26bac86ad2ba59eaacdb5efc783e58caae8187d670b4f071
+  metadata.gz: a0e233e5c53c6ee3c7a32239ca20625a58deb1b385af022cb582433d02070f7b861873f44cef5fe786ede0307caee4105202e49844902e8d75e14039623bdc74
+  data.tar.gz: 238ca3ba9a777686867752bc4abbf1d10081d73215e3c0f7ed0e9360f7c380298b4736177c703f1c921fb22b4296e7544379bef69021408f9e9ad86280a3716c

data/.rubocop.yml

@@ -20,7 +20,7 @@ Metrics/BlockLength:
     - "lib/eager_eye/railtie.rb"
 
 Metrics/ClassLength:
-  Max: 165
+  Max: 170
 
 Metrics/ParameterLists:
   Max: 6

data/CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.2.5] - 2026-02-21
+
+### Added
+
+- **New Detector: `DecoratorNPlusOne`** - Detects N+1 queries inside decorator/presenter classes
+  - Catches `object.comments.map(...)`, `__getobj__.items.each { ... }`, `model.posts`, `source.tags` patterns
+  - Identifies decorator classes by inheritance (`Draper::Decorator`, `SimpleDelegator`, `Delegator`) or name suffix (`Decorator`, `Presenter`, `ViewObject`)
+  - Targets all four object reference styles: `object`, `__getobj__`, `source`, `model`
+  - Skips ActiveStorage methods (`attached?`, `blob`, `variant`, etc.) to prevent false positives
+  - Suggests eager loading in the controller before decorating the collection
+
 ## [1.2.4] - 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.4-red.svg" alt="Gem Version"></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://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>
@@ -42,7 +42,7 @@
 
 ## Features
 
-✨ **Detects 8 types of N+1 problems:**
+✨ **Detects 9 types of N+1 problems:**
 - Loop associations (queries in iterations)
 - Serializer nesting issues
 - Missing counter caches
@@ -51,6 +51,7 @@
 - Callback query N+1s
 - Pluck to array misuse
 - Delegation N+1s (hidden via `delegate :method, to: :association`)
+- Decorator N+1s (Draper, SimpleDelegator, Presenter, ViewObject)
 
 🔧 **Developer-friendly:**
 - Inline suppression (like RuboCop)
@@ -369,6 +370,34 @@ EagerEye detects these by:
 2. Tracking which methods delegate to which associations
 3. Flagging calls to those methods inside iteration blocks when the association is not preloaded
 
+### 9. Decorator N+1
+
+Detects N+1 queries inside Draper decorators, SimpleDelegator subclasses, and classes named `Decorator`, `Presenter`, or `ViewObject`. Each decorator wraps a single record — when a collection is decorated without preloading, every method that accesses an association triggers a new query per record.
+
+```ruby
+# Bad - N+1 on each decorated post
+class PostDecorator < Draper::Decorator
+  def comment_summary
+    object.comments.map(&:body).join(", ")   # Query for each post!
+  end
+
+  def tag_list
+    object.tags.map(&:name).join(", ")        # Another query for each post!
+  end
+end
+
+# Controller - no includes = N+1
+@posts = Post.all.decorate
+
+# Good - Eager load before decorating
+@posts = Post.includes(:comments, :tags).all.decorate
+```
+
+Supports the following object references inside decorators:
+- `object` — Draper standard
+- `__getobj__` — SimpleDelegator standard
+- `source`, `model` — alternative Draper aliases
+
 ## Inline Suppression
 
 Suppress false positives using inline comments (RuboCop-style):
@@ -412,6 +441,7 @@ Both CamelCase and snake_case formats are accepted:
 | Callback Query | `CallbackQuery` | `callback_query` |
 | Pluck to Array | `PluckToArray` | `pluck_to_array` |
 | Delegation N+1 | `DelegationNPlusOne` | `delegation_n_plus_one` |
+| Decorator N+1 | `DecoratorNPlusOne` | `decorator_n_plus_one` |
 | All Detectors | `all` | `all` |
 
 ## Auto-fix (Experimental)
@@ -515,6 +545,7 @@ enabled_detectors:
   - callback_query
   - pluck_to_array
   - delegation_n_plus_one
+  - decorator_n_plus_one
 
 # Severity levels per detector (error, warning, info)
 severity_levels:
@@ -525,6 +556,7 @@ severity_levels:
   callback_query: warning
   pluck_to_array: warning        # Optimization
   delegation_n_plus_one: warning # Hidden delegation N+1
+  decorator_n_plus_one: warning  # Decorator/Presenter N+1
   missing_counter_cache: info    # Suggestion
 
 # Minimum severity to report (default: info)

data/lib/eager_eye/analyzer.rb

@@ -12,7 +12,8 @@ module EagerEye
       count_in_iteration: Detectors::CountInIteration,
       callback_query: Detectors::CallbackQuery,
       pluck_to_array: Detectors::PluckToArray,
-      delegation_n_plus_one: Detectors::DelegationNPlusOne
+      delegation_n_plus_one: Detectors::DelegationNPlusOne,
+      decorator_n_plus_one: Detectors::DecoratorNPlusOne
     }.freeze
 
     attr_reader :paths, :issues, :association_preloads, :delegation_maps

data/lib/eager_eye/configuration.rb

@@ -8,7 +8,7 @@ module EagerEye
     DEFAULT_DETECTORS = %i[
       loop_association serializer_nesting missing_counter_cache
       custom_method_query count_in_iteration callback_query
-      pluck_to_array delegation_n_plus_one
+      pluck_to_array delegation_n_plus_one decorator_n_plus_one
     ].freeze
 
     DEFAULT_SEVERITY_LEVELS = {
@@ -19,7 +19,8 @@ module EagerEye
       count_in_iteration: :warning,
       callback_query: :warning,
       pluck_to_array: :warning,
-      delegation_n_plus_one: :warning
+      delegation_n_plus_one: :warning,
+      decorator_n_plus_one: :warning
     }.freeze
 
     VALID_SEVERITIES = %i[info warning error].freeze

data/lib/eager_eye/detectors/callback_query.rb

@@ -29,6 +29,9 @@ module EagerEye
       ITERATION_METHODS = %i[each map select find_all reject collect
                              find_each find_in_batches in_batches].freeze
       AR_BATCH_METHODS = %i[find_each find_in_batches in_batches].freeze
+      NON_AR_NAMESPACES = %w[Sidekiq Redis ActionCable ActionMailer Kafka].freeze
+      TRANSACTIONAL_CALLBACKS = %i[before_validation before_save before_create before_update before_destroy
+                                   around_save around_create around_update around_destroy].freeze
 
       def self.detector_name
         :callback_query
@@ -87,7 +90,8 @@ module EagerEye
 
         if iteration_block?(node)
           block_var = extract_block_variable(node)
-          if block_var && contains_ar_query_on_variable?(node, block_var)
+          collection = node.children[0].children[0]
+          if block_var && !non_ar_collection?(collection) && contains_ar_query_on_variable?(node, block_var)
             add_iteration_issue(node, method_name, callback_type)
             find_query_calls_in_block(node, method_name, callback_type, block_var)
           end
@@ -128,26 +132,41 @@ module EagerEye
 
       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
+                       "Callbacks run on every save/create/update. Consider moving to a background job"
+                     end
 
         @issues << create_issue(
           file_path: @file_path,
           line_number: node.loc.line,
           message: "Query method `.#{query_method}` found in `#{callback_type}` callback `:#{method_name}`",
           severity: :warning,
-          suggestion: "Callbacks run on every save/create/update. Consider moving to a background job"
+          suggestion: suggestion
         )
       end
 
       def add_iteration_issue(node, method_name, callback_type)
+        suggestion = if transactional_callback?(callback_type)
+                       "Avoid DB queries in before_*/around_* callbacks. Preload data outside the iteration instead"
+                     else
+                       "Avoid iterations in callbacks. Use background jobs for bulk operations"
+                     end
+
         @issues << create_issue(
           file_path: @file_path,
           line_number: node.loc.line,
           message: "Iteration found in `#{callback_type}` callback `:#{method_name}` - potential N+1",
           severity: :error,
-          suggestion: "Avoid iterations in callbacks. Use background jobs for bulk operations"
+          suggestion: suggestion
         )
       end
 
+      def transactional_callback?(callback_type)
+        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
@@ -171,6 +190,22 @@ module EagerEye
         end
       end
 
+      def non_ar_collection?(node)
+        ns = root_namespace(node)
+        ns && NON_AR_NAMESPACES.include?(ns)
+      end
+
+      def root_namespace(node)
+        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])
+        end
+      end
+
       def contains_ar_query_on_variable?(node, block_var)
         return false unless node.is_a?(Parser::AST::Node)
         return true if query_call?(node) && receiver_chain_starts_with?(node.children[0], block_var)

data/lib/eager_eye/detectors/count_in_iteration.rb

@@ -6,6 +6,7 @@ module EagerEye
       COUNT_METHODS = %i[count].freeze
       ITERATION_METHODS = %i[each map select find_all reject collect each_with_index each_with_object flat_map
                              find_each find_in_batches in_batches].freeze
+      ARRAY_METHOD_SUFFIXES = %w[_ids _tags _types _codes _names _values].freeze
 
       def self.detector_name
         :count_in_iteration
@@ -52,9 +53,17 @@ module EagerEye
 
       def count_on_association?(node, block_var)
         node.type == :send && COUNT_METHODS.include?(node.children[1]) &&
+          !array_returning_method?(node.children[0]) &&
           association_call_on_block_var?(node.children[0], block_var)
       end
 
+      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) }
+      end
+
       def association_call_on_block_var?(node, block_var)
         return false unless node.is_a?(Parser::AST::Node) && node.type == :send
 

data/lib/eager_eye/detectors/custom_method_query.rb

@@ -7,7 +7,7 @@ module EagerEye
                          maximum].freeze
       SAFE_QUERY_METHODS = %i[first last take count sum find size length ids].freeze
       SAFE_TRANSFORM_METHODS = %i[keys values split [] params sort pluck ids to_s to_a to_i chars bytes].freeze
-      ARRAY_COLUMN_SUFFIXES = %w[_ids _tags _types _codes _names _values].freeze
+      ARRAY_COLUMN_SUFFIXES = %w[_ids _tags _types _codes _names _values _arr].freeze
       ITERATION_METHODS = %i[each map select find_all reject collect detect find_index flat_map
                              find_each find_in_batches in_batches].freeze
 
@@ -62,6 +62,7 @@ module EagerEye
         method_name = node.children[1]
         return false unless QUERY_METHODS.include?(method_name)
         return false if skip_array_method?(node, block_var, is_array_collection)
+        return false if receiver_is_query_chain?(node.children[0])
 
         receiver_chain_starts_with?(node.children[0], block_var)
       end
@@ -130,6 +131,10 @@ module EagerEye
         SAFE_TRANSFORM_METHODS.include?(method_name) || array_column_method?(method_name)
       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) }

data/lib/eager_eye/detectors/decorator_n_plus_one.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module EagerEye
+  module Detectors
+    class DecoratorNPlusOne < Base
+      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
+      end
+
+      def detect(ast, file_path)
+        return [] unless ast
+
+        issues = []
+
+        traverse_ast(ast) do |node|
+          next unless 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
+      end
+
+      def inherits_from_decorator?(class_node)
+        parent_node = class_node.children[1]
+        return false unless parent_node
+
+        parent_name = const_to_string(parent_node)
+        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
+
+        traverse_ast(body) do |node|
+          next unless node.type == :def
+
+          find_associations_in_method(node.children[2], file_path, issues)
+        end
+      end
+
+      def find_associations_in_method(method_body, file_path, issues)
+        return unless method_body
+
+        storage_lines = collect_active_storage_lines(method_body)
+        traverse_ast(method_body) do |node|
+          next unless association_access?(node, storage_lines)
+
+          receiver = node.children[0]
+          method_name = node.children[1]
+          issues << create_decorator_issue(file_path, node.loc.line, receiver, method_name)
+        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"
+        )
+      end
+    end
+  end
+end

data/lib/eager_eye/version.rb

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

data/lib/eager_eye.rb

@@ -15,6 +15,7 @@ require_relative "eager_eye/detectors/count_in_iteration"
 require_relative "eager_eye/detectors/callback_query"
 require_relative "eager_eye/detectors/pluck_to_array"
 require_relative "eager_eye/detectors/delegation_n_plus_one"
+require_relative "eager_eye/detectors/decorator_n_plus_one"
 require_relative "eager_eye/comment_parser"
 require_relative "eager_eye/analyzer"
 require_relative "eager_eye/fixers/base"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eager_eye
 version: !ruby/object:Gem::Version
-  version: 1.2.4
+  version: 1.2.5
 platform: ruby
 authors:
 - hamzagedikkaya
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-21 00:00:00.000000000 Z
+date: 2026-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast
@@ -70,6 +70,7 @@ files:
 - 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
+- lib/eager_eye/detectors/decorator_n_plus_one.rb
 - lib/eager_eye/detectors/delegation_n_plus_one.rb
 - lib/eager_eye/detectors/loop_association.rb
 - lib/eager_eye/detectors/missing_counter_cache.rb