eager_eye 1.1.0 → 1.1.2

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!
@@ -73,46 +68,32 @@ module EagerEye
       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
+        receiver.children[1].to_s if receiver&.type == :const
       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 extract_block_variable(block_node)
-        args = block_node&.children&.fetch(1, nil)
-        first_child = args&.children&.first
-        first_child&.type == :arg ? first_child.children[0] : nil
+        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
 
@@ -177,10 +158,6 @@ module EagerEye
         included_set.merge(extract_symbols_from_args(args))
       end
 
-      def extract_from_hash(hash_node, included_set)
-        extract_symbols_from_hash(hash_node, included_set)
-      end
-
       def find_association_calls(node, block_var, file_path, issues, included_associations = Set.new)
         reported = Set.new
         traverse_ast(node) do |child|

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,100 +49,67 @@ 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)

data/lib/eager_eye/detectors/serializer_nesting.rb

@@ -3,26 +3,10 @@
 module EagerEye
   module Detectors
     class SerializerNesting < Base
-      # Serializer base classes to detect
-      SERIALIZER_PATTERNS = [
-        "ActiveModel::Serializer",
-        "ActiveModelSerializers::Model",
-        "Blueprinter::Base",
-        "Alba::Resource"
-      ].freeze
-
-      # Method names that define attributes in serializers
+      SERIALIZER_PATTERNS = %w[ActiveModel::Serializer ActiveModelSerializers::Model Blueprinter::Base Alba::Resource].freeze
       ATTRIBUTE_METHODS = %i[attribute field attributes].freeze
-
-      # Object reference names in serializers
       OBJECT_REFS = %i[object record resource].freeze
-
-      # Common association names (same as LoopAssociation)
-      ASSOCIATION_NAMES = %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 avatar photo attachment document
+      HAS_MANY_ASSOCIATIONS = %w[
         authors users owners creators admins members customers clients
         posts articles comments categories tags children companies organizations
         projects tasks items orders products accounts profiles settings
@@ -52,21 +36,16 @@ module EagerEye
       def serializer_class?(node)
         return false unless node.type == :class
 
-        # Check class name ends with Serializer, Blueprint, or Resource
         class_name = extract_class_name(node)
         return false unless class_name
 
         class_name.end_with?("Serializer", "Blueprint", "Resource") ||
-          inherits_from_serializer?(node) ||
-          includes_serializer_module?(node)
+          inherits_from_serializer?(node) || includes_serializer_module?(node)
       end
 
       def extract_class_name(class_node)
         name_node = class_node.children[0]
-        return nil unless name_node
-        return nil unless name_node.type == :const
-
-        name_node.children[1].to_s
+        name_node.children[1].to_s if name_node&.type == :const
       end
 
       def inherits_from_serializer?(class_node)
@@ -74,7 +53,7 @@ module EagerEye
         return false unless parent_node
 
         parent_name = const_to_string(parent_node)
-        SERIALIZER_PATTERNS.any? { |pattern| parent_name&.include?(pattern.split("::").last) }
+        SERIALIZER_PATTERNS.any? { |p| parent_name&.include?(p.split("::").last) }
       end
 
       def includes_serializer_module?(class_node)
@@ -82,20 +61,14 @@ module EagerEye
         return false unless body
 
         traverse_ast(body) do |node|
-          next unless node.type == :send
-
-          method = node.children[1]
-          return true if method == :include && alba_resource?(node)
+          return true if node.type == :send && node.children[1] == :include && alba_resource?(node)
         end
-
         false
       end
 
       def alba_resource?(include_node)
         arg = include_node.children[2]
-        return false unless arg
-
-        const_to_string(arg)&.include?("Alba")
+        arg && const_to_string(arg)&.include?("Alba")
       end
 
       def const_to_string(node)
@@ -103,12 +76,10 @@ module EagerEye
 
         parts = []
         current = node
-
         while current&.type == :const
           parts.unshift(current.children[1].to_s)
           current = current.children[0]
         end
-
         parts.join("::")
       end
 
@@ -117,34 +88,24 @@ module EagerEye
         return unless body
 
         traverse_ast(body) do |node|
-          next unless attribute_block?(node)
-
-          block_body = node.children[2]
-          next unless block_body
+          next unless attribute_block?(node) && node.children[2]
 
-          find_association_in_block(block_body, node, file_path, issues)
+          find_association_in_block(node.children[2], file_path, issues)
         end
       end
 
       def attribute_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]
-        ATTRIBUTE_METHODS.include?(method_name)
+        node.type == :block && node.children[0]&.type == :send &&
+          ATTRIBUTE_METHODS.include?(node.children[0].children[1])
       end
 
-      def find_association_in_block(block_body, _block_node, file_path, issues)
+      def find_association_in_block(block_body, file_path, issues)
         traverse_ast(block_body) do |node|
           next unless node.type == :send
 
           receiver = node.children[0]
           method_name = node.children[1]
-
-          next unless object_reference?(receiver)
-          next unless likely_association?(method_name)
+          next unless object_reference?(receiver) && likely_association?(method_name)
 
           issues << create_issue(
             file_path: file_path,
@@ -159,33 +120,22 @@ module EagerEye
         return false unless node
 
         case node.type
-        when :send
-          # object.something or record.something
-          receiver = node.children[0]
-          method = node.children[1]
-
-          receiver.nil? && OBJECT_REFS.include?(method)
-        when :lvar
-          # Block variable like |post|
-          true
-        else
-          false
+        when :send then node.children[0].nil? && OBJECT_REFS.include?(node.children[1])
+        when :lvar then true
+        else false
         end
       end
 
       def receiver_name(node)
         case node.type
-        when :send
-          node.children[1].to_s
-        when :lvar
-          node.children[0].to_s
-        else
-          "object"
+        when :send then node.children[1].to_s
+        when :lvar then node.children[0].to_s
+        else "object"
         end
       end
 
       def likely_association?(method_name)
-        ASSOCIATION_NAMES.include?(method_name.to_s)
+        HAS_MANY_ASSOCIATIONS.include?(method_name.to_s)
       end
     end
   end