eager_eye 1.0.10 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 27aed443ecc5e83aeb4fe0baa9aa9ccbcec462df45767c8294d867562c9066b5
-  data.tar.gz: f2a9f245154a8fe043d9a9f0f68edaf940a5c3f8e2bd3f0255962603ef48d4d3
+  metadata.gz: 8b6c076a6dd51cb872bfb213cbb83369a7d9f159bb20054b41901710b738b4df
+  data.tar.gz: 15850c235c48858cbbb2585c83ffaeacf1331a029b959f973aede31ef584ae24
 SHA512:
-  metadata.gz: f6f769f5d65827fd4059671674f8947f172b1ef9ff72a82375c25ac3e31c35c81099384e79de97036b8c867613343fd2e078f7c23f59fd68bf5daac8cd8a8a19
-  data.tar.gz: f6c0743373d769ec6d147ccb1045b6a667d6015551a705b31eaefe6fc511568ecf06683cb99d7034f2d59cd83997732096d8e7c12b732b42c6ee460b9d152b5c
+  metadata.gz: 0454d92551dcc8d96ae35513ae89c3198a707ee6aac43538c7233d679cb9328c9190c8def794736c53cf61b06419051baa937a9358288a046590de14d15c22b1
+  data.tar.gz: bfd0dc368252cf5d0118a5dcf912b981ea02bf6f158a80a59a1fc475f0f5810c302c223c4126dfc639f8a5ad5e8be3fbcfd3ed87d5c21d3e148405a5f5033b1a

data/.rubocop.yml

@@ -19,6 +19,9 @@ Metrics/BlockLength:
     - "*.gemspec"
     - "lib/eager_eye/railtie.rb"
 
+Metrics/ClassLength:
+  Max: 155
+
 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,21 +7,31 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [1.0.10] - 2025-12-26
+## [1.1.1] - 2026-01-03
 
-### Changed
+### Fixed
 
-- **PluckToArray Severity Levels** - Differentiate between scoped and unscoped pluck usage
-  - Scoped `.pluck(:id)` (e.g., `User.active.pluck(:id)`) → **Warning** (default)
-  - Unscoped `.all.pluck(:id)` → **Error** (loads entire table into memory)
-  - Small arrays with scoped pluck may be acceptable - users can suppress with comments
+- **SerializerNesting False Positive** - No longer flags `belongs_to` associations
+  - `user.author`, `subscription.user` etc. (singular) are now ignored
+  - Only `has_many` associations (plural names) are flagged as potential N+1
+
+## [1.1.0] - 2025-12-28
 
 ### Added
 
-- **Improved PluckToArray Detection** - Now detects and prioritizes `.all.pluck` patterns
-  - Tracks `.all.pluck(:id)` as critical issues (error severity)
-  - Detects both variable assignments and inline usage
-  - Better suggestions for high-priority cases
+- **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
 

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.10-red.svg" alt="Gem Version"></a>
+  <a href="https://rubygems.org/gems/eager_eye"><img src="https://img.shields.io/badge/gem-v1.1.1-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>
@@ -153,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)
@@ -313,40 +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
-
-# Worse - Loads entire table into memory! (REPORTED AS ERROR)
-user_ids = User.all.pluck(:id)     # Query 1: SELECT id FROM users -- ENTIRE TABLE!
-Post.where(user_id: user_ids)      # Query 2: SELECT * FROM posts WHERE user_id IN (...)
+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)
 ```
 
-**Severity Levels:**
-
-- ⚠️ **Warning (default)** - Scoped `.pluck(:id)` (e.g., `User.active.pluck(:id)`)
-  - Two queries and memory overhead with moderately-sized arrays
-  - Small arrays may be acceptable
-  
-- 🔴 **Error** - Unscoped `.all.pluck(:id)` (e.g., `User.all.pluck(:id)`)
-  - Loads entire table into memory
-  - Highly inefficient and should always be refactored
-
-**Performance comparison with 10,000 users:**
-
-| Approach | Queries | Memory | Time |
-|----------|---------|--------|------|
-| `pluck` + `where` | 2 | ~80KB for IDs | ~45ms |
-| `.all.pluck` + `where` | 2 | ~40KB+ for all IDs | ~100ms+ |
-| `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/SECURITY.md

@@ -4,6 +4,7 @@
 
 | Version | Supported          |
 | ------- | ------------------ |
+| 1.1.x   | :white_check_mark: |
 | 1.0.x   | :white_check_mark: |
 | < 1.0   | :x:                |
 

data/lib/eager_eye/analyzer.rb

@@ -14,24 +14,47 @@ 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
 
-      ruby_files.each do |file_path|
-        analyze_file(file_path)
+    def collect_association_preloads
+      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
 
-      @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|
@@ -59,19 +82,15 @@ module EagerEye
       return unless ast
 
       comment_parser = CommentParser.new(source)
+      min_severity = EagerEye.configuration.min_severity
 
       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)
 
