eager_eye 1.0.10 → 1.1.1

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

data/lib/eager_eye/detectors/loop_association.rb

@@ -5,11 +5,8 @@ module EagerEye
     class LoopAssociation < Base
       ITERATION_METHODS = %i[each map collect select find find_all reject filter filter_map flat_map].freeze
       PRELOAD_METHODS = %i[includes preload eager_load].freeze
-      # Methods that return a single record (not a collection)
       SINGLE_RECORD_METHODS = %i[find find_by find_by! first first! last last! take take! second third fourth fifth
                                  forty_two sole find_sole_by].freeze
-
-      # Common association names (belongs_to = singular, has_many = plural)
       ASSOCIATION_NAMES = Set.new(%w[
         author user owner creator admin member customer client post article comment category tag
         parent company organization project task item order product account profile setting image
@@ -18,8 +15,6 @@ module EagerEye
         tasks items orders products accounts profiles settings images avatars photos attachments
         documents
       ]).freeze
-
-      # Methods that should NOT be treated as associations
       EXCLUDED_METHODS = %i[
         id to_s to_h to_a to_json to_xml inspect class object_id nil? blank? present? empty?
         any? none? size count length save save! update update! destroy destroy! delete delete!
@@ -31,10 +26,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 +47,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,40 +58,42 @@ module EagerEye
 
       private
 
-      def iteration_block?(node)
-        return false unless node.type == :block
+      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
 
-        send_node = node.children[0]
-        return false unless send_node&.type == :send
+      def infer_model_name_from_collection(node)
+        return nil unless node&.type == :send
 
-        method_name = send_node.children[1]
-        ITERATION_METHODS.include?(method_name)
+        receiver = node.children[0]
+        receiver.children[1].to_s if receiver&.type == :const
       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
+      def iteration_block?(node)
+        node.type == :block && node.children[0]&.type == :send &&
+          ITERATION_METHODS.include?(node.children[0].children[1])
+      end
 
-        first_arg.children[0]
+      def extract_block_variable(block_node)
+        args = block_node&.children&.[](1)
+        first_arg = args&.children&.first
+        first_arg&.type == :arg ? first_arg.children[0] : nil
       end
 
       def extract_included_associations(collection_node)
         included = Set.new
         return included unless collection_node&.type == :send
 
-        # Traverse through chained method calls to find includes/preload/eager_load
         current = collection_node
         while current&.type == :send
-          method_name = current.children[1]
-          extract_includes_from_method(current, included) if PRELOAD_METHODS.include?(method_name)
-
+          extract_includes_from_method(current, included) if PRELOAD_METHODS.include?(current.children[1])
           current = current.children[0]
         end
-
         included
       end
 
@@ -101,19 +101,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 +132,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 +154,46 @@ 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
-      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
+        args = extract_method_args(method_node)
+        included_set.merge(extract_symbols_from_args(args))
       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
-
-          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)
+          next unless should_report_issue?(child, block_var, reported, included_associations)
 
-          # 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.type == :lvar && receiver.children[0] == block_var
+        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)
+
+        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/missing_counter_cache.rb

@@ -3,22 +3,14 @@
 module EagerEye
   module Detectors
     class MissingCounterCache < Base
-      # Methods that trigger COUNT queries
       COUNT_METHODS = %i[count size length].freeze
-
-      # Common has_many association names (plural)
       PLURAL_ASSOCIATIONS = %w[
-        posts comments tags categories articles users members
-        items orders products tasks projects images attachments
-        documents files messages notifications reviews ratings
-        followers followings likes favorites bookmarks votes
-        children replies responses answers questions
+        posts comments tags categories articles users members items orders products tasks projects
+        images attachments documents files messages notifications reviews ratings followers followings
+        likes favorites bookmarks votes children replies responses answers questions
       ].freeze
-
-      # Iteration methods that indicate a loop context
-      ITERATION_METHODS = %i[each map collect select reject find_all
-                             filter filter_map flat_map each_with_index
-                             each_with_object reduce inject sum].freeze
+      ITERATION_METHODS = %i[each map collect select reject find_all filter filter_map flat_map
+                             each_with_index each_with_object reduce inject sum].freeze
 
       def self.detector_name
         :missing_counter_cache
@@ -51,68 +43,45 @@ module EagerEye
 
       def count_on_association?(node)
         return false unless node.type == :send
-
-        method_name = node.children[1]
-        return false unless COUNT_METHODS.include?(method_name)
+        return false unless COUNT_METHODS.include?(node.children[1])
 
         receiver = node.children[0]
