eager_eye 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03025eeca47525318e9dbd1ffe0046bcd6647c16bc5696a1fd0b7906906ebc9d
-  data.tar.gz: c9fa809e3bcc95a6ea20d6f9ef18ca45241ad96e325fef76b0aa90e79b19e3a3
+  metadata.gz: 8b6c076a6dd51cb872bfb213cbb83369a7d9f159bb20054b41901710b738b4df
+  data.tar.gz: 15850c235c48858cbbb2585c83ffaeacf1331a029b959f973aede31ef584ae24
 SHA512:
-  metadata.gz: c3faea6fb82cda3d118584970dba7bb88fa2fa1024dd6906d03f89699ff93b5f4d2a487b6c598eb9ee6bc18ae222b308f959d3cefbaed7d54c808aba93bc2fb2
-  data.tar.gz: 355d9b1c678b755ff679492183e7046b3edb511bff6e8fe3ff0990f091274917877cf8495984cb8315fe1096b0308a3528aff8c56fc6f1ed22270aa4257b0d03
+  metadata.gz: 0454d92551dcc8d96ae35513ae89c3198a707ee6aac43538c7233d679cb9328c9190c8def794736c53cf61b06419051baa937a9358288a046590de14d15c22b1
+  data.tar.gz: bfd0dc368252cf5d0118a5dcf912b981ea02bf6f158a80a59a1fc475f0f5810c302c223c4126dfc639f8a5ad5e8be3fbcfd3ed87d5c21d3e148405a5f5033b1a

data/.rubocop.yml

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

data/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.1.1] - 2026-01-03
+
+### Fixed
+
+- **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

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.1.0-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>

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

@@ -33,17 +33,15 @@ module EagerEye
 
     def collect_association_preloads
       model_files.each do |file_path|
-        source = File.read(file_path)
-        ast = parse_source(source)
+        ast = parse_source(File.read(file_path))
         next unless ast
 
-        model_name = extract_model_name(file_path)
         parser = AssociationParser.new
-        parser.parse_model(ast, model_name)
+        parser.parse_model(ast, extract_model_name(file_path))
         @association_preloads.merge!(parser.preloaded_associations)
       end
     rescue StandardError
-      # Silently skip errors in association parsing
+      nil
     end
 
     def model_files
@@ -84,22 +82,15 @@ module EagerEye
       return unless ast
 
       comment_parser = CommentParser.new(source)
+      min_severity = EagerEye.configuration.min_severity
 
       enabled_detectors.each do |detector|
         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|
-          comment_parser.disabled_at?(issue.line_number, issue.detector)
-        end
-
-        # Filter by minimum severity
-        min_severity = EagerEye.configuration.min_severity
+        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

@@ -42,33 +42,17 @@ module EagerEye
     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]
+      first_arg = node.children[2]
+      first_arg&.type == :sym ? first_arg.children[0] : nil
     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)
+      block_node = node.children[2..].find { |arg| arg&.type == :block }
+      traverse_for_preloads(block_node&.children&.[](2), preloaded) if block_node
       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)
 
@@ -78,17 +62,11 @@ module EagerEye
     end
 
     def preload_call?(node)
-      return false unless node.type == :send
-
-      method = node.children[1]
-      %i[includes preload eager_load].include?(method)
+      node.type == :send && %i[includes preload eager_load].include?(node.children[1])
     end
 
     def extract_includes_from_method(node, included)
-      args = node.children[2..]
-      return if args.empty?
-
-      args.each { |arg| add_included_sym(arg, included) }
+      node.children[2..].each { |arg| add_included_sym(arg, included) }
     end
 
     def add_included_sym(arg, included)

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)
@@ -61,14 +58,10 @@ module EagerEye
 
       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)
+          when :sym then symbols.add(arg.children[0])
+          when :hash then extract_symbols_from_hash(arg, symbols)
           end
         end
         symbols

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)

data/lib/eager_eye/detectors/custom_method_query.rb

@@ -3,27 +3,9 @@
 module EagerEye
   module Detectors
     class CustomMethodQuery < Base
-      QUERY_METHODS = %i[
-        where
-        find_by
-        find_by!
-        exists?
-        find
-        first
-        last
-        take
-        pluck
-        ids
-        count
-        sum
-        average
-        minimum
-        maximum
-      ].freeze
-
-      # Array-only methods that should not be flagged when collection is clearly an array
+      QUERY_METHODS = %i[where find_by find_by! exists? find first last take pluck ids count sum average minimum
+                         maximum].freeze
       ARRAY_METHODS = %i[first last take].freeze
