rails-ai-context 5.30.2 → 5.31.0

data/lib/rails_ai_context/introspectors/listeners/callbacks_listener.rb

@@ -7,6 +7,7 @@ module RailsAiContext
       # before_validation, after_save, after_commit, etc.
       class CallbacksListener < BaseListener
         include WithOptionsScope
+        include OwnerScope
 
         CALLBACK_METHODS = %i[
           before_validation after_validation
@@ -39,6 +40,31 @@ module RailsAiContext
           end
         end
 
+        ON_EVENT = "after_commit_on_"
+
+        # Every commit spelling lands in the one after-commit kind of one chain.
+        def self.chain_key(type)
+          type.to_s.match?(/\Aafter_(\w+_)?commit/) ? "after_commit" : type.to_s
+        end
+
+        def self.transaction?(type)
+          type.to_s.match?(/\Aafter_(\w+_)?(commit|rollback)/)
+        end
+
+        def self.after?(type)
+          type.to_s.start_with?("after_")
+        end
+
+        # `after_commit on: :create` resolves to a type that names its event.
+        def self.names_event?(type)
+          type.to_s.start_with?(ON_EVENT)
+        end
+
+        # The event such a type names, `"create"`, or nil.
+        def self.event(type)
+          type.to_s.delete_prefix(ON_EVENT) if names_event?(type)
+        end
+
         private
 
         # `around_create Snowflake::Callbacks` names a real target;
@@ -66,6 +92,7 @@ module RailsAiContext
                 type:       callback_type,
                 method:     method_name,
                 options:    options,
+                owner:      @owner_stack.dup,
                 location:   node.location.start_line,
                 confidence: confidence
               }
@@ -77,7 +104,7 @@ module RailsAiContext
         # declaration for several events stays one callback, its on: kept.
         def resolve_callback_types(name, options)
           events = Array(options[:on])
-          name == :after_commit && events.one? ? [ "after_commit_on_#{events.first}" ] : [ name.to_s ]
+          name == :after_commit && events.one? ? [ "#{ON_EVENT}#{events.first}" ] : [ name.to_s ]
         end
       end
     end

data/lib/rails_ai_context/introspectors/listeners/generic_macro_listener.rb

@@ -4,10 +4,11 @@ module RailsAiContext
   module Introspectors
     module Listeners
       class GenericMacroListener < BaseListener
-        def initialize(*target_methods)
+        def initialize(*target_methods, block_source: [])
           super()
           @target_methods = target_methods.flatten.map(&:to_sym).to_set
           @enclosing = []
+          @block_source = block_source.to_set
         end
 
         def on_call_node_enter(node)
@@ -21,6 +22,7 @@ module RailsAiContext
             options:       extract_keyword_options(node),
             option_values: extract_keyword_sources(node),
             option_nodes:  extract_keyword_nodes(node),
+            block:         (one_line_source(node.block) if node.block.is_a?(Prism::BlockNode) && @block_source.include?(node.name)),
             # Offsets, not line numbers: a one-line block puts the parent and
             # its nested calls on one line, and a consumer pairing them by
             # line then attaches the second child to the first.

data/lib/rails_ai_context/introspectors/listeners/mixins_listener.rb

@@ -14,28 +14,11 @@ module RailsAiContext
         MIXIN_MACROS = %i[include prepend extend].to_set.freeze
         ANCESTOR_MACROS = %i[include prepend].to_set.freeze
 
+        include OwnerScope
+
         def initialize
           super
           @singleton_depth = 0
-          @owner_stack = []
-        end
-
-        # The class or module the mixin is written in, the way MethodsListener
-        # records a method's: a nested class's include is not its module's.
-        def on_class_node_enter(node)
-          @owner_stack.push(constant_path_string(node.constant_path))
-        end
-
-        def on_class_node_leave(_node)
-          @owner_stack.pop
-        end
-
-        def on_module_node_enter(node)
-          @owner_stack.push(constant_path_string(node.constant_path))
-        end
-
-        def on_module_node_leave(_node)
-          @owner_stack.pop
         end
 
         # `include` inside `class << self` lands on the singleton class, so it
@@ -48,27 +31,37 @@ module RailsAiContext
           @singleton_depth -= 1
         end
 
