rails-ai-context 5.30.2 → 5.32.0

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Introspectors
+    module Listeners
+      # Calls on an HTTP client constant with a literal URL: `Faraday.get("https://x")`,
+      # `Net::HTTP.get(URI("https://x"))`, `Faraday.new(url: "https://x")`, `URI.open("https://x")`,
+      # and `Net::HTTP.start("api.x.com", 443)`, whose first argument is a host.
+      class HttpClientCallListener < BaseListener
+        CLIENTS = %w[Faraday Net::HTTP HTTParty RestClient HTTP Excon Typhoeus].freeze
+
+        def on_call_node_enter(node)
+          client = client_name(node) or return
+
+          first = node.arguments&.arguments&.first
+          if client == "Net::HTTP" && %i[start new].include?(node.name)
+            host = literal_string(first)
+            @results << { client: client, host: host, line: node.location.start_line } if host
+          elsif (url = url_literal(first) || url_literal(extract_keyword_nodes(node)[:url]))
+            @results << { client: client, url: url, line: node.location.start_line }
+          end
+        end
+
+        private
+
+        def client_name(node)
+          receiver = node.receiver
+          return nil unless receiver.is_a?(Prism::ConstantReadNode) || receiver.is_a?(Prism::ConstantPathNode)
+
+          name = constant_path_string(receiver)
+          return "URI.open" if name == "URI" && node.name == :open
+
+          name if CLIENTS.include?(name)
+        end
+
+        # A string literal, or one wrapped in `URI(...)` or `URI.parse(...)`.
+        def url_literal(node)
+          return node.unescaped if node.is_a?(Prism::StringNode)
+          return nil unless node.is_a?(Prism::CallNode)
+
+          receiver = node.receiver
+          wrapped = (receiver.nil? && node.name == :URI) ||
+            (node.name == :parse && receiver.is_a?(Prism::ConstantReadNode) && receiver.name == :URI)
+          inner = node.arguments&.arguments&.first
+          inner.unescaped if wrapped && inner.is_a?(Prism::StringNode)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Introspectors
+    module Listeners
+      # Locale files an app adds to I18n's load path, literal paths and globs only:
+      #
+      #   config.i18n.load_path += Dir[Rails.root.join("my/locales/*.{rb,yml}")] → "my/locales/*.{rb,yml}"
+      #   I18n.load_path << "#{Rails.root}/lib/locales/de.yml"                   → "lib/locales/de.yml"
+      #   config.i18n.load_path = Dir[Rails.root.join("x/*.yml")]                → "x/*.yml"
+      #
+      # The path forms are LiteralPaths', plus the Dir[] / Dir.glob wrapper.
+      class I18nLoadPathListener < BaseListener
+        include LiteralPaths
+
+        def on_call_node_enter(node)
+          if node.name == :load_path= && i18n?(node.receiver)
+            collect_paths(node.arguments&.arguments&.first)
+          elsif APPENDING.include?(node.name) && load_path?(node.receiver)
+            Array(node.arguments&.arguments).each { |argument| collect_paths(argument) }
+          end
+        end
+
+        def on_call_operator_write_node_enter(node)
+          return unless node.binary_operator == :+ && node.read_name == :load_path && i18n?(node.receiver)
+
+          collect_paths(node.value)
+        end
+
+        private
+
+        def load_path?(node)
+          node.is_a?(Prism::CallNode) && node.name == :load_path && i18n?(node.receiver)
+        end
+
+        def i18n?(node)
+          case node
+          when Prism::CallNode then node.name == :i18n
+          when Prism::ConstantReadNode, Prism::ConstantPathNode then node.slice.delete_prefix("::") == "I18n"
+          else false
+          end
+        end
+
+        def collect_call_path(node)
+          if %i[[] glob].include?(node.name) && node.receiver&.slice&.delete_prefix("::") == "Dir"
+            return collect_paths(node.arguments&.arguments&.first)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module RailsAiContext
+  module Introspectors
+    module Listeners
+      # The literal path forms an app writes a setting with: a string, `%W(#{config.root}/x)`,
+      # `Rails.root.join("x")`. Each one read lands in `push_path`; a path built at run time stays unread.
+      # `collect_paths` returns whether it read the whole node, so a caller can tell a partly read write.
+      module LiteralPaths
+        APPENDING = %i[<< push append concat].to_set.freeze
+
+        private
+
+        def paths_receiver?(node)
+          node.is_a?(Prism::CallNode) && node.name == :paths
+        end
+
+        def collect_paths(node)
+          case node
+          when Prism::ArrayNode then node.elements.map { |element| collect_paths(element) }.all?
+          when Prism::StringNode then push_path(node.unescaped)
+          when Prism::InterpolatedStringNode then collect_interpolated_path(node)
+          when Prism::CallNode then collect_call_path(node)
+          end
+        end
+
+        # `"#{config.root}/lib_static"`, and only that: a gem's root names a path outside
+        # the app, and a later interpolation leaves the path unknown.
+        def collect_interpolated_path(node)
+          return unless app_root?(node.parts.first) && node.parts.drop(1).all?(Prism::StringNode)
+
+          push_path(node.parts.drop(1).map(&:content).join)
+        end
+
+        # `Rails.root.join("lib_static")` and its `.to_s`, whose arguments are
+        # the path relative to the app root.
+        def collect_call_path(node)
+          return collect_file_path(node) if @file && file_constant?(node.receiver)
+          return collect_paths(node.receiver) unless node.name == :join
+
+          segments = app_root_join(node)
+          push_path(File.join(*segments)) if segments
+        end
+
+        # `File.expand_path("x", __dir__)` and `File.join(__dir__, "x")`, read when the
+        # listener is given `@file`, the walked file's path relative to the app root.
+        def collect_file_path(node)
+          arguments = Array(node.arguments&.arguments)
+          path = case node.name
+          when :expand_path then file_relative(arguments.first, arguments[1]) if arguments.size == 2
+          when :join then file_relative_join(arguments)
+          end
+          push_path(path) if path
+        end
+
+        def file_relative(relative, base)
+          return unless relative.is_a?(Prism::StringNode)
+
+          anchor = file_anchor(base) or return
+          Pathname.new(File.join(anchor, relative.unescaped)).cleanpath.to_s
+        end
+
+        def file_relative_join(arguments)
+          anchor = file_anchor(arguments.first) or return
+          rest = arguments.drop(1)
+          return unless rest.any? && rest.all?(Prism::StringNode)
+
+          Pathname.new(File.join(anchor, *rest.map(&:unescaped))).cleanpath.to_s
+        end
+
+        # `File.expand_path("x", __FILE__)` resolves against the file name itself, as Ruby does.
+        def file_anchor(node)
+          case node
+          when Prism::SourceFileNode then @file
+          when Prism::CallNode then File.dirname(@file) if dir_call?(node) || file_dirname_call?(node)
+          end
+        end
+
+        # `File.dirname(__FILE__)`, the older spelling of `__dir__`.
+        def file_dirname_call?(node)
+          arguments = Array(node.arguments&.arguments)
+          node.name == :dirname && file_constant?(node.receiver) && arguments.size == 1 && arguments.first.is_a?(Prism::SourceFileNode)
+        end
+
+        # The segments of `Rails.root.join("a", "b")`, nil unless every one is a literal.
+        def app_root_join(node)
+          return nil unless node.is_a?(Prism::CallNode) && node.name == :join && app_root?(node.receiver)
+
+          segments = Array(node.arguments&.arguments)
+          segments.map(&:unescaped) if segments.any? && segments.all?(Prism::StringNode)
+        end
+
+        # `root`, `config.root`, `Rails.root` or `::Rails.root`.
+        def app_root?(node)
+          node = node.statements if node.is_a?(Prism::EmbeddedStatementsNode)
+          node = node.body.first if node.is_a?(Prism::StatementsNode)
+          return false unless node.is_a?(Prism::CallNode) && node.name == :root && node.arguments.nil? && node.block.nil?
+
+          receiver = node.receiver
+          case receiver
+          when nil then true
+          when Prism::CallNode then receiver.name == :config && receiver.receiver.nil? && receiver.arguments.nil?
+          when Prism::LocalVariableReadNode then receiver.name == :config
+          when Prism::ConstantReadNode, Prism::ConstantPathNode then constant_path_string(receiver) == "Rails"
+          else false
+          end
+        end
+
+        def push_path(value)
+          cleaned = value.to_s.strip.delete_prefix("/")
+          record_path(cleaned) unless cleaned.empty?
+          true
+        end
+
+        def record_path(path)
+          @results << path
+        end
+      end
+    end
+  end
+end

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

