eager_eye 1.0.9 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44b2f46a77bcc0bb742c6d169cebb7be6b9a8b722b64044b153397fcf7686872
-  data.tar.gz: 25a589c3401fe25248b6fe429e0255e5d2d9ada9b50bd7bbf467ada161e0ca95
+  metadata.gz: 03025eeca47525318e9dbd1ffe0046bcd6647c16bc5696a1fd0b7906906ebc9d
+  data.tar.gz: c9fa809e3bcc95a6ea20d6f9ef18ca45241ad96e325fef76b0aa90e79b19e3a3
 SHA512:
-  metadata.gz: 2ea1baa8c98a5362527e991d3712c0a3c0d821307a99e1b8b1a9a0ac76fbff5d4adcf4f4cd512990971956fcc3bd61ef97fb8c047d0b44609e4bd55ca385bfb4
-  data.tar.gz: 8d1590b243420e3ea3534290f15725a0aa70f3ea537aa7da05cd4648521fe284718965d27e4b00ac77ea277d4ca400107e49a18a7759780dd532c560ef1b91b3
+  metadata.gz: c3faea6fb82cda3d118584970dba7bb88fa2fa1024dd6906d03f89699ff93b5f4d2a487b6c598eb9ee6bc18ae222b308f959d3cefbaed7d54c808aba93bc2fb2
+  data.tar.gz: 355d9b1c678b755ff679492183e7046b3edb511bff6e8fe3ff0990f091274917877cf8495984cb8315fe1096b0308a3528aff8c56fc6f1ed22270aa4257b0d03

data/.rubocop.yml

@@ -19,6 +19,9 @@ Metrics/BlockLength:
     - "*.gemspec"
     - "lib/eager_eye/railtie.rb"
 
+Metrics/ClassLength:
+  Max: 165
+
 Metrics/ParameterLists:
   Max: 6
 
@@ -28,8 +31,5 @@ Metrics/AbcSize:
 Metrics/MethodLength:
   Max: 30
 
-Metrics/ClassLength:
-  Max: 150
-
 Layout/FirstArrayElementIndentation:
   EnforcedStyle: consistent

data/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.1.0] - 2025-12-28
+
+### Added
+
+- **Association Scope Preloading Detection** - LoopAssociation now recognizes associations with built-in preloading
+  - Detects `has_many :posts, -> { includes(:comments) }` patterns
+  - Recognizes scope-defined preloads to reduce false positives
+  - Parses model files to extract association definitions and preload scopes
+
+## [1.0.10] - 2025-12-27
+
+### Changed
+
+- **PluckToArray Severity Levels** - Scoped pluck is warning, `.all.pluck` is error
+  - Scoped `.pluck(:id)` → **Warning** (acceptable for small arrays)
+  - Unscoped `.all.pluck(:id)` → **Error** (loads entire table)
+  - Improved detection and suggestions for critical patterns
+
 ## [1.0.9] - 2025-12-26
 
 ### Added
@@ -19,12 +37,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Supports both CamelCase and snake_case detector names
   - Can disable all detectors with `all` keyword
 
-### Improved
-
-- Enhanced README with table of contents and better organization
-- Improved code readability and documentation structure
-- Updated version badge to v1.0.9
-
 ## [1.0.8] - 2025-12-25
 
 ### Added

data/CONTRIBUTING.md

@@ -74,7 +74,7 @@ end
 ## Code Style
 
 - Follow RuboCop rules (run `bundle exec rubocop`)
-- Maintain 90%+ test coverage
+- Maintain 95%+ test coverage
 - Document public methods
 - Keep methods small and focused
 

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.0.9-red.svg" alt="Gem Version"></a>
+  <a href="https://rubygems.org/gems/eager_eye"><img src="https://img.shields.io/badge/gem-v1.1.0-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>
@@ -24,7 +24,6 @@
 ---
 
 ## Table of Contents
