scryer 0.1.0

data/lib/scryer/performance_rules/inefficient_save_loop_rule.rb

@@ -0,0 +1,108 @@
+module Scryer
+  module PerformanceRules
+    # Flags `.save`/`.save!`/`.update`/`.update!`/`.update_attribute(s)` called
+    # on the block variable inside a `.each`/`.each_with_index` loop — one
+    # database write per iteration where a single bulk statement
+    # (`update_all`/`insert_all`/`upsert_all`) could often do the same work in
+    # one round-trip. Best-effort: this rule can't tell whether the
+    # per-record operation is actually uniform enough to batch (e.g. distinct
+    # values per row still need `update_all` with a `CASE`, or don't fit the
+    # bulk-method shape at all) — it's a nudge to double check, not a
+    # guarantee the loop is replaceable as-is.
+    class InefficientSaveLoopRule < Rule
+      self.rule_id = "inefficient_save_loop"
+      self.category = "performance"
+      self.default_severity = "warning"
+      self.title = "Per-record save/update inside a loop"
+
+      LOOP_METHODS = %w[each each_with_index].freeze
+      # Genuinely argless in normal use — a bare `:call` node, never wrapped
+      # by a method_add_arg, so matching this tag alone can't double-count.
+      BARE_METHODS = %w[save save!].freeze
+      # Always take an argument, so they only ever show up wrapped in
+      # method_add_arg/command/command_call — matching only the wrapper
+      # avoids double-counting the inner call node these wrap.
+      ARG_METHODS = %w[update update! update_attribute update_attributes].freeze
+
+      def scan
+        findings = []
+
+        Ast.each_node(sexp) do |node|
+          next unless Ast.tagged?(node, :method_add_block)
+
+          call_node = node[1]
+          _receiver, loop_method = Ast.call_name(call_node) || [nil, nil]
+          next unless LOOP_METHODS.include?(loop_method)
+
+          block_node = node[2]
+          param_name = block_param_name(block_node)
+          next unless param_name
+
+          find_save_calls(block_node[2], param_name).each do |line, method_name|
+            findings << finding(
+              line: line,
+              message: "Inside a `.each` loop, `.#{method_name}` runs once per record — each call " \
+                        "is a separate database round-trip, which scales linearly with the number " \
+                        "of records instead of running as one bulk statement.",
+              suggested_fix: "If every record gets the same update, replace the loop with " \
+                              "`Model.where(...).update_all(column: value)` (one UPDATE for the whole " \
+                              "set). If each record's new values differ but come from data already " \
+                              "in hand, `upsert_all`/`insert_all` with an array of attribute hashes " \
+                              "can also replace the per-row round-trips."
+            )
+          end
+        end
+
+        findings
+      end
+
+      private
+
+      def block_param_name(block_node)
+        return nil unless Ast.tagged?(block_node, :do_block, :brace_block)
+
+        block_var = block_node[1]
+        return nil unless Ast.tagged?(block_var, :block_var)
+
+        params = block_var[1]
+        first_param = params.is_a?(Array) ? params[1]&.first : nil
+        return nil unless first_param.is_a?(Array) && first_param[0] == :@ident
+
+        first_param[1]
+      end
+
+      def block_var_receiver?(node, param_name)
+        return false unless Ast.tagged?(node, :var_ref, :vcall)
+
+        inner = node[1]
+        inner.is_a?(Array) && %i[@ident @ivar].include?(inner[0]) && inner[1] == param_name
+      end
+
+      def find_save_calls(body, param_name)
+        results = []
+
+        Ast.each_node(body) do |n|
+          if Ast.tagged?(n, :call)
+            name = Ast.ident_text(n[3])
+            next unless BARE_METHODS.include?(name)
+            next unless block_var_receiver?(n[1], param_name)
+
+            results << [Ast.line_of(n), name]
+          elsif Ast.tagged?(n, :method_add_arg, :command, :command_call)
+            inner = Ast.tagged?(n, :method_add_arg) ? n[1] : n
+            receiver_and_name = Ast.call_name(inner)
+            next unless receiver_and_name
+
+            receiver, name = receiver_and_name
+            next unless ARG_METHODS.include?(name)
+            next unless block_var_receiver?(receiver, param_name)
+
+            results << [Ast.line_of(n), name]
+          end
+        end
+
+        results
+      end
+    end
+  end
+end