@@ -9,6 +9,8 @@ module RailsAiContext
       # broadcasts, generates_token_for, attribute, etc.
       class MacrosListener < BaseListener
         include WithOptionsScope
+        include OwnerScope
+        include BranchConditions
 
         SIMPLE_MACROS = %i[
           has_secure_password
@@ -16,24 +18,109 @@ module RailsAiContext
 
         ATTRIBUTE_MACROS = %i[
           encrypts normalizes has_one_attached has_many_attached
-          has_rich_text generates_token_for serialize store store_accessor
+          has_rich_text generates_token_for serialize attr_readonly query_constraints
         ].to_set.freeze
 
+        # Class settings each change how the model reads, writes or loads; kept as written.
+        SETTINGS = %i[
+          inheritance_column= store_full_sti_class= strict_loading_by_default=
+          implicit_order_column= locking_column=
+        ].to_set.freeze
+
+        STORE_MACROS = %i[store store_accessor].to_set.freeze
+
         BROADCAST_MACROS = %i[
           broadcasts broadcasts_to broadcasts_refreshes_to
         ].to_set.freeze
 
+        # Model gems' class macros, each listed as written; aasm's block is read in full.
+        GEM_MACROS = %i[
+          has_paper_trail audited acts_as_paranoid friendly_id
+          mount_uploader mount_uploaders monetize
+          pg_search_scope multisearchable searchkick
+          acts_as_list acts_as_tenant multi_tenant acts_as_taggable acts_as_taggable_on
+          has_ancestry acts_as_nested_set has_closure_tree acts_as_tree
+          state_machine workflow
+        ].to_set.freeze
+
+        def initialize
+          super
+          @def_depth = 0
+          @eval_depths = []
+        end
+
+        def on_def_node_enter(_node)
+          @def_depth += 1
+        end
+
+        def on_def_node_leave(_node)
+          @def_depth -= 1
+        end
+
+        # A method body runs only when called, so only a call sent to a mixin hook's
+        # includer counts there. Each record names the class it is written in.
         def on_call_node_enter(node)
+          return if @def_depth.positive? && !(node.receiver && in_scope?(node))
+
+          owned { record_call(node) }
+          # `base.class_eval do` in a hook runs its block on the includer, as a class body.
+          return unless @def_depth.positive? && node.block && WithOptionsScope::EVALS.include?(node.name)
+
+          @eval_depths.push([ node, @def_depth ])
+          @def_depth = 0
+        end
+
+        def on_call_node_leave(node)
+          @def_depth = @eval_depths.pop.last if @eval_depths.last&.first.equal?(node)
+          @aasm = nil if @aasm && @aasm[:node].equal?(node)
+          @event = nil if @event && @event[:node].equal?(node)
+        end
+
+        # self.ignored_columns += [...] and -= [...]
+        def on_call_operator_write_node_enter(node)
+          return unless @def_depth.zero? && node.read_name == :ignored_columns && node.receiver.is_a?(Prism::SelfNode)
+
+          op = { :+ => :add, :- => :remove }[node.binary_operator]
+          owned { record_ignored_columns(node, op) } if op
+        end
+
+        private
+
+        def owned
+          count = @results.size
+          yield
+          @results.drop(count).each { |result| result[:owner] = @owner_stack.dup }
+        end
+
+        def record_call(node)
+          return record_ignored_columns(node, :assign) if node.name == :ignored_columns= && node.receiver.is_a?(Prism::SelfNode)
+          return record_setting(node) if SETTINGS.include?(node.name) && node.receiver.is_a?(Prism::SelfNode)
           return unless in_scope?(node)
+          return read_aasm(node) if @aasm
 
-          if SIMPLE_MACROS.include?(node.name)
+          if node.name == :aasm
+            open_aasm(node) if node.block || node.arguments
+          elsif GEM_MACROS.include?(node.name)
+            record_gem_macro(node)
+          elsif node.name == :connects_to
+            # Under a condition the app may never call it, so no table is routed to its database.
+            condition = current_condition
+            @results << { macro: :connects_to, text: one_line_source(node), condition: condition,
+                          writing: (writing_database(node) unless condition),
+                          location: node.location.start_line, confidence: confidence_for(node) }.compact
+          elsif SIMPLE_MACROS.include?(node.name)
+            # Rails defaults the attribute to :password.
             @results << {
               macro:      node.name,
+              attribute:  (extract_symbol_args(node).first || :password).to_s,
+              written:    written_options(node),
               location:   node.location.start_line,
               confidence: confidence_for(node)
             }
           elsif ATTRIBUTE_MACROS.include?(node.name)
             extract_attribute_macro(node)
+          elsif STORE_MACROS.include?(node.name)
+            extract_store(node)
           elsif BROADCAST_MACROS.include?(node.name)
             extract_broadcast_macro(node)
           elsif node.name == :delegate
@@ -42,10 +129,93 @@ module RailsAiContext
             extract_delegate_missing_to(node)
           elsif node.name == :attribute
             extract_attribute_api(node)
+          elsif node.name == :alias_attribute
+            extract_alias_attribute(node)
+          elsif node.name == :has_secure_token
+            extract_secure_token(node)
+          elsif node.name == :accepts_nested_attributes_for
+            extract_nested_attributes(node)
           end
         end
 
-        private
+        # Every keyword option as the file writes it: a lambda, `2.days` or a nested hash
+        # reads the same on every Ruby, where a value's inspect does not.
+        def written_options(node)
+          keyword_hash(node) { |value| one_line_source(value) }
+        end
+
+        def record_setting(node)
+          value = node.arguments&.arguments&.first or return
+          @results << { macro: :model_setting, setting: node.name.to_s.delete_suffix("="), value: value.slice,
+                        literal: setting_literal(value), location: node.location.start_line, confidence: confidence_for(node) }
+        end
+
+        # A symbol or string names what it spells, nil is nil; anything else is not known without running it.
+        def setting_literal(value)
+          case value
+          when Prism::SymbolNode, Prism::StringNode then value.unescaped
+          when Prism::NilNode then nil
+          else RailsAiContext::Confidence::INFERRED
+          end
+        end
+
+        def record_gem_macro(node)
+          text = one_line_source(node, upto: node.block&.location&.start_offset)
+          text = text.gsub(/\s+/, " ").strip
+          adds = monetized_names(node) if node.name == :monetize
+          @results << { macro: :gem_macro, name: node.name, text: text, adds: adds.presence,
+                        location: node.location.start_line, confidence: confidence_for(node) }.compact
+        end
+
+        # money-rails names the attribute `as:`, or the column minus its `_cents` postfix.
+        def monetized_names(node)
+          as = extract_keyword_options(node)[:as]
+          return [ as.to_s ] if as.is_a?(Symbol) || as.is_a?(String)
+
+          extract_symbol_args(node).map(&:to_s).filter_map { |column| column.delete_suffix("_cents") if column.end_with?("_cents") }
+        end
+
+        # A named machine's column defaults to its name (AASM::Base#default_column).
+        def open_aasm(node)
+          name = extract_symbol_args(node).first
+          column = extract_keyword_options(node)[:column] || (name && name != :default ? name : "aasm_state")
+          entry = { macro: :aasm, column: column.to_s, initial: nil, states: [], events: [],
+                    location: node.location.start_line, confidence: confidence_for(node) }
+          @results << entry
+          @aasm = { node: node, entry: entry } if node.block.is_a?(Prism::BlockNode)
+        end
+
+        def read_aasm(node)
+          entry = @aasm[:entry]
+          case node.name
+          when :state
+            names = extract_symbol_args(node).map(&:to_s)
+            entry[:states].concat(names)
+            # The first state is the initial one until a state says `initial: true`.
+            entry[:initial] = names.first if names.any? && (entry[:initial].nil? || extract_keyword_options(node)[:initial] == true)
+          when :event
+            name = extract_symbol_args(node).first or return
+            event = { name: name.to_s, transitions: [] }
+            entry[:events] << event
+            @event = { node: node, event: event } if node.block
+          when :transitions
+            options = extract_keyword_nodes(node)
+            from = options[:from] ? literal_strings(options[:from]) : []
+            @event[:event][:transitions] << { from: from, to: options[:to] && literal_string(options[:to]) } if @event
+          end
+        end
+
+        def record_ignored_columns(node, op)
+          value = node.is_a?(Prism::CallNode) ? node.arguments&.arguments&.first : node.value
+          columns = value.is_a?(Prism::ArrayNode) && value.elements.all? { |e| literal_string(e) } ? literal_strings(value) : nil
+          @results << {
+            macro:      :ignored_columns,
+            op:         op,
+            columns:    columns,
+            location:   node.location.start_line,
+            confidence: columns ? RailsAiContext::Confidence::VERIFIED : RailsAiContext::Confidence::INFERRED
+          }
+        end
 
         def extract_attribute_macro(node)
           attrs   = extract_symbol_args(node)
@@ -56,12 +226,61 @@ module RailsAiContext
               macro:      node.name,
               attribute:  attr_name.to_s,
               options:    options,
+              written:    written_options(node),
               location:   node.location.start_line,
               confidence: confidence_for(node)
             }
           end
         end
 