-
       ITERATION_METHODS = %i[each map select find_all reject collect detect find_index flat_map].freeze
 
       def self.detector_name
@@ -51,34 +33,22 @@ module EagerEye
 
         if iteration_block?(node)
           block_var = extract_block_variable(node)
-          block_body = extract_block_body(node)
-          collection = extract_collection(node)
-          yield(block_body, block_var, collection) if block_var && block_body
-        end
-
-        node.children.each do |child|
-          find_iteration_blocks(child, &block)
+          block_body = node.children[2]
+          yield(block_body, block_var, node.children[0]) if block_var && block_body
         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_block_for_query_methods(node, block_var, is_array_collection = false) # rubocop:disable Style/OptionalBooleanParameter
         return unless node.is_a?(Parser::AST::Node)
 
         add_issue(node) if query_chain_on_association?(node, block_var, is_array_collection)
-
-        node.children.each do |child|
-          check_block_for_query_methods(child, block_var, is_array_collection)
-        end
+        node.children.each { |child| check_block_for_query_methods(child, block_var, is_array_collection) }
       end
 
       def query_chain_on_association?(node, block_var, is_array_collection = false) # rubocop:disable Style/OptionalBooleanParameter
@@ -86,35 +56,23 @@ module EagerEye
 
         method_name = node.children[1]
         return false unless QUERY_METHODS.include?(method_name)
+        return false if is_array_collection && ARRAY_METHODS.include?(method_name) &&
+                        receiver_is_only_block_var?(node.children[0], block_var)
 
-        # Skip array-only methods when collection is clearly an array (.map result)
-        # AND the receiver is only the block variable (not chained)
-        if is_array_collection && ARRAY_METHODS.include?(method_name) &&
-           receiver_is_only_block_var?(node.children[0], block_var)
-          return false
-        end
-
-        receiver = node.children[0]
-        receiver_chain_starts_with?(receiver, block_var)
+        receiver_chain_starts_with?(node.children[0], block_var)
       end
 
       def receiver_is_only_block_var?(node, block_var)
-        # Returns true only if receiver is EXACTLY the block variable, not a chain
-        node.is_a?(Parser::AST::Node) &&
-          node.type == :lvar &&
-          node.children[0] == block_var
+        node.is_a?(Parser::AST::Node) && node.type == :lvar && node.children[0] == block_var
       end
 
       def receiver_chain_starts_with?(node, block_var)
         return false unless node.is_a?(Parser::AST::Node)
 
         case node.type
-        when :lvar
-          node.children[0] == block_var
-        when :send
-          receiver_chain_starts_with?(node.children[0], block_var)
-        else
-          false
+        when :lvar then node.children[0] == block_var
+        when :send then receiver_chain_starts_with?(node.children[0], block_var)
+        else false
         end
       end
 
@@ -123,37 +81,16 @@ 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]
+        first_arg&.type == :arg ? first_arg.children[0] : nil
       end
 
-      def extract_block_body(block_node)
-        block_node.children[2]
-      end
-
-      def extract_collection(block_node)
-        # Extract the collection being iterated on
-        # For: collection.each { |item| ... }
-        # Returns: the send node representing the collection method call
-        block_node.children[0]
-      end
-
-      def collection_is_array?(collection_node)
-        return false unless collection_node.is_a?(Parser::AST::Node)
+      def collection_is_array?(node)
+        return false unless node.is_a?(Parser::AST::Node)
 
-        case collection_node.type
-        when :array
-          # Literal array: [1, 2, 3].each { |item| ... }
-          true
-        when :send
-          # Only consider these methods as definitely returning arrays when iterating
-          method_name = collection_node.children[1]
-          # map, select, collect, etc. on anything return arrays for iteration
-          %i[map select collect flat_map to_a uniq compact].include?(method_name)
-        else
-          # Block variable itself won't tell us if it's an array
-          false
+        case node.type
+        when :array then true
+        when :send then %i[map select collect flat_map to_a uniq compact].include?(node.children[1])
+        else false
         end
       end
 
@@ -173,14 +110,11 @@ module EagerEye
         return "" unless node.is_a?(Parser::AST::Node)
 
         case node.type
-        when :lvar
-          node.children[0].to_s
+        when :lvar then node.children[0].to_s
         when :send
           receiver_str = reconstruct_chain(node.children[0])
-          method = node.children[1]
-          receiver_str.empty? ? method.to_s : "#{receiver_str}.#{method}"
-        else
-          ""
+          receiver_str.empty? ? node.children[1].to_s : "#{receiver_str}.#{node.children[1]}"
+        else ""
         end
       end
     end