data/lib/scryer/performance_rules/missing_pagination_rule.rb

@@ -0,0 +1,132 @@
+module Scryer
+  module PerformanceRules
+    # Flags a controller `index` action that loads `Model.all` or a bare
+    # `Model.where(...)` (no `.limit`/`.page`/`.per`/`.paginate`/`.find_each`
+    # bound anywhere in the chain) and hands the result straight to an
+    # instance variable or `render` — i.e. nothing bounds how many rows get
+    # loaded and rendered. Heuristic: only looks at the literal call chain
+    # text, not what happens to the variable afterwards (e.g. slicing it in
+    # the view would not be detected as "safe" by this rule).
+    class MissingPaginationRule < Rule
+      self.rule_id = "missing_pagination"
+      self.category = "performance"
+      self.default_severity = "warning"
+      self.title = "Possible unbounded result set on an index action"
+
+      QUERY_METHODS = %w[all where].freeze
+      BOUND_METHODS = %w[limit page per paginate find_each find_in_batches first take].freeze
+
+      def scan
+        findings = []
+
+        Ast.each_node(sexp) do |node|
+          next unless Ast.tagged?(node, :def)
+          next unless Ast.ident_text(node[1]) == "index"
+
+          body = node.last
+          findings.concat(check_body(body))
+        end
+
+        findings
+      end
+
+      private
+
+      def check_body(body)
+        results = []
+        seen_lines = []
+
+        sink_values(body).each do |value|
+          next unless unbounded_query?(value)
+
+          line = Ast.line_of(value)
+          next if seen_lines.include?(line)
+
+          seen_lines << line
+          results << finding(
+            line: line,
+            message: "The `index` action loads records with no `.limit`/`.page`/`.per` bound — " \
+                      "as the table grows this action will load (and likely render) every row, " \
+                      "getting slower and more memory-hungry over time.",
+            suggested_fix: "Bound the result set, e.g. with Kaminari/will_paginate " \
+                            "(`Model.page(params[:page]).per(25)`) or a plain `.limit(...)`, " \
+                            "so the action's cost stays roughly constant as the table grows."
+          )
+        end
+
+        results
+      end
+
+      # Collects the value expressions that end up as an ivar/local assignment
+      # or a `render(...)` argument — the "sinks" an unbounded query could flow
+      # into directly.
+      def sink_values(body)
+        values = []
+
+        Ast.each_node(body) do |node|
+          if Ast.tagged?(node, :assign) && assignable_target?(node[1])
+            values << node[2]
+          elsif render_call?(node)
+            values.concat(flatten_arg_values(Ast.call_arguments(node)))
+          end
+        end
+
+        values
+      end
+
+      def assignable_target?(target)
+        return false unless Ast.tagged?(target, :var_field)
+
+        inner = target[1]
+        inner.is_a?(Array) && %i[@ident @ivar].include?(inner[0])
+      end
+
+      def render_call?(node)
+        inner = Ast.tagged?(node, :method_add_arg) ? node[1] : node
+        return false unless Ast.tagged?(inner, :command, :fcall, :call, :vcall, :command_call)
+
+        Ast.call_name(inner)&.last == "render"
+      end
+
+      def flatten_arg_values(nodes)
+        nodes.flat_map do |n|
+          if Ast.tagged?(n, :bare_assoc_hash)
+            n[1].filter_map { |assoc| Ast.tagged?(assoc, :assoc_new) ? assoc[2] : nil }
+          else
+            [n]
+          end
+        end
+      end
+
+      def unbounded_query?(value)
+        return false unless value.is_a?(Array)
+
+        root = root_of(value)
+        return false unless Ast.tagged?(root, :var_ref, :vcall)
+
+        const = root[1]
+        return false unless const.is_a?(Array) && const[0] == :@const
+
+        method_names = Ast.each_node(value).filter_map do |n|
+          next unless Ast.tagged?(n, :call, :method_add_arg, :command, :vcall, :fcall)
+
+          inner = Ast.tagged?(n, :method_add_arg) ? n[1] : n
+          Ast.call_name(inner)&.last
+        end
+
+        (method_names & QUERY_METHODS).any? && (method_names & BOUND_METHODS).none?
+      end
+
+      def root_of(node)
+        return node unless node.is_a?(Array)
+
+        case node[0]
+        when :method_add_arg, :call, :command_call
+          root_of(node[1])
+        else
+          node
+        end
+      end
+    end
+  end
+end

