eager_eye 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4adfe62f9c9082d1c0f1e9b149af5f2cc09db5a455af6c0262687a5770b2c50b
-  data.tar.gz: 5284a262cf22fc9e7191dafa0a45383b3f073565313e02d202fb902bc250e7bb
+  metadata.gz: 6329285c3bdd39b8c99bbf665ffef121ac0dc5530b26b8e125d71ca04239a7a4
+  data.tar.gz: 78a608b043a06a58b22a54553d0c0b4ee459c2ee921405f01c5a216a77e801fb
 SHA512:
-  metadata.gz: e40d5802cd52757817d3c6f071abb7203d05ca5b127a72ee5534066b59b4addb2fdec1a592f703864710eec81fa571ef774ada0cd2381995b3819b711366d939
-  data.tar.gz: 50d3bcfa2029032200cae2b4e05ba5ef319f1a981acfc1b8b2969e0dcd977d849d01c2edab51f42808d0bdda538a63be280ad2063f5927907b64e579185c223e
+  metadata.gz: 5d985342e6d3bc4a09dab284b153807b4cda7a7dce898c4dca9ca3e0223e6fb2f575b369426a2a04c30f4d04b557749be8091ee4ed23de4c4a86522d410867ec
+  data.tar.gz: 18ba07590dce273befec6295f0ce05702241ee46a727c05825dd573d44e3019839655f0da14dc9674f5ded7d56b7ee21d802b6264a2b2a85c5f6859928c887da

data/lib/eager_eye/detectors/custom_method_query.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+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
+
+      ITERATION_METHODS = %i[each map select find_all reject collect detect find_index flat_map].freeze
+
+      def self.detector_name
+        :custom_method_query
+      end
+
+      def detect(ast, file_path)
+        return [] unless ast
+
+        @issues = []
+        @file_path = file_path
+
+        find_iteration_blocks(ast) do |block_body, block_var|
+          check_block_for_query_methods(block_body, block_var)
+        end
+
+        @issues
+      end
+
+      private
+
+      def find_iteration_blocks(node, &block)
+        return unless node.is_a?(Parser::AST::Node)
+
+        if iteration_block?(node)
+          block_var = extract_block_variable(node)
+          block_body = extract_block_body(node)
+          yield(block_body, block_var) if block_var && block_body
+        end
+
+        node.children.each do |child|
+          find_iteration_blocks(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)
+      end
+
+      def check_block_for_query_methods(node, block_var)
+        return unless node.is_a?(Parser::AST::Node)
+
+        add_issue(node) if query_chain_on_association?(node, block_var)
+
+        node.children.each do |child|
+          check_block_for_query_methods(child, block_var)
+        end
+      end
+
+      def query_chain_on_association?(node, block_var)
+        return false unless node.type == :send
+
+        method_name = node.children[1]
+        return false unless QUERY_METHODS.include?(method_name)
+
+        receiver = node.children[0]
+        receiver_chain_starts_with?(receiver, 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
+        end
+      end
+
+      def extract_block_variable(block_node)
+        args_node = block_node.children[1]
+        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]
+      end
+
+      def add_issue(node)
+        method_name = node.children[1]
+        association_chain = reconstruct_chain(node.children[0])
+
+        @issues << create_issue(
+          file_path: @file_path,
+          line_number: node.loc.line,
+          message: "Query method `.#{method_name}` called on `#{association_chain}` inside iteration",
+          severity: :warning,
+          suggestion: "This query executes on each iteration. Consider preloading data or restructuring the query."
+        )
+      end
+
+      def reconstruct_chain(node)
+        return "" unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :lvar
+          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
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/eager_eye/detectors/loop_association.rb

@@ -49,7 +49,11 @@ module EagerEye
           block_body = node.children[2]
           next unless block_body
 
-          find_association_calls(block_body, block_var, file_path, issues)
+          # Check if the collection already has includes
+          collection_node = node.children[0]
+          included_associations = extract_included_associations(collection_node)
+
+          find_association_calls(block_body, block_var, file_path, issues, included_associations)
         end
 
         issues
@@ -78,7 +82,44 @@ module EagerEye
         first_arg.children[0]
       end
 
-      def find_association_calls(node, block_var, file_path, issues)
+      def extract_included_associations(collection_node)
+        included = Set.new
+        return included unless collection_node&.type == :send
+
+        # Traverse through chained method calls to find includes()
+        current = collection_node
+        while current&.type == :send
+          method_name = current.children[1]
+          extract_includes_from_method(current, included) if method_name == :includes
+
+          current = current.children[0]
+        end
+
+        included
+      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
+      end
+
+      def find_association_calls(node, block_var, file_path, issues, included_associations = Set.new)
         reported_associations = Set.new
 
         traverse_ast(node) do |child|
@@ -91,6 +132,9 @@ module EagerEye
           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)

data/lib/eager_eye/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EagerEye
-  VERSION = "0.2.0"
+  VERSION = "0.2.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eager_eye
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - hamzagedikkaya
@@ -61,6 +61,7 @@ files:
 - lib/eager_eye/cli.rb
 - lib/eager_eye/configuration.rb
 - lib/eager_eye/detectors/base.rb
+- lib/eager_eye/detectors/custom_method_query.rb
 - lib/eager_eye/detectors/loop_association.rb
 - lib/eager_eye/detectors/missing_counter_cache.rb
 - lib/eager_eye/detectors/serializer_nesting.rb