+        # store :col, accessors: [...] and store_accessor :col, *keys both name
+        # the column first; the keys follow it, positionally or as accessors:.
+        def extract_store(node)
+          args = node.arguments&.arguments || []
+          column = args.first && literal_string(args.first)
+          return unless column
+
+          keys = args.drop(1).reject { |a| a.is_a?(Prism::KeywordHashNode) }.flat_map { |a| literal_strings(a) }
+          keys_node = extract_keyword_nodes(node)[:accessors]
+          keys += literal_strings(keys_node) if keys_node
+
+          @results << {
+            macro:      node.name,
+            attribute:  column,
+            keys:       keys,
+            options:    extract_keyword_options(node).slice(:prefix, :suffix),
+            location:   node.location.start_line,
+            confidence: confidence_for(node)
+          }
+        end
+
+        # Rails defaults the attribute to :token.
+        def extract_secure_token(node)
+          args = node.arguments&.arguments || []
+          first = args.first
+          return if first && !first.is_a?(Prism::KeywordHashNode) && literal_string(first).nil?
+
+          @results << {
+            macro:      :has_secure_token,
+            attribute:  first && literal_string(first) || "token",
+            location:   node.location.start_line,
+            confidence: confidence_for(node)
+          }
+        end
+
+        def extract_nested_attributes(node)
+          names = extract_symbol_args(node).map(&:to_s)
+          return if names.empty?
+
+          @results << {
+            macro:      :accepts_nested_attributes_for,
+            names:      names,
+            options:    extract_keyword_sources(node),
+            location:   node.location.start_line,
+            confidence: confidence_for(node)
+          }
+        end
+
         def extract_broadcast_macro(node)
           target = extract_symbol_args(node).first
           @results << {
@@ -97,6 +316,15 @@ module RailsAiContext
           }
         end
 