data/lib/scryer/performance_rules/n_plus_one_query_rule.rb

@@ -0,0 +1,221 @@
+module Scryer
+  module PerformanceRules
+    # Flags likely N+1 queries: inside a `.each`/`.map` block whose receiver
+    # looks like an Active Record collection (a local variable previously
+    # assigned from `Model.where(...)`/`Model.all`/`Model.find(...)`, or a bare
+    # instance variable — the common `@orders.each do |order| ... end` shape),
+    # a bare no-arg `.method_name` call directly on the block variable (likely
+    # an association access, e.g. `order.line_items`) is flagged unless an
+    # `.includes(:that_name)` appeared earlier in the same base query chain.
+    #
+    # This is a heuristic, not type inference: it can't tell an association
+    # read (`order.line_items`, which issues a query per row) from a plain
+    # attribute/column read (`order.status`) or a harmless Ruby method call —
+    # both parse identically as a bare no-arg call on the block variable. A
+    # small block-list of universally-common non-association methods
+    # (to_s, present?, class, ...) cuts down the noisiest false positives, but
+    # real false positives on attribute reads are still expected and normal
+    # for this class of tool (see README).
+    class NPlusOneQueryRule < Rule
+      self.rule_id = "n_plus_one_query"
+      self.category = "performance"
+      self.default_severity = "warning"
+      self.title = "Possible N+1 query inside a loop"
+
+      QUERY_METHODS = %w[where all find find_by find_by! order limit].freeze
+      LOOP_METHODS = %w[each map collect each_with_index].freeze
+
+      # Bare methods that are overwhelmingly plain Ruby/attribute reads rather
+      # than association traversal — flagging these would be mostly noise.
+      NON_ASSOCIATION_METHODS = %w[
+        to_s to_i to_a to_h inspect class dup clone freeze frozen? hash
+        present? blank? nil? empty? any? id id_value == equal? try tap then
+        is_a? kind_of? instance_of? respond_to? send public_send object_id
+        itself
+      ].freeze
+
+      def scan
+        findings = []
+
+        Ast.each_node(sexp) do |node|
+          next unless Ast.tagged?(node, :def, :defs)
+
+          body = node.last
+          bindings = query_bindings(body)
+
+          Ast.each_node(body) do |block_call|
+            next unless Ast.tagged?(block_call, :method_add_block)
+
+            call_node = block_call[1]
+            receiver, loop_method = Ast.call_name(call_node) || [nil, nil]
+            next unless LOOP_METHODS.include?(loop_method)
+            next unless receiver
+
+            base_name = var_or_ivar_name(receiver)
+            next unless base_name
+
+            includes = if bindings.key?(base_name)
+                         bindings[base_name]
+                       elsif base_name.start_with?("@")
+                         [] # ivar set elsewhere — treat as an AR collection with no known eager-loading
+                       end
+            next unless includes # local var we never saw assigned from a query — don't guess
+
+            block_node = block_call[2]
+            param_name = block_param_name(block_node)
+            next unless param_name
+
+            findings.concat(association_calls(block_node[2], param_name, includes))
+          end
+        end
+
+        findings
+      end
+
+      private
+
+      # Local-variable/ivar assignments in this method whose value is a query
+      # chain rooted at a bare Model constant, mapped to the set of association
+      # names already eager-loaded via `.includes(...)` in that same chain.
+      def query_bindings(body)
+        bindings = {}
+
+        Ast.each_node(body) do |node|
+          next unless Ast.tagged?(node, :assign)
+
+          name = assign_target_name(node[1])
+          next unless name
+
+          value = node[2]
+          next unless query_chain?(value)
+
+          bindings[name] = includes_symbols(value)
+        end
+
+        bindings
+      end
+
+      def assign_target_name(target)
+        return nil unless Ast.tagged?(target, :var_field)
+
+        inner = target[1]
+        return nil unless inner.is_a?(Array)
+
+        inner[1] if %i[@ident @ivar].include?(inner[0])
+      end
+
+      def query_chain?(value)
+        root = root_of(value)
+        return false unless Ast.tagged?(root, :var_ref, :vcall)
+
+        const = root[1]
+        return false unless const.is_a?(Array) && const[0] == :@const
+
+        Ast.each_node(value).any? do |n|
+          next false unless Ast.tagged?(n, :call, :method_add_arg, :command, :vcall, :fcall)
+
+          inner = Ast.tagged?(n, :method_add_arg) ? n[1] : n
+          name = Ast.call_name(inner)&.last
+          QUERY_METHODS.include?(name)
+        end
+      end
+
+      def includes_symbols(value)
+        names = []
+
+        Ast.each_node(value) do |n|
+          next unless Ast.tagged?(n, :method_add_arg)
+
+          receiver_and_name = Ast.call_name(n[1])
+          next unless receiver_and_name && receiver_and_name.last == "includes"
+
+          Ast.call_arguments(n).each do |arg|
+            sym = symbol_name(arg)
+            names << sym if sym
+          end
+        end
+
+        names
+      end
+
+      def symbol_name(node)
+        return nil unless Ast.tagged?(node, :symbol_literal)
+
+        # symbol_literal wraps [:symbol, [:@ident, name, pos]] — one more
+        # level of unwrapping than a bare @ident node.
+        wrapper = node[1]
+        return nil unless Ast.tagged?(wrapper, :symbol)
+
+        ident = wrapper[1]
+        return nil unless ident.is_a?(Array)
+
+        ident[1] if %i[@ident @const @kw].include?(ident[0])
+      end
+
+      # Walks down the leftmost receiver chain of a call expression to find
+      # the root object the whole chain is called on.
+      def root_of(node)
+        return node unless node.is_a?(Array)
+
+        case node[0]
+        when :method_add_arg, :call, :command_call
+          root_of(node[1])
+        else
+          node
+        end
+      end
+
+      def var_or_ivar_name(node)
+        return nil unless Ast.tagged?(node, :var_ref, :vcall)
+
+        inner = node[1]
+        return nil unless inner.is_a?(Array)
+
+        inner[1] if %i[@ident @ivar].include?(inner[0])
+      end
+
+      def block_param_name(block_node)
+        return nil unless Ast.tagged?(block_node, :do_block, :brace_block)
+
+        block_var = block_node[1]
+        return nil unless Ast.tagged?(block_var, :block_var)
+
+        params = block_var[1]
+        first_param = params.is_a?(Array) ? params[1]&.first : nil
+        return nil unless first_param.is_a?(Array) && first_param[0] == :@ident
+
+        first_param[1]
+      end
+
+      def association_calls(body, param_name, includes)
+        results = []
+
+        Ast.each_node(body) do |n|
+          next unless Ast.tagged?(n, :call)
+
+          receiver = n[1]
+          next unless var_or_ivar_name(receiver) == param_name
+
+          method_name = Ast.ident_text(n[3])
+          next unless method_name
+          next if NON_ASSOCIATION_METHODS.include?(method_name)
+          next if includes.include?(method_name)
+
+          line = Ast.line_of(n)
+          results << finding(
+            line: line,
+            message: "`#{param_name}.#{method_name}` is called inside a loop — if `#{method_name}` " \
+                      "is an association, this issues a separate query per iteration instead of one " \
+                      "batched query (a classic N+1).",
+            suggested_fix: "Eager-load the association on the base query before the loop, e.g. " \
+                            "`#{param_name.chomp('s')}s = Model.includes(:#{method_name}).where(...)` " \
+                            "(or add `:#{method_name}` to an existing `.includes(...)` call), so Rails " \
+                            "fetches it in one extra query instead of one per record."
+          )
+        end
+
+        results
+      end
+    end
+  end
+end