-        # Filter suppressed issues
-        file_issues.reject! do |issue|
-          comment_parser.disabled_at?(issue.line_number, issue.detector)
-        end
-
-        # Filter by minimum severity
-        min_severity = EagerEye.configuration.min_severity
+        file_issues = detector.detect(*args)
+        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)
       end
     rescue Errno::ENOENT, Errno::EACCES => e

data/lib/eager_eye/association_parser.rb

@@ -0,0 +1,88 @@
+# 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)
+      first_arg = node.children[2]
+      first_arg&.type == :sym ? first_arg.children[0] : nil
+    end
+
+    def extract_preloaded_associations(node)
+      preloaded = Set.new
+      block_node = node.children[2..].find { |arg| arg&.type == :block }
+      traverse_for_preloads(block_node&.children&.[](2), preloaded) if block_node
+      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)
+      node.type == :send && %i[includes preload eager_load].include?(node.children[1])
+    end
+
+    def extract_includes_from_method(node, included)
+      node.children[2..].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/auto_fixer.rb

@@ -12,11 +12,7 @@ module EagerEye
       fixes = collect_fixes
       return puts "No auto-fixable issues found." if fixes.empty?
 
-      if @interactive
-        apply_interactively(fixes)
-      else
-        apply_all(fixes)
-      end
+      @interactive ? apply_interactively(fixes) : apply_all(fixes)
     end
 
     def suggest
@@ -37,12 +33,9 @@ module EagerEye
 
     def collect_fixes
       @issues.filter_map do |issue|
-        source = read_file(issue.file_path)
-        fixer = FixerRegistry.fixer_for(issue, source)
-        next unless fixer&.fixable?
-
-        fixer.diff
-      end.compact
+        fixer = FixerRegistry.fixer_for(issue, read_file(issue.file_path))
+        fixer&.fixable? ? fixer.diff : nil
+      end
     end
 
     def read_file(path)
@@ -71,7 +64,6 @@ module EagerEye
     end
 
     def apply_all(fixes)
-      # Group by file to minimize file operations
       fixes.group_by { |f| f[:file] }.each do |file, file_fixes|
         lines = File.readlines(file)
 

data/lib/eager_eye/cli.rb

@@ -137,9 +137,7 @@ module EagerEye
 
     def analyze
       configure_from_options!
-
-      analyzer = Analyzer.new(paths: options[:paths])
-      analyzer.run
+      Analyzer.new(paths: options[:paths]).run
     end
 
     def configure_from_options!
@@ -165,10 +163,7 @@ module EagerEye
     end
 
     def exit_code(issues)
-      return 0 unless options[:fail_on_issues]
-      return 0 if issues.empty?
-
-      1
+      options[:fail_on_issues] && issues.any? ? 1 : 0
     end
   end
 end

data/lib/eager_eye/comment_parser.rb

@@ -131,11 +131,6 @@ module EagerEye
       end
     end
 
-    def inline_disable?(line)
-      code_part = line.split("#").first
-      code_part && !code_part.strip.empty?
-    end
-
     def code_before_comment?(line)
       code_part = line.split("#").first
       code_part && !code_part.strip.empty?

data/lib/eager_eye/detectors/base.rb

@@ -41,10 +41,7 @@ module EagerEye
         return unless node.is_a?(Parser::AST::Node)
 
         yield node
-
-        node.children.each do |child|
-          traverse_ast(child, &block)
-        end
+        node.children.each { |child| traverse_ast(child, &block) }
       end
 
       def parse_source(source)
@@ -52,6 +49,30 @@ 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
+        args.each do |arg|
+          case arg&.type
+          when :sym then symbols.add(arg.children[0])
+          when :hash then 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/callback_query.rb

@@ -51,18 +51,11 @@ module EagerEye
         return unless node.is_a?(Parser::AST::Node)
 
         extract_callback_method_name(node) if callback_definition?(node)
-
-        node.children.each do |child|
-          find_callback_definitions(child)
-        end
+        node.children.each { |child| find_callback_definitions(child) }
       end
 
       def callback_definition?(node)
-        return false unless node.type == :send
-        return false unless node.children[0].nil?
-
-        method_name = node.children[1]
-        CALLBACK_METHODS.include?(method_name)
+        node.type == :send && node.children[0].nil? && CALLBACK_METHODS.include?(node.children[1])
       end
 
       def extract_callback_method_name(node)
@@ -78,28 +71,13 @@ module EagerEye
       def check_callback_methods(node)
         return unless node.is_a?(Parser::AST::Node)
 
-        if method_definition?(node)
+        if node.type == :def && @callback_methods.key?(node.children[0])
           method_name = node.children[0]
-          if @callback_methods.key?(method_name)
-            callback_type = @callback_methods[method_name]
-            check_method_body_for_queries(node, method_name, callback_type)
-          end
+          body = node.children[2]
+          find_iterations_with_queries(body, method_name, @callback_methods[method_name]) if body
         end
 
