eager_eye 1.1.0 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03025eeca47525318e9dbd1ffe0046bcd6647c16bc5696a1fd0b7906906ebc9d
-  data.tar.gz: c9fa809e3bcc95a6ea20d6f9ef18ca45241ad96e325fef76b0aa90e79b19e3a3
+  metadata.gz: 22770991f73a5bc9ca8694ae4e45212fc6c0517036dad5a8734a11af90aa4496
+  data.tar.gz: bcdbdf3076b011a7a4eb83d62d34b4173d7f6c5cb1dff3c0ac767bbd0f47c316
 SHA512:
-  metadata.gz: c3faea6fb82cda3d118584970dba7bb88fa2fa1024dd6906d03f89699ff93b5f4d2a487b6c598eb9ee6bc18ae222b308f959d3cefbaed7d54c808aba93bc2fb2
-  data.tar.gz: 355d9b1c678b755ff679492183e7046b3edb511bff6e8fe3ff0990f091274917877cf8495984cb8315fe1096b0308a3528aff8c56fc6f1ed22270aa4257b0d03
+  metadata.gz: fcf06b3db031246fcd6549bff94a13f5e30b29da2d72a6e3c2d233fcb9740cf4a60f807e190e3f082620eda08755e90a01e96915ac873f4205f3938c44de1e8a
+  data.tar.gz: 93a926cb2d961f1b5c8341df4c7ac0dbcb3d482e9bbc00b61b7d84ed3c457432611792f999d9c02b7dcb164cf3d238c561d89392b5cb67bb287e57dcbb008a12

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,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.1.2] - 2026-01-04
+
+### Fixed
+
+- **CallbackQuery False Positive** - Only flag iterations that contain actual AR query methods
+  - Non-AR iterations (Redis, Sidekiq, mailers) are no longer flagged
+  - `Sidekiq::ScheduledSet.new.select { |job| ... }.each(&:delete)` no longer triggers warning
+
+## [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.2-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
-        end
-
-        node.children.each do |child|
-          check_callback_methods(child)
+          body = node.children[2]
+          find_iterations_with_queries(body, method_name, @callback_methods[method_name]) if body
         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)
@@ -107,13 +85,13 @@ module EagerEye
 
         if iteration_block?(node)
           block_var = extract_block_variable(node)
-          add_iteration_issue(node, method_name, callback_type)
-          find_query_calls_in_block(node, method_name, callback_type, block_var) if block_var
+          if block_var && contains_ar_query_on_variable?(node, block_var)
+            add_iteration_issue(node, method_name, callback_type)
+            find_query_calls_in_block(node, method_name, callback_type, block_var)
+          end
         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 +101,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)
@@ -189,6 +157,13 @@ module EagerEye
           false
         end
       end
+
+      def contains_ar_query_on_variable?(node, block_var)
+        return false unless node.is_a?(Parser::AST::Node)
+        return true if query_call?(node) && receiver_chain_starts_with?(node.children[0], block_var)
+
+        node.children.any? { |child| contains_ar_query_on_variable?(child, block_var) }
+      end
     end
   end
 end

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)