-        return false unless receiver
-
-        likely_association_receiver?(receiver)
+        receiver && likely_association_receiver?(receiver)
       end
 
       def likely_association_receiver?(node)
-        return false unless node.type == :send
-
-        method_name = node.children[1]
-        PLURAL_ASSOCIATIONS.include?(method_name.to_s)
+        node.type == :send && PLURAL_ASSOCIATIONS.include?(node.children[1].to_s)
       end
 
       def extract_association_name(node)
         receiver = node.children[0]
-        return nil unless receiver&.type == :send
-
-        receiver.children[1].to_s
+        receiver.children[1].to_s if receiver&.type == :send
       end
 
-      # Check if the node is inside an iteration block
       def inside_iteration?(node)
         parent = node
-        while (parent = find_parent(parent))
+        while (parent = @parent_map[parent])
           return true if iteration_block?(parent)
         end
         false
       end
 
-      def find_parent(node)
-        @parent_map ||= {}
-        @parent_map[node]
-      end
-
-      # Override traverse_ast to build parent map
       def traverse_ast(node, &block)
         return unless node.is_a?(Parser::AST::Node)
 
         @parent_map ||= {}
-
         yield node
-
         node.children.each do |child|
-          if child.is_a?(Parser::AST::Node)
-            @parent_map[child] = node
-            traverse_ast(child, &block)
-          end
+          next unless child.is_a?(Parser::AST::Node)
+
+          @parent_map[child] = node
+          traverse_ast(child, &block)
         end
       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
     end
   end

data/lib/eager_eye/detectors/pluck_to_array.rb

@@ -49,108 +49,75 @@ module EagerEye
         add_issue(node) if regular_pluck?(node)
       end
 
-      def local_variable_assignment?(node)
-        node.type == :lvasgn
-      end
+      def local_variable_assignment?(node) = node.type == :lvasgn
 
-      def where_call?(node)
-        node.type == :send && node.children[1] == :where
-      end
+      def where_call?(node) = node.type == :send && node.children[1] == :where
 
       def pluck_call?(node)
-        return false unless node.is_a?(Parser::AST::Node) && node.type == :send
-
-        method = node.children[1]
-        %i[pluck ids].include?(method)
+        node.is_a?(Parser::AST::Node) && node.type == :send && %i[pluck ids].include?(node.children[1])
       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
+        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)
-
-        block_map?(node) || send_map?(node)
+        node.is_a?(Parser::AST::Node) && (block_map?(node) || send_map?(node))
       end
 
       def block_map?(node)
-        return false unless node.type == :block
-
-        send_node = node.children[0]
-        send_node&.type == :send && %i[map collect].include?(send_node.children[1])
+        node.type == :block && node.children[0]&.type == :send &&
+          %i[map collect].include?(node.children[0].children[1])
       end
 
       def send_map?(node)
-        return false unless node.type == :send
-
-        method = node.children[1]
-        %i[map collect].include?(method) &&
+        node.type == :send && %i[map collect].include?(node.children[1]) &&
           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) && node.type == :block_pass
 
-        sym = node.children[0]
-        sym&.type == :sym && %i[id to_i].include?(sym.children[0])
+        node.children[0]&.type == :sym && %i[id to_i].include?(node.children[0].children[0])
       end
 
       def regular_pluck?(node)
-        where_args = node.children[2..]
-        where_args.any? { |arg| pluck_var_in_hash?(arg) }
+        node.children[2..].any? { |arg| pluck_var_in_hash?(arg) }
       end
 
       def critical_pluck?(node)
-        where_args = node.children[2..]
-        where_args.any? { |arg| critical_pluck_in_hash?(arg) }
+        node.children[2..].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
 
-        node.children.any? do |pair|
-          next false unless pair.type == :pair
-
-          pluck_value?(pair.children[1])
-        end
+        node.children.any? { |pair| pair.type == :pair && pluck_value?(pair.children[1]) }
       end
 
       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
-
-          critical_value?(pair.children[1])
-        end
+        node.children.any? { |pair| pair.type == :pair && critical_value?(pair.children[1]) }
       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)
+        value.type == :lvar && (@pluck_variables.key?(value.children[0]) || @map_id_variables.key?(value.children[0]))
       end
 
       def critical_value?(value)
-        if value.type == :lvar
-          @critical_pluck_variables.key?(value.children[0])
-        else
-          all_pluck_call?(value)
-        end
+        value.type == :lvar ? @critical_pluck_variables.key?(value.children[0]) : all_pluck_call?(value)
       end
 
       def add_issue(node)
         @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 +126,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