+        # The database `connects_to database: { writing: :analytics }` writes to, which names its schema dump.
+        def writing_database(node)
+          roles = extract_keyword_nodes(node)[:database]
+          return unless roles.is_a?(Prism::HashNode)
+
+          pair = roles.elements.find { |element| element.is_a?(Prism::AssocNode) && literal_string(element.key) == "writing" }
+          pair && literal_string(pair.value)
+        end
+
         def extract_attribute_api(node)
           args    = node.arguments&.arguments || []
           return if args.empty?
@@ -107,9 +335,12 @@ module RailsAiContext
           type_arg = args[1]
           type = case type_arg
           when Prism::SymbolNode then type_arg.unescaped
+          when nil, Prism::KeywordHashNode then nil
+          else one_line_source(type_arg)
           end
 
-          options = extract_keyword_options(node)
+          # Sources, so `default: "anon"` prints as the file writes it.
+          options = extract_keyword_sources(node).merge(extract_keyword_nodes(node).slice(:default).transform_values(&:slice))
 
           @results << {
             macro:      :attribute,
@@ -120,6 +351,19 @@ module RailsAiContext
             confidence: confidence_for(node)
           }
         end
+
+        def extract_alias_attribute(node)
+          new_name, old_name = extract_symbol_args(node)
+          return unless new_name && old_name
+
+          @results << {
+            macro:      :alias_attribute,
+            attribute:  new_name.to_s,
+            target:     old_name.to_s,
+            location:   node.location.start_line,
+            confidence: confidence_for(node)
+          }
+        end
       end
     end
   end

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