data/lib/scryer/performance_rules/unbounded_table_scan_rule.rb

@@ -0,0 +1,78 @@
+module Scryer
+  module PerformanceRules
+    # Flags `Model.all.each`/`Model.where(...).each` (or `.order(...).each`) —
+    # chaining `.each` directly onto a query loads every matching row into
+    # memory at once before iterating. `find_each`/`find_in_batches` load and
+    # yield records in bounded batches instead, keeping memory flat regardless
+    # of table size. This only looks at the literal chain (`Const.query.each`)
+    # so it won't catch the same problem one step removed — e.g. a variable
+    # assigned from the query and iterated later (that pattern is out of scope
+    # here; see `NPlusOneQueryRule`, which does track simple local
+    # assignments, for a related check on what happens *inside* such a loop).
+    class UnboundedTableScanRule < Rule
+      self.rule_id = "unbounded_table_scan"
+      self.category = "performance"
+      self.default_severity = "warning"
+      self.title = "Full query result loaded into memory before iterating"
+
+      QUERY_METHODS = %w[all where order].freeze
+
+      def scan
+        findings = []
+
+        Ast.each_node(sexp) do |node|
+          next unless Ast.tagged?(node, :method_add_block)
+
+          call_node = node[1]
+          receiver, method_name = Ast.call_name(call_node) || [nil, nil]
+          next unless method_name == "each"
+          next unless receiver
+          next unless direct_query_chain?(receiver)
+
+          line = Ast.line_of(call_node)
+          findings << finding(
+            line: line,
+            message: "`.each` is chained directly onto a query — Active Record loads every " \
+                      "matching row into memory before the block runs even once, which can exhaust " \
+                      "memory (or just be very slow) once the table is large.",
+            suggested_fix: "Use `find_each` (row-by-row, fixed batch size) or `find_in_batches` " \
+                            "(access a batch `Array` at a time) instead of `.each`, e.g. " \
+                            "`Model.where(...).find_each { |record| ... }` — Active Record loads and " \
+                            "discards records in bounded batches instead of all at once."
+          )
+        end
+
+        findings
+      end
+
+      private
+
+      def direct_query_chain?(receiver)
+        return false unless receiver.is_a?(Array)
+
+        inner = Ast.tagged?(receiver, :method_add_arg) ? receiver[1] : receiver
+        return false unless Ast.tagged?(inner, :call)
+
+        _, name = Ast.call_name(inner)
+        return false unless QUERY_METHODS.include?(name)
+
+        root = root_of(receiver)
+        return false unless Ast.tagged?(root, :var_ref, :vcall)
+
+        const = root[1]
+        const.is_a?(Array) && const[0] == :@const
+      end
+
+      def root_of(node)
+        return node unless node.is_a?(Array)
+
+        case node[0]
+        when :method_add_arg, :call, :command_call
+          root_of(node[1])
+        else
+          node
+        end
+      end
+    end
+  end
+end