-        node.children.each do |child|
-          check_callback_methods(child)
-        end
-      end
-
-      def method_definition?(node)
-        node.type == :def
-      end
-
-      def check_method_body_for_queries(method_node, method_name, callback_type)
-        method_body = method_node.children[2]
-        return unless method_body
-
-        find_iterations_with_queries(method_body, method_name, callback_type)
+        node.children.each { |child| check_callback_methods(child) }
       end
 
       def find_iterations_with_queries(node, method_name, callback_type)
@@ -111,9 +89,7 @@ module EagerEye
           find_query_calls_in_block(node, method_name, callback_type, block_var) if block_var
         end
 
-        node.children.each do |child|
-          find_iterations_with_queries(child, method_name, callback_type)
-        end
+        node.children.each { |child| find_iterations_with_queries(child, method_name, callback_type) }
       end
 
       def find_query_calls_in_block(node, method_name, callback_type, block_var)
@@ -123,26 +99,16 @@ module EagerEye
           add_query_issue(node, method_name, callback_type)
         end
 
-        node.children.each do |child|
-          find_query_calls_in_block(child, method_name, callback_type, block_var)
-        end
+        node.children.each { |child| find_query_calls_in_block(child, method_name, callback_type, block_var) }
       end
 
       def query_call?(node)
-        return false unless node.type == :send
-
-        method = node.children[1]
-        QUERY_INDICATORS.include?(method)
+        node.type == :send && QUERY_INDICATORS.include?(node.children[1])
       end
 
       def iteration_block?(node)
-        return false unless node.type == :block
-
-        send_node = node.children[0]
-        return false unless send_node&.type == :send
-
-        method_name = send_node.children[1]
-        ITERATION_METHODS.include?(method_name)
+        node.type == :block && node.children[0]&.type == :send &&
+          ITERATION_METHODS.include?(node.children[0].children[1])
       end
 
       def add_query_issue(node, method_name, callback_type)

data/lib/eager_eye/detectors/count_in_iteration.rb

@@ -3,14 +3,8 @@
 module EagerEye
   module Detectors
     class CountInIteration < Base
-      # count always executes a COUNT query
-      # size and length use memory when collection is loaded
       COUNT_METHODS = %i[count].freeze
-
-      ITERATION_METHODS = %i[
-        each map select find_all reject collect
-        each_with_index each_with_object flat_map
-      ].freeze
+      ITERATION_METHODS = %i[each map select find_all reject collect each_with_index each_with_object flat_map].freeze
 
       def self.detector_name
         :count_in_iteration
@@ -36,74 +30,48 @@ module EagerEye
 
         if iteration_block?(node)
           block_var = extract_block_variable(node)
-          block_body = extract_block_body(node)
+          block_body = node.children[2]
           yield(block_body, block_var) if block_var && block_body
         end
 
-        node.children.each do |child|
-          find_iteration_blocks(child, &block)
-        end
+        node.children.each { |child| find_iteration_blocks(child, &block) }
       end
 
       def iteration_block?(node)
-        return false unless node.type == :block
-
-        send_node = node.children[0]
-        return false unless send_node&.type == :send
-
-        method_name = send_node.children[1]
-        ITERATION_METHODS.include?(method_name)
+        node.type == :block && node.children[0]&.type == :send &&
+          ITERATION_METHODS.include?(node.children[0].children[1])
       end
 
       def check_for_count_calls(node, block_var)
         return unless node.is_a?(Parser::AST::Node)
 
         add_issue(node) if count_on_association?(node, block_var)
-
-        node.children.each do |child|
-          check_for_count_calls(child, block_var)
-        end
+        node.children.each { |child| check_for_count_calls(child, block_var) }
       end
 
       def count_on_association?(node, block_var)
-        return false unless node.type == :send
-
-        method_name = node.children[1]
-        return false unless COUNT_METHODS.include?(method_name)
-
-        receiver = node.children[0]
-        association_call_on_block_var?(receiver, block_var)
+        node.type == :send && COUNT_METHODS.include?(node.children[1]) &&
+          association_call_on_block_var?(node.children[0], block_var)
       end
 
       def association_call_on_block_var?(node, block_var)
-        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
 
         receiver = node.children[0]
         return false unless receiver.is_a?(Parser::AST::Node)
 
-        # post.comments.count -> receiver is post.comments
-        # post.comments -> receiver is post (lvar)
-        if receiver.type == :lvar && receiver.children[0] == block_var
-          true
-        elsif receiver.type == :send
-          # Nested: post.author.posts.count
-          chain_starts_with_block_var?(receiver, block_var)
-        else
-          false
-        end
+        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
-          node.children[0] == block_var
-        when :send
-          chain_starts_with_block_var?(node.children[0], block_var)
-        else
-          false
+        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
 
@@ -112,13 +80,7 @@ module EagerEye
         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 extract_block_body(block_node)
-        block_node.children[2]
+        first_arg&.type == :arg ? first_arg.children[0] : nil
       end
 
       def add_issue(node)