-- [Why EagerEye?](#why-eagereye)
 - [Features](#features)
 - [Installation](#installation)
 - [Quick Start](#quick-start)
@@ -41,31 +40,13 @@
 - [Development](#development)
 - [Contributing](#contributing)
 
-## Why EagerEye?
-
-Unlike runtime tools like Bullet, EagerEye:
-
-- **Runs without executing code** - Works in CI pipelines without a test suite
-- **Catches more patterns** - Detects serializer N+1s, missing counter caches, and query methods in loops
-- **Proactive detection** - Finds issues at code review time, not after deployment
-
-| Feature | EagerEye | Bullet |
-|---------|----------|--------|
-| Detection method | Static analysis | Runtime |
-| Requires test suite | No | Yes |
-| Serializer N+1 detection | Yes | Limited |
-| Counter cache suggestions | Yes | No |
-| Query methods in loops | Yes | No |
-| CI integration | Native | Requires tests |
-| False positive rate | Higher | Lower |
-
 ## Features
 
 ✨ **Detects 7 types of N+1 problems:**
 - Loop associations (queries in iterations)
 - Serializer nesting issues
 - Missing counter caches
-- Custom method queries (invisible to Bullet)
+- Custom method queries
 - Count in iteration patterns
 - Callback query N+1s
 - Pluck to array misuse
@@ -172,6 +153,17 @@ posts.each { |post| post.comments.size }  # No warning
 @user.posts.each do |post|
   post.comments  # No warning - single user, no N+1
 end
+
+# Scope-defined preloads are recognized (v1.1.0+)
+# In Post model:
+class Post < ApplicationRecord
+  has_many :comments, -> { includes(:author) }
+end
+
+# In controller - EagerEye recognizes comments are already preloaded via scope!
+posts.each do |post|
+  post.comments.map(&:author)  # No warning - preloaded via scope
+end
 ```
 
 ### 2. Serializer Nesting (N+1 in serializers)
@@ -226,10 +218,10 @@ end
 
 ### 4. Custom Method Query (N+1 in query methods)
 
-Detects query methods (`.where`, `.find_by`, `.exists?`, etc.) called on associations inside loops. **These patterns are invisible to Bullet.**
+Detects query methods (`.where`, `.find_by`, `.exists?`, etc.) called on associations inside loops.
 
 ```ruby
-# Bad - Bullet CANNOT catch this
+# Bad - where inside loop
 class User < ApplicationRecord
   def supports?(team_name)
     teams.where(name: team_name).exists?
@@ -332,25 +324,20 @@ Detects when `.pluck(:id)` or `.map(&:id)` results are used in `where` clauses i
 
 ```ruby
 # Bad - Two queries + memory overhead
-user_ids = User.active.pluck(:id)  # Query 1: SELECT id FROM users
-Post.where(user_id: user_ids)      # Query 2: SELECT * FROM posts WHERE user_id IN (1,2,3...)
-# Also holds potentially thousands of IDs in memory
+user_ids = User.active.pluck(:id)
+Post.where(user_id: user_ids)  # ⚠️ Warning
 
-# Bad - Same problem with map
-user_ids = users.map(&:id)
+# Worse - Loads entire table! 🔴 Error
+user_ids = User.all.pluck(:id)
 Post.where(user_id: user_ids)
 
-# Good - Single subquery, no memory overhead
+# Good - Single subquery
 Post.where(user_id: User.active.select(:id))
-# Single query: SELECT * FROM posts WHERE user_id IN (SELECT id FROM users WHERE active = true)
 ```
 
-**Performance comparison with 10,000 users:**
-
-| Approach | Queries | Memory | Time |
-|----------|---------|--------|------|
-| `pluck` + `where` | 2 | ~80KB for IDs | ~45ms |
-| `select` subquery | 1 | None | ~20ms |
+**Severity:**
+- ⚠️ **Warning** - Scoped `.pluck(:id)` (two queries, memory overhead)
+- 🔴 **Error** - Unscoped `.all.pluck(:id)` (loads entire table)
 
 ## Inline Suppression
 

data/lib/eager_eye/analyzer.rb

@@ -14,24 +14,49 @@ module EagerEye
       pluck_to_array: Detectors::PluckToArray
     }.freeze
 
-    attr_reader :paths, :issues
+    attr_reader :paths, :issues, :association_preloads
 
     def initialize(paths: nil)
       @paths = Array(paths || EagerEye.configuration.app_path)
       @issues = []
+      @association_preloads = {}
     end
 
     def run
       @issues = []
+      collect_association_preloads
+      analyze_files
+      @issues
+    end
+
+    private
+
+    def collect_association_preloads
+      model_files.each do |file_path|
+        source = File.read(file_path)
+        ast = parse_source(source)
+        next unless ast
 
-      ruby_files.each do |file_path|
-        analyze_file(file_path)
+        model_name = extract_model_name(file_path)
+        parser = AssociationParser.new
+        parser.parse_model(ast, model_name)
+        @association_preloads.merge!(parser.preloaded_associations)
       end
+    rescue StandardError
+      # Silently skip errors in association parsing
+    end
 
-      @issues
+    def model_files
+      Dir.glob(File.join(@paths[0], "models", "**", "*.rb"))
     end
 
-    private
+    def extract_model_name(file_path)
+      File.basename(file_path, ".rb").camelize
+    end
+
+    def analyze_files
+      ruby_files.each { |file_path| analyze_file(file_path) }
+    end
 
     def ruby_files
       all_files = paths.flat_map do |path|
@@ -61,7 +86,10 @@ module EagerEye
       comment_parser = CommentParser.new(source)
 
       enabled_detectors.each do |detector|
-        file_issues = detector.detect(ast, file_path)
+        args = [ast, file_path]
+        args << @association_preloads if detector.is_a?(Detectors::LoopAssociation)
+
+        file_issues = detector.detect(*args)
 
         # Filter suppressed issues
         file_issues.reject! do |issue|

data/lib/eager_eye/association_parser.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module EagerEye
+  class AssociationParser
+    ASSOCIATION_METHODS = %i[has_many has_one belongs_to has_and_belongs_to_many].freeze
+
+    attr_reader :preloaded_associations
+
+    def initialize
+      @preloaded_associations = {}
+    end
+
+    def parse_model(ast, model_name)
+      return unless ast
+
+      traverse(ast, model_name)
+    end
+
+    private
+
+    def traverse(node, model_name)
+      return unless node.is_a?(Parser::AST::Node)
+
+      check_association_definition(node, model_name)
+      node.children.each { |child| traverse(child, model_name) }
+    end
+
+    def check_association_definition(node, model_name)
+      return unless node.type == :send
+      return unless node.children[0].nil? # receiver is nil (class context)
+
+      method_name = node.children[1]
+      return unless ASSOCIATION_METHODS.include?(method_name)
+
+      association_name = extract_association_name(node)
+      return unless association_name
+
+      preloaded = extract_preloaded_associations(node)
+      return if preloaded.empty?
+
+      @preloaded_associations["#{model_name}##{association_name}"] = preloaded
+    end
+
+    def extract_association_name(node)
+      args = node.children[2..]
+      return nil if args.empty?
+
+      first_arg = args[0]
+      return nil unless first_arg&.type == :sym
+
+      first_arg.children[0]
+    end
+
+    def extract_preloaded_associations(node)
+      preloaded = Set.new
+      args = node.children[2..]
+      return preloaded if args.empty?
+
+      # Check for block with includes/preload/eager_load
+      block_node = args.find { |arg| arg&.type == :block }
+      return preloaded unless block_node
+
+      extract_from_block(block_node, preloaded)
+      preloaded
+    end
+
+    def extract_from_block(block_node, preloaded)
+      block_body = block_node.children[2]
+      traverse_for_preloads(block_body, preloaded)
+    end
+
+    def traverse_for_preloads(node, preloaded)
+      return unless node.is_a?(Parser::AST::Node)
+
+      extract_includes_from_method(node, preloaded) if preload_call?(node)
+
+      node.children.each { |child| traverse_for_preloads(child, preloaded) }
+    end
+
+    def preload_call?(node)
+      return false unless node.type == :send
+
+      method = node.children[1]
+      %i[includes preload eager_load].include?(method)
+    end
+
+    def extract_includes_from_method(node, included)
+      args = node.children[2..]
+      return if args.empty?
+
+      args.each { |arg| add_included_sym(arg, included) }
+    end
+
+    def add_included_sym(arg, included)
+      case arg&.type
+      when :sym
+        included << arg.children[0]
+      when :hash
+        arg.children.each { |pair| extract_sym_from_pair(pair, included) }
+      end
+    end
+
+    def extract_sym_from_pair(pair, included)
+      return unless pair.type == :pair
+
+      key = pair.children[0]
+      included << key.children[0] if key&.type == :sym
+    end
+  end
+end

data/lib/eager_eye/comment_parser.rb

@@ -72,22 +72,18 @@ module EagerEye
     end
 
     def detect_block_or_inline_directive(line)
-      # Check for eager_eye:disable-block explicitly
       if line =~ BLOCK_START_PATTERN && !code_before_comment?(line)
         detectors = parse_detector_names(::Regexp.last_match(1) || "all")
         return { type: :block_start, detectors: detectors }
       end
 
-      # Check for eager_eye:disable (either inline or block start)
       return unless line =~ INLINE_DISABLE_PATTERN
 
       detectors = parse_detector_names(::Regexp.last_match(1) || "all")
 
-      # If there's code before the comment, it's inline (same line only)
       if code_before_comment?(line)
         { type: :inline, detectors: detectors }
       else
-        # No code before comment, so it's a block start
         { type: :block_start, detectors: detectors }
       end
     end

data/lib/eager_eye/detectors/base.rb

@@ -52,6 +52,34 @@ module EagerEye
       rescue Parser::SyntaxError
         nil
       end
+
+      def extract_method_args(node)
+        return [] unless node&.type == :send
+
+        node.children[2..]
+      end
+
+      def extract_symbols_from_args(args)
+        symbols = Set.new
+        return symbols if args.empty?
+
+        args.each do |arg|
+          case arg&.type
+          when :sym
+            symbols.add(arg.children[0])
+          when :hash
+            extract_symbols_from_hash(arg, symbols)
+          end
+        end
+        symbols
+      end
+
+      def extract_symbols_from_hash(hash_node, symbols)
+        hash_node.children.each do |pair|
+          key = pair.children[0]
+          symbols.add(key.children[0]) if key&.type == :sym
+        end
+      end
     end
   end
 end

data/lib/eager_eye/detectors/loop_association.rb

@@ -31,10 +31,11 @@ module EagerEye
         :loop_association
       end
 
-      def detect(ast, file_path)
+      def detect(ast, file_path, association_preloads = {})
         return [] unless ast
 
         issues = []
+        @association_preloads = association_preloads
         build_variable_maps(ast)
 
         traverse_ast(ast) do |node|
@@ -51,6 +52,8 @@ 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))
 
           find_association_calls(block_body, block_var, file_path, issues, included)
         end
@@ -60,6 +63,27 @@ 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)
+        end
+        preloaded
+      end
+
+      def infer_model_name_from_collection(node)
+        # Infer model name from collection (posts -> Post, users -> User)
+        return nil unless node&.type == :send
+
+        # Handle: Model.includes, @var.method calls
+        receiver = node.children[0]
+        case receiver&.type
+        when :const
+          receiver.children[1].to_s
+        end
+      end
+
       def iteration_block?(node)
         return false unless node.type == :block
 
@@ -71,14 +95,9 @@ module EagerEye
       end
 
       def extract_block_variable(block_node)
-        args_node = block_node.children[1]
-        return nil unless args_node&.type == :args
-        return nil if args_node.children.empty?
-
-        first_arg = args_node.children[0]
-        return nil unless first_arg&.type == :arg
-
-        first_arg.children[0]
+        args = block_node&.children&.fetch(1, nil)
+        first_child = args&.children&.first
+        first_child&.type == :arg ? first_child.children[0] : nil
       end
 
       def extract_included_associations(collection_node)
@@ -101,19 +120,21 @@ module EagerEye
         @variable_preloads = {}
         @single_record_variables = Set.new
 
-        traverse_ast(ast) do |node|
-          next unless %i[lvasgn ivasgn].include?(node.type)
+        traverse_ast(ast) { |node| process_variable_assignment(node) }
+      end
 
-          var_type = node.type == :lvasgn ? :lvar : :ivar
-          var_name = node.children[0]
-          value_node = node.children[1]
-          next unless value_node
+      def process_variable_assignment(node)
+        return unless %i[lvasgn ivasgn].include?(node.type)
 
-          key = [var_type, var_name]
-          preloaded = extract_included_associations(value_node)
-          @variable_preloads[key] = preloaded unless preloaded.empty?
-          @single_record_variables.add(key) if single_record_query?(value_node)
-        end
+        var_type = node.type == :lvasgn ? :lvar : :ivar
+        var_name = node.children[0]
+        value_node = node.children[1]
+        return unless value_node
+
+        key = [var_type, var_name]
+        preloaded = extract_included_associations(value_node)
+        @variable_preloads[key] = preloaded unless preloaded.empty?
+        @single_record_variables.add(key) if single_record_query?(value_node)
       end
 
       def extract_variable_preloads(node)
@@ -130,11 +151,18 @@ module EagerEye
       end
 
       def single_record_query?(node)
+        last_send = find_last_send_method(node)
+        last_send && SINGLE_RECORD_METHODS.include?(last_send)
+      end
+
+      def find_last_send_method(node)
         current = node
-        while current&.type == :send && !SINGLE_RECORD_METHODS.include?(current.children[1])
-          current = current.children[0]
-        end
-        current&.type == :send && SINGLE_RECORD_METHODS.include?(current.children[1])
+        current = current.children[0] while current&.type == :send && !single_record_method?(current)
+        current&.type == :send ? current.children[1] : nil
+      end
+
+      def single_record_method?(node)
+        SINGLE_RECORD_METHODS.include?(node.children[1])
       end
 
       def single_record_iteration?(node)
@@ -145,67 +173,50 @@ module EagerEye
       end
 
       def extract_includes_from_method(method_node, included_set)
-        args = method_node.children[2..]
-        args&.each do |arg|
-          case arg&.type
-          when :sym
-            # includes(:product)
-            included_set.add(arg.children[0])
-          when :hash
-            # includes(product: :manufacturer)
-            extract_from_hash(arg, included_set)
-          end
-        end
+        args = extract_method_args(method_node)
+        included_set.merge(extract_symbols_from_args(args))
       end
 
       def extract_from_hash(hash_node, included_set)
-        hash_node.children.each do |pair|
-          key = pair.children[0]
-          included_set.add(key.children[0]) if key&.type == :sym
-        end
+        extract_symbols_from_hash(hash_node, included_set)
       end
 
       def find_association_calls(node, block_var, file_path, issues, included_associations = Set.new)
-        reported_associations = Set.new
-
+        reported = Set.new
         traverse_ast(node) do |child|
-          next unless child.type == :send
+          next unless should_report_issue?(child, block_var, reported, included_associations)
 
-          receiver = child.children[0]
-          method_name = child.children[1]
-
-          # Only detect direct calls on block variable (post.author, not post.author.name)
-          next unless direct_call_on_block_var?(receiver, block_var)
-          next unless likely_association?(method_name)
-
-          # Skip if association is already included
-          next if included_associations.include?(method_name)
-
-          # Avoid duplicate reports for same association on same line
-          report_key = "#{child.loc.line}:#{method_name}"
-          next if reported_associations.include?(report_key)
-
-          reported_associations << report_key
-
-          issues << create_issue(
-            file_path: file_path,
-            line_number: child.loc.line,
-            message: "Potential N+1 query: `#{block_var}.#{method_name}` called inside iteration",
-            suggestion: "Consider using `includes(:#{method_name})` on the collection before iterating"
-          )
+          add_n_plus_one_issue(child, block_var, file_path, issues, reported)
         end
       end
 
-      def direct_call_on_block_var?(receiver, block_var)
-        return false unless receiver
+      def should_report_issue?(child, block_var, reported, included)
+        return false unless child.type == :send
+
+        receiver = child.children[0]
+        method = child.children[1]
+        return false unless receiver&.type == :lvar && receiver.children[0] == block_var
+        return false if excluded?(method, included)
 
-        receiver.type == :lvar && receiver.children[0] == block_var
+        key = "#{child.loc.line}:#{method}"
+        !reported.include?(key) && reported.add(key)
       end
 
-      def likely_association?(method_name)
-        return false if EXCLUDED_METHODS.include?(method_name)
+      def excluded?(method, included)
+        EXCLUDED_METHODS.include?(method) ||
+          !ASSOCIATION_NAMES.include?(method.to_s) ||
+          included.include?(method)
+      end
 
-        ASSOCIATION_NAMES.include?(method_name.to_s)
+      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

data/lib/eager_eye/detectors/pluck_to_array.rb

@@ -12,126 +12,136 @@ module EagerEye
         @file_path = file_path
         @pluck_variables = {}
         @map_id_variables = {}
+        @critical_pluck_variables = {}
 
         return @issues unless ast
 
-        collect_pluck_assignments(ast)
-        collect_map_id_assignments(ast)
-        find_where_with_pluck_var(ast)
-
+        visit(ast)
         @issues
       end
 
       private
 
-      def collect_pluck_assignments(node)
+      def visit(node)
         return unless node.is_a?(Parser::AST::Node)
 
-        if local_variable_assignment?(node)
-          var_name = node.children[0]
-          value = node.children[1]
-
-          @pluck_variables[var_name] = node.loc.line if pluck_call?(value)
-        end
+        collect_assignments(node)
+        check_where_calls(node)
 
-        node.children.each do |child|
-          collect_pluck_assignments(child)
-        end
+        node.children.each { |child| visit(child) }
       end
 
-      def collect_map_id_assignments(node)
-        return unless node.is_a?(Parser::AST::Node)
+      def collect_assignments(node)
+        return unless local_variable_assignment?(node)
 
-        if local_variable_assignment?(node)
-          var_name = node.children[0]
-          value = node.children[1]
+        var_name = node.children[0]
+        value = node.children[1]
 
-          @map_id_variables[var_name] = node.loc.line if map_id_call?(value)
-        end
-
-        node.children.each do |child|
-          collect_map_id_assignments(child)
-        end
+        @critical_pluck_variables[var_name] = node.loc.line if all_pluck_call?(value)
+        @pluck_variables[var_name] = node.loc.line if pluck_call?(value)
+        @map_id_variables[var_name] = node.loc.line if map_id_call?(value)
       end
 
-      def find_where_with_pluck_var(node)
-        return unless node.is_a?(Parser::AST::Node)
+      def check_where_calls(node)
+        return unless where_call?(node)
 
-        add_issue(node) if where_call_with_pluck_var?(node)
-
-        node.children.each do |child|
-          find_where_with_pluck_var(child)
-        end
+        add_critical_issue(node) if critical_pluck?(node)
+        add_issue(node) if regular_pluck?(node)
       end
 
       def local_variable_assignment?(node)
         node.type == :lvasgn
       end
 
+      def where_call?(node)
+        node.type == :send && node.children[1] == :where
+      end
+
       def pluck_call?(node)
-        return false unless node.is_a?(Parser::AST::Node)
-        return false unless node.type == :send
+        return false unless node.is_a?(Parser::AST::Node) && node.type == :send
 
-        method_name = node.children[1]
-        %i[pluck ids].include?(method_name)
+        method = node.children[1]
+        %i[pluck ids].include?(method)
+      end
+
+      def all_pluck_call?(node)
+        return false unless pluck_call?(node)
+
+        receiver = node.children[0]
+        receiver.is_a?(Parser::AST::Node) && receiver.type == :send &&
+          receiver.children[1] == :all
       end
 
       def map_id_call?(node)
         return false unless node.is_a?(Parser::AST::Node)
 
-        case node.type
-        when :block then block_map_call?(node)
-        when :send then send_map_id_call?(node)
-        else false
-        end
+        block_map?(node) || send_map?(node)
       end
 
-      def block_map_call?(node)
-        send_node = node.children[0]
-        return false unless send_node&.type == :send
+      def block_map?(node)
+        return false unless node.type == :block
 
-        %i[map collect].include?(send_node.children[1])
+        send_node = node.children[0]
+        send_node&.type == :send && %i[map collect].include?(send_node.children[1])
       end
 
-      def send_map_id_call?(node)
-        method_name = node.children[1]
-        return false unless %i[map collect].include?(method_name)
+      def send_map?(node)
+        return false unless node.type == :send
 
-        node.children[2..].any? { |arg| symbol_to_proc_id?(arg) }
+        method = node.children[1]
+        %i[map collect].include?(method) &&
+          node.children[2..].any? { |arg| symbol_to_proc_id?(arg) }
       end
 
       def symbol_to_proc_id?(node)
-        return false unless node.is_a?(Parser::AST::Node)
-        return false unless node.type == :block_pass
+        return false unless node.is_a?(Parser::AST::Node) && node.type == :block_pass
 
-        sym_node = node.children[0]
-        return false unless sym_node&.type == :sym
+        sym = node.children[0]
+        sym&.type == :sym && %i[id to_i].include?(sym.children[0])
+      end
 
-        %i[id to_i].include?(sym_node.children[0])
+      def regular_pluck?(node)
+        where_args = node.children[2..]
+        where_args.any? { |arg| pluck_var_in_hash?(arg) }
       end
 
-      def where_call_with_pluck_var?(node)
-        return false unless node.type == :send
-        return false unless node.children[1] == :where
+      def critical_pluck?(node)
+        where_args = node.children[2..]
+        where_args.any? { |arg| critical_pluck_in_hash?(arg) }
+      end
+
+      def pluck_var_in_hash?(node)
+        return false unless node.is_a?(Parser::AST::Node) && node.type == :hash
 
-        args = node.children[2..]
-        args.any? { |arg| hash_with_pluck_var?(arg) }
+        node.children.any? do |pair|
+          next false unless pair.type == :pair
+
+          pluck_value?(pair.children[1])
+        end
       end
 
-      def hash_with_pluck_var?(node)
-        return false unless node.is_a?(Parser::AST::Node)
-        return false unless node.type == :hash
+      def critical_pluck_in_hash?(node)
+        return false unless node.is_a?(Parser::AST::Node) && node.type == :hash
 
         node.children.any? do |pair|
           next false unless pair.type == :pair
 
-          value = pair.children[1]
-          if value.type == :lvar
-            var_name = value.children[0]
-            @pluck_variables.key?(var_name) || @map_id_variables.key?(var_name)
-          else
-            false
-          end
+          critical_value?(pair.children[1])
+        end
+      end
+
+      def pluck_value?(value)
+        return false unless value.type == :lvar
+
+        var_name = value.children[0]
+        @pluck_variables.key?(var_name) || @map_id_variables.key?(var_name)
+      end
+
+      def critical_value?(value)
+        if value.type == :lvar
+          @critical_pluck_variables.key?(value.children[0])
+        else
+          all_pluck_call?(value)
         end
       end
 
@@ -139,8 +149,19 @@ module EagerEye
         @issues << create_issue(
           file_path: @file_path,
           line_number: node.loc.line,
-          message: "Using plucked/mapped array in `where` causes two queries and holds IDs in memory",
-          suggestion: "Use `.select(:id)` subquery: `Model.where(col: OtherModel.condition.select(:id))`"
+          message: "Using plucked array in `where` causes two queries and memory overhead",
+          suggestion: "Use `.select(:id)` subquery instead: `Model.where(col: OtherModel.select(:id))`",
+          severity: :warning
+        )
+      end
+
+      def add_critical_issue(node)
+        @issues << create_issue(
+          file_path: @file_path,
+          line_number: node.loc.line,
+          message: "Using `.all.pluck(:id)` loads entire table into memory - highly inefficient",
+          suggestion: "Use `.select(:id)` subquery: `Model.where(col: OtherModel.select(:id))`",
+          severity: :error
         )
       end
     end

data/lib/eager_eye/version.rb

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

data/lib/eager_eye.rb

@@ -3,6 +3,7 @@
 require_relative "eager_eye/version"
 require_relative "eager_eye/configuration"
 require_relative "eager_eye/issue"
+require_relative "eager_eye/association_parser"
 require_relative "eager_eye/detectors/base"
 require_relative "eager_eye/detectors/loop_association"
 require_relative "eager_eye/detectors/serializer_nesting"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eager_eye
 version: !ruby/object:Gem::Version
-  version: 1.0.9
+  version: 1.1.0
 platform: ruby
 authors:
 - hamzagedikkaya
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-26 00:00:00.000000000 Z
+date: 2025-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast
@@ -59,6 +59,7 @@ files:
 - exe/eager_eye
 - lib/eager_eye.rb
 - lib/eager_eye/analyzer.rb
+- lib/eager_eye/association_parser.rb
 - lib/eager_eye/auto_fixer.rb
 - lib/eager_eye/cli.rb
 - lib/eager_eye/comment_parser.rb