data/lib/scryer/query_extractor.rb

@@ -0,0 +1,123 @@
+require "ripper"
+
+module Scryer
+  # Extracts each Active Record query chain rooted at a bare Model constant
+  # (`User.where(...).order(...)`, `Order.joins(:items).count`, ...) as a
+  # MethodInfo — same shape MethodExtractor produces for `def`s, so it can
+  # feed the same DuplicateDetector — to catch copy-pasted query logic that
+  # never got extracted into a scope/service, even when the surrounding
+  # methods themselves don't look alike.
+  #
+  # A "chain" is captured at its outermost call (the last method in the
+  # chain), and the walk does not recurse into a chain it just captured —
+  # so `User.where(...).order(...)` is one unit, not also a nested `where`
+  # unit. This means a subquery buried inside a captured chain's arguments
+  # (e.g. `Foo.where(id: Bar.select(:id))`) isn't separately extracted — an
+  # accepted simplification, not a correctness bug: it would still be found
+  # if the same subquery shape appears somewhere else outside a captured
+  # chain.
+  module QueryExtractor
+    module_function
+
+    # Mirrors the query-method lists in NPlusOneQueryRule/UnboundedTableScanRule
+    # but broader, since here we're looking for "this is recognizably a query"
+    # rather than one specific anti-pattern.
+    QUERY_METHODS = %w[
+      where find_by find_by! find_or_create_by find_or_initialize_by
+      order reorder limit offset joins left_joins includes preload eager_load
+      references group having select distinct pluck exists? count sum average
+      minimum maximum find first last not or none unscope ids find_each
+      find_in_batches in_batches lock readonly
+    ].freeze
+
+    MIN_TOKENS = 8 # shorter than MethodExtractor's threshold — queries are terser than whole methods
+
+    def extract(file:, source:, sexp:)
+      queries = []
+      walk(sexp) do |node|
+        info = build_info(node, file: file, source: source)
+        queries << info if info
+      end
+      queries
+    end
+
+    def walk(node, &block)
+      return unless node.is_a?(Array)
+
+      if chain_root?(node)
+        block.call(node)
+        return # don't descend into a chain we just captured — see module doc
+      end
+
+      node.each { |child| walk(child, &block) }
+    end
+
+    def chain_root?(node)
+      inner = Ast.tagged?(node, :method_add_arg) ? node[1] : node
+      name = Ast.call_name(inner)&.last
+      return false unless name && QUERY_METHODS.include?(name)
+
+      root = root_of(node)
+      Ast.tagged?(root, :var_ref, :vcall) &&
+        root[1].is_a?(Array) && root[1][0] == :@const
+    end
+
+    # Walks down the leftmost receiver chain to the constant the whole chain
+    # is called on (same logic as NPlusOneQueryRule#root_of).
+    def root_of(node)
+      return node unless node.is_a?(Array)
+
+      case node[0]
+      when :method_add_arg, :call, :command_call
+        root_of(node[1])
+      else
+        node
+      end
+    end
+
+    def build_info(node, file:, source:)
+      start_line, end_line = Ast.line_range_of(node)
+      return nil unless start_line
+
+      tokens = Ast.normalized_tokens(node)
+      return nil if tokens.size < MIN_TOKENS
+
+      const_name = Ast.ident_text(root_of(node)[1]) || "?"
+
+      MethodInfo.new(
+        name: "#{const_name}.#{chain_label(node)}",
+        file: file,
+        start_line: start_line,
+        end_line: end_line,
+        token_stream: tokens,
+        source_snippet: Ast.source_text(source, node)
+      )
+    end
+
+    # Best-effort ".method1.method2" label (outermost-first) for display —
+    # not used for comparison, just so a finding reads as
+    # "User.where.order" instead of a bare line number. Each iteration
+    # unwraps one call link (method_add_arg -> its :call, or a bare :call)
+    # and steps the cursor to *that* call's receiver, so a chain link is
+    # never counted twice.
+    def chain_label(node)
+      names = []
+      cursor = node
+
+      loop do
+        break unless cursor.is_a?(Array)
+
+        inner = Ast.tagged?(cursor, :method_add_arg) ? cursor[1] : cursor
+        break unless Ast.tagged?(inner, :call, :vcall, :fcall, :command)
+
+        name = Ast.call_name(inner)&.last
+        names.unshift(name) if name
+        break unless Ast.tagged?(inner, :call) # vcall/fcall/command have no receiver to descend into
+
+        cursor = inner[1]
+      end
+
+      names.join(".")
+    end
+  end
+end