@@ -27,7 +27,8 @@ module RailsAiContext
             when Prism::KeywordHashNode, Prism::HashNode
               arg.elements.each do |assoc|
                 next unless assoc.is_a?(Prism::AssocNode)
-                pattern = node_source(assoc.key)
+                # `all: :catchall` is the :all address, written as a label.
+                pattern = assoc.key.is_a?(Prism::SymbolNode) ? ":#{assoc.key.unescaped}" : node_source(assoc.key)
                 action = extract_value(assoc.value)
                 @results << {
                   type:     :routing,

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

@@ -6,6 +6,8 @@ module RailsAiContext
       # Call sites by name, wherever they appear: inside a def, a lambda, a
       # callback block. The macro listener only sees class-body calls.
       class MethodCallListener < BaseListener
+        include OwnerScope
+
         def initialize(names: nil, pattern: nil)
           super()
           @names = names&.map(&:to_sym)&.to_set
@@ -20,9 +22,13 @@ module RailsAiContext
             name: name.to_s,
             receiver: node.receiver&.slice,
             line: node.location.start_line,
+            offset: node.location.start_offset,
             arguments: extract_arg_values(node),
+            computed: computed_arguments(node),
+            constants: constant_arguments(node),
             options: extract_keyword_sources(node),
-            snippet: node.slice.lines.first.to_s.strip
+            snippet: node.slice.lines.first.to_s.strip,
+            owner: @owner_stack.dup
           }
         end
       end