+        # `singleton_class` called on what stands for the class: nothing or `self` in its body, `base` in a hook.
+        # `singleton_class.include M` gives the class M's methods, as `extend` does, without `extended`.
+        def self.singleton_class_of?(node, &stands_for_class)
+          node.is_a?(Prism::CallNode) && node.name == :singleton_class && node.arguments.nil? && stands_for_class.call(node.receiver)
+        end
+
+        # The record of `node` mixing in `name`.
+        def self.record(node, macro, name, ancestor:, owner: [])
+          { macro: macro, name: name, ancestor: ancestor, owner: owner, location: node.location.start_line,
+            confidence: confidence_for(node) }
+        end
+
         # `Type.include(StatusPatch)` mixes into Type, not the class the line sits in, so the
         # record names Type as `receiver` and it is never an ancestor of the enclosing class.
         def on_call_node_enter(node)
           receiver = node.receiver && constant_name(node.receiver)
-          return unless node.receiver.nil? || receiver
+          singleton = self.class.singleton_class_of?(node.receiver) { |inner| inner.nil? || inner.is_a?(Prism::SelfNode) }
+          return unless node.receiver.nil? || receiver || singleton
 
           macro, arguments = mixin_call(node)
           return unless macro
+          return if singleton && macro == :extend
+
+          macro = :"singleton_#{macro}" if singleton
 
           arguments.each do |arg|
             name = constant_name(arg)
             next unless name
 
-            record = {
-              macro:      macro,
-              name:       name,
-              ancestor:   receiver.nil? && @singleton_depth.zero? && ANCESTOR_MACROS.include?(macro),
-              owner:      @owner_stack.dup,
-              location:   node.location.start_line,
-              confidence: confidence_for(node)
-            }
+            ancestor = receiver.nil? && @singleton_depth.zero? && ANCESTOR_MACROS.include?(macro)
+            record = self.class.record(node, macro, name, ancestor: ancestor, owner: @owner_stack.dup)
             record[:receiver] = receiver if receiver
             @results << record
           end

data/lib/rails_ai_context/introspectors/listeners/owner_scope.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Introspectors
+    module Listeners
+      # The class or module a record is written in, so a nested class's
+      # declarations stay its own. `Sib = Class.new(Base) do` opens Sib.
+      module OwnerScope
+        def initialize
+          super
+          @owner_stack = []
+          @class_new_writes = []
+        end
+
+        def on_class_node_enter(node)
+          @owner_stack.push(constant_path_string(node.constant_path))
+        end
+
+        def on_class_node_leave(_node)
+          @owner_stack.pop
+        end
+
+        def on_module_node_enter(node)
+          @owner_stack.push(constant_path_string(node.constant_path))
+        end
+
+        def on_module_node_leave(_node)
+          @owner_stack.pop
+        end
+
+        def on_constant_write_node_enter(node)
+          enter_class_new(node, node.name.to_s)
+        end
+
+        def on_constant_write_node_leave(node)
+          leave_class_new(node)
+        end
+
+        def on_constant_path_write_node_enter(node)
+          enter_class_new(node, node.target.slice)
+        end
+
+        def on_constant_path_write_node_leave(node)
+          leave_class_new(node)
+        end
+
+        private
+
+        def enter_class_new(node, name)
+          value = node.value
+          return unless value.is_a?(Prism::CallNode) && value.name == :new && value.block &&
+                        value.receiver.is_a?(Prism::ConstantReadNode) && value.receiver.name == :Class
+
+          @owner_stack.push(name)
+          @class_new_writes.push(node)
+        end
+
+        def leave_class_new(node)
+          return unless @class_new_writes.last.equal?(node)
+
+          @class_new_writes.pop
+          @owner_stack.pop
+        end
+      end
+    end
+  end
+end

data/lib/rails_ai_context/introspectors/listeners/proc_literal_listener.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Introspectors
+    module Listeners
+      # Every Proc literal (`-> {}`, `lambda {}`, `proc {}`, `Proc.new {}`) with
+      # the line it starts on and the constant it is assigned to, if any.
+      class ProcLiteralListener < BaseListener
+        def initialize
+          super
+          @assigned = {}
+        end
+
+        def on_constant_write_node_enter(node)
+          @assigned[node.value.location.start_offset] = node.name.to_s
+        end
+
+        def on_lambda_node_enter(node)
+          record(node)
+        end
+
+        def on_call_node_enter(node)
+          record(node) if proc_call?(node)
+        end
+
+        private
+
+        def proc_call?(node)
+          return false unless node.block.is_a?(Prism::BlockNode)
+          return %i[lambda proc].include?(node.name) if node.receiver.nil?
+
+          node.name == :new && node.receiver.is_a?(Prism::ConstantReadNode) && node.receiver.name == :Proc
+        end
+
+        def record(node)
+          @results << { line: node.location.start_line, constant: @assigned[node.location.start_offset],
+                        source: one_line_source(node) }
+        end
+      end
+    end
+  end
+end