eager_eye 1.0.10 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 27aed443ecc5e83aeb4fe0baa9aa9ccbcec462df45767c8294d867562c9066b5
-  data.tar.gz: f2a9f245154a8fe043d9a9f0f68edaf940a5c3f8e2bd3f0255962603ef48d4d3
+  metadata.gz: 03025eeca47525318e9dbd1ffe0046bcd6647c16bc5696a1fd0b7906906ebc9d
+  data.tar.gz: c9fa809e3bcc95a6ea20d6f9ef18ca45241ad96e325fef76b0aa90e79b19e3a3
 SHA512:
-  metadata.gz: f6f769f5d65827fd4059671674f8947f172b1ef9ff72a82375c25ac3e31c35c81099384e79de97036b8c867613343fd2e078f7c23f59fd68bf5daac8cd8a8a19
-  data.tar.gz: f6c0743373d769ec6d147ccb1045b6a667d6015551a705b31eaefe6fc511568ecf06683cb99d7034f2d59cd83997732096d8e7c12b732b42c6ee460b9d152b5c
+  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,21 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [1.0.10] - 2025-12-26
+## [1.1.0] - 2025-12-28
 
-### Changed
+### Added
 
-- **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
+- **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
 
-### Added
+## [1.0.10] - 2025-12-27
+
+### Changed
 
-- **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
+- **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.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>
@@ -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/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/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

@@ -149,8 +149,8 @@ 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
@@ -159,8 +159,8 @@ module EagerEye
         @issues << create_issue(
           file_path: @file_path,
           line_number: node.loc.line,
-          message: "Using `.all.pluck(:id)` in `where` loads entire table into memory and is highly inefficient",
-          suggestion: "Use `.select(:id)` subquery instead: `Model.where(col: OtherModel.select(:id))`",
+          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

data/lib/eager_eye/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EagerEye
-  VERSION = "1.0.10"
+  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.10
+  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