ruby-lsp-mongoid 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25deaba20b973e9a4ceae841a71e0ae0d46b7ba6272fc5c48a9a56900d5240f3
-  data.tar.gz: 1075b753283b79bdf2cb9a0e36fdc16659d7b79e7f419b7a039531b8d1b92ecf
+  metadata.gz: 459274f7c2be280ff2e284869fcd8dc7e424dcce61799d881a27f7bc250edf75
+  data.tar.gz: 07ee1f8583968c5b01bc395df23e3b598967e9ae389b10100d4681eb5c592f9d
 SHA512:
-  metadata.gz: 7717dc958cb9f9c06fe1e097b8d8771ec0e52cfcf68ab502165ddc21e24dca5cf56cb07fff2c5d5790345fe56f08b479a843b2001b0ac21b7c89a9f0ef920e48
-  data.tar.gz: da98dc048563431553f88902e5068ce03757dc9056f43c47388651f978a98909e1fbf5664f367c9e3d2fe81c8fbe5a024ea710e9606b95ca7804c57e49af1610
+  metadata.gz: c946f9ee440c08d5620f074272c1f34376624b4cfb7251bf26d4e7342a76792bd625d86b78eda2015da57eccdaf4b38be838e97e82a39ead6e8d73c8fe890750
+  data.tar.gz: 2343c3b4a06ecd64abf51015cac50ce6f45380148a796777860474e025e446526892a2f2a486235a0f5e38906258b9c2b6b07044d12500b38468ad2cfc8adcde

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 ## [Unreleased]
 
+## [0.1.2] - 2025-12-15
+
+### Added
+
+- Auto-index core instance methods when including `Mongoid::Document` or `ApplicationDocument`:
+  - ID accessors: `_id`, `_id=`, `id`, `id=` (always present in Mongoid documents)
+  - Persistence methods: `save`, `save!`, `update`, `update!`, `destroy`, `delete`, `upsert`, `reload`
+  - State methods: `new_record?`, `persisted?`, `valid?`, `changed?`
+  - Attribute methods: `attributes`, `attributes=`, `assign_attributes`, `read_attribute`, `write_attribute`, `changes`, `errors`
+  - Identity methods: `to_key`, `to_param`, `model_name`, `inspect`
+- Auto-index core class methods when including `Mongoid::Document` or `ApplicationDocument`:
+  - Query methods: `all`, `where`, `find`, `find_by`, `find_by!`, `first`, `last`, `count`, `exists?`, `distinct`
+  - Creation methods: `create`, `create!`, `new`, `build`
+  - Modification methods: `update_all`, `delete_all`, `destroy_all`
+  - Database methods: `collection`, `database`
+- Support for `ApplicationDocument` pattern (common Rails pattern where `ApplicationDocument` includes `Mongoid::Document`)
+
+### Changed
+
+- ID accessors (`_id`, `id`) are now indexed when including `Mongoid::Document`/`ApplicationDocument` instead of at the first DSL call
+- Simplified internal implementation by removing `ensure_id_field_indexed` mechanism
+
+## [0.1.1] - 2025-12-08
+
 ### Added
 
 - Auto-index `_id` and `id` accessor methods for all Mongoid models that use any DSL (field, associations, scope)

data/lib/ruby_lsp/ruby_lsp_mongoid/addon.rb

@@ -1,19 +1,27 @@
 # frozen_string_literal: true
 
 require_relative "../../ruby_lsp_mongoid/version"
+require_relative "signature_resolver"
 require_relative "indexing_enhancement"
 require_relative "hover"
 
 module RubyLsp
   module Mongoid
     class Addon < ::RubyLsp::Addon
+      include SignatureResolver
+
       def activate(global_state, outgoing_queue)
         @global_state = global_state
         @outgoing_queue = outgoing_queue
         @outgoing_queue << Notification.window_log_message("Activating Ruby LSP Mongoid add-on v#{VERSION}")
+
+        # Start background thread to update signatures after indexing completes
+        @signature_update_thread = Thread.new { wait_for_indexing_and_update_signatures }
       end
 
-      def deactivate; end
+      def deactivate
+        @signature_update_thread&.kill
+      end
 
       def name
         "Ruby LSP Mongoid"
@@ -28,6 +36,91 @@ module RubyLsp
 
         Hover.new(response_builder, node_context, @global_state.index, dispatcher)
       end
+
+      private
+
+      def wait_for_indexing_and_update_signatures
+        return unless @global_state
+
+        index = @global_state.index
+
+        # Wait for initial indexing to complete
+        sleep(0.1) until index.instance_variable_get(:@initial_indexing_completed)
+
+        update_mongoid_signatures(index)
+      rescue StandardError => e
+        @outgoing_queue << Notification.window_log_message(
+          "Ruby LSP Mongoid: Error updating signatures: #{e.message}",
+        )
+      end
+
+      def update_mongoid_signatures(index)
+        updated_count = 0
+
+        # Update instance method signatures
+        CORE_INSTANCE_METHODS.each do |method_name|
+          mongoid_signatures = resolve_instance_method_signature(index, method_name)
+          next unless mongoid_signatures
+
+          updated_count += update_method_signatures_for_mongoid_models(index, method_name, mongoid_signatures)
+        end
+
+        # Update class method signatures
+        CORE_CLASS_METHODS.each do |method_name|
+          mongoid_signatures = resolve_class_method_signature(index, method_name)
+          next unless mongoid_signatures
+
+          updated_count += update_singleton_method_signatures_for_mongoid_models(
+            index,
+            method_name,
+            mongoid_signatures,
+          )
+        end
+
+        if updated_count > 0
+          @outgoing_queue << Notification.window_log_message(
+            "Ruby LSP Mongoid: Updated #{updated_count} method signatures from Mongoid modules",
+          )
+        end
+      end
+
+      def update_method_signatures_for_mongoid_models(index, method_name, new_signatures)
+        updated = 0
+
+        # Find all classes that have this method registered by our addon
+        # We look for methods that were registered with empty signatures
+        index.instance_variable_get(:@entries).each do |_name, entries|
+          entries.each do |entry|
+            next unless entry.is_a?(RubyIndexer::Entry::Method)
+            next unless entry.name == method_name
+            next unless entry.signatures.empty? || entry.signatures.first.parameters.empty?
+
+            # Update the signatures
+            entry.instance_variable_set(:@signatures, new_signatures)
+            updated += 1
+          end
+        end
+
+        updated
+      end
+
+      def update_singleton_method_signatures_for_mongoid_models(index, method_name, new_signatures)
+        updated = 0
+
+        index.instance_variable_get(:@entries).each do |_name, entries|
+          entries.each do |entry|
+            next unless entry.is_a?(RubyIndexer::Entry::Method)
+            next unless entry.name == method_name
+            next unless entry.owner.is_a?(RubyIndexer::Entry::SingletonClass)
+            next unless entry.signatures.empty? || entry.signatures.first.parameters.empty?
+
+            entry.instance_variable_set(:@signatures, new_signatures)
+            updated += 1
+          end
+        end
+
+        updated
+      end
     end
   end
 end

data/lib/ruby_lsp/ruby_lsp_mongoid/hover.rb

@@ -43,10 +43,21 @@ module RubyLsp
         return unless entries&.any?
 
         entry = entries.first
+
+        # Build hover content with signature and options
+        content_parts = []
+
+        # Add method signature
+        signature = format_signature(name.to_s, entry)
+        content_parts << signature if signature
+
+        # Add field options from comments
         comments = entry.comments
-        return if comments.nil? || comments.empty?
+        content_parts << comments if comments && !comments.empty?
 
-        @response_builder.push(comments, category: :documentation)
+        return if content_parts.empty?
+
+        @response_builder.push(content_parts.join("\n\n"), category: :documentation)
       end
 
       def handle_association(node)
@@ -128,6 +139,37 @@ module RubyLsp
 
         @response_builder.push(content, category: :documentation)
       end
+
+      def format_signature(method_name, entry)
+        return nil unless entry.respond_to?(:signatures) && entry.signatures.any?
+
+        sig = entry.signatures.first
+        return nil if sig.parameters.empty?
+
+        params = sig.parameters.map { |param| format_parameter(param) }.join(", ")
+        "```ruby\ndef #{method_name}(#{params})\n```"
+      end
+
+      def format_parameter(param)
+        case param
+        when RubyIndexer::Entry::RequiredParameter
+          param.name.to_s
+        when RubyIndexer::Entry::OptionalParameter
+          "#{param.name} = nil"
+        when RubyIndexer::Entry::KeywordParameter
+          "#{param.name}:"
+        when RubyIndexer::Entry::OptionalKeywordParameter
+          "#{param.name}: nil"
+        when RubyIndexer::Entry::RestParameter
+          "*#{param.name}"
+        when RubyIndexer::Entry::KeywordRestParameter
+          "**#{param.name}"
+        when RubyIndexer::Entry::BlockParameter
+          "&#{param.name}"
+        else
+          param.name.to_s
+        end
+      end
     end
   end
 end

data/lib/ruby_lsp/ruby_lsp_mongoid/indexing_enhancement.rb

@@ -5,7 +5,6 @@ module RubyLsp
     class IndexingEnhancement < RubyIndexer::Enhancement
       def initialize(listener)
         super
-        @id_indexed_owners = Set.new
       end
 
       def on_call_node_enter(call_node)
@@ -13,6 +12,8 @@ module RubyLsp
         return unless owner
 
         case call_node.name
+        when :include
+          handle_include(call_node)
         when :field
           handle_field(call_node)
         when :embeds_many, :embedded_in
@@ -30,6 +31,58 @@ module RubyLsp
 
       private
 
+      # Core instance methods automatically added by Mongoid::Document
+      CORE_INSTANCE_METHODS = %w[
+        save save! update update! destroy delete upsert reload
+        new_record? persisted? valid? changed?
+        attributes attributes= assign_attributes read_attribute write_attribute changes errors
+        to_key to_param model_name inspect
+      ].freeze
+
+      # Class methods automatically added by Mongoid::Document
+      CORE_CLASS_METHODS = %w[
+        all where find find_by find_by! first last count exists? distinct
+        create create! new build
+        update_all delete_all destroy_all
+        collection database
+      ].freeze
+
+      def handle_include(call_node)
+        arguments = call_node.arguments&.arguments
+        return unless arguments
+
+        # Check if including Mongoid::Document or ApplicationDocument
+        first_arg = arguments.first
+        module_name = case first_arg
+                      when Prism::ConstantReadNode
+                        first_arg.name.to_s
+                      when Prism::ConstantPathNode
+                        first_arg.full_name
+                      end
+
+        # Support both Mongoid::Document and ApplicationDocument (common Rails pattern)
+        return unless module_name == "Mongoid::Document" || module_name == "ApplicationDocument"
+
+        owner = @listener.current_owner
+        return unless owner
+
+        loc = call_node.location
+
+        # Add _id and id accessor methods (always present in Mongoid documents)
+        add_accessor_methods("_id", loc)
+        add_accessor_methods("id", loc)
+
+        # Add core instance methods
+        CORE_INSTANCE_METHODS.each do |method_name|
+          add_core_method(method_name, loc)
+        end
+
+        # Add core class methods
+        CORE_CLASS_METHODS.each do |method_name|
+          add_singleton_method(method_name, loc, owner)
+        end
+      end
+
       def handle_field(call_node)
         name = extract_name(call_node)
         return unless name
@@ -37,8 +90,6 @@ module RubyLsp
         loc = call_node.location
         comment = build_field_options_comment(call_node)
 
-        ensure_id_field_indexed(loc)
-
         add_accessor_methods(name, loc, comments: comment)
 
         # Handle as: option for field alias
@@ -51,7 +102,6 @@ module RubyLsp
         return unless name
 
         loc = call_node.location
-        ensure_id_field_indexed(loc)
 
         add_accessor_methods(name, loc)
       end
@@ -61,7 +111,6 @@ module RubyLsp
         return unless name
 
         loc = call_node.location
-        ensure_id_field_indexed(loc)
 
         add_accessor_methods(name, loc)
 
@@ -74,7 +123,6 @@ module RubyLsp
         return unless name
 
         loc = call_node.location
-        ensure_id_field_indexed(loc)
 
         add_accessor_methods(name, loc)
         add_builder_methods(name, loc)
@@ -88,9 +136,17 @@ module RubyLsp
         return unless owner
 
         loc = call_node.location
-        ensure_id_field_indexed(loc)
 
-        add_singleton_method(name.to_s, loc, owner)
+        # Extract lambda parameters if present
+        lambda_node = extract_lambda_node(call_node)
+        signatures = if lambda_node
+          params = extract_lambda_parameters(lambda_node)
+          [RubyIndexer::Entry::Signature.new(params)]
+        else
+          [RubyIndexer::Entry::Signature.new([])]
+        end
+
+        add_singleton_method_with_signatures(name.to_s, loc, owner, signatures)
       end
 
       def extract_name(call_node)
@@ -175,21 +231,34 @@ module RubyLsp
         @listener.add_method("#{name}=", location, writer_signatures, comments: comments)
       end
 
+      def add_core_method(name, location)
+        signatures = [RubyIndexer::Entry::Signature.new([])]
+        @listener.add_method(name.to_s, location, signatures)
+      end
+
       def add_builder_methods(name, location)
-        builder_signatures = [RubyIndexer::Entry::Signature.new([])]
+        builder_signatures = [
+          RubyIndexer::Entry::Signature.new([
+            RubyIndexer::Entry::OptionalParameter.new(name: :attributes),
+          ]),
+        ]
         @listener.add_method("build_#{name}", location, builder_signatures)
         @listener.add_method("create_#{name}", location, builder_signatures)
         @listener.add_method("create_#{name}!", location, builder_signatures)
       end
 
       def add_singleton_method(name, node_location, owner)
+        signatures = [RubyIndexer::Entry::Signature.new([])]
+        add_singleton_method_with_signatures(name, node_location, owner, signatures)
+      end
+
+      def add_singleton_method_with_signatures(name, node_location, owner, signatures)
         index = @listener.instance_variable_get(:@index)
         code_units_cache = @listener.instance_variable_get(:@code_units_cache)
         uri = @listener.instance_variable_get(:@uri)
 
         location = RubyIndexer::Location.from_prism_location(node_location, code_units_cache)
         singleton = index.existing_or_new_singleton_class(owner.name)
-        signatures = [RubyIndexer::Entry::Signature.new([])]
 
         index.add(RubyIndexer::Entry::Method.new(
           name,
@@ -203,6 +272,69 @@ module RubyLsp
         ))
       end
 
+      def extract_lambda_node(call_node)
+        arguments = call_node.arguments&.arguments
+        return unless arguments
+
+        arguments.find { |arg| arg.is_a?(Prism::LambdaNode) }
+      end
+
+      def extract_lambda_parameters(lambda_node)
+        return [] unless lambda_node.is_a?(Prism::LambdaNode)
+
+        params_node = lambda_node.parameters
+        return [] unless params_node
+
+        # Lambda parameters can be either BlockParametersNode or NumberedParametersNode
+        case params_node
+        when Prism::BlockParametersNode
+          extract_parameters_from_block_params(params_node)
+        else
+          []
+        end
+      end
+
+      def extract_parameters_from_block_params(block_params_node)
+        params = []
+
+        # BlockParametersNode has a `parameters` method that returns ParametersNode
+        inner_params = block_params_node.parameters
+        return params unless inner_params
+
+        # Required parameters
+        inner_params.requireds&.each do |param|
+          next unless param.respond_to?(:name)
+
+          params << RubyIndexer::Entry::RequiredParameter.new(name: param.name)
+        end
+
+        # Optional parameters
+        inner_params.optionals&.each do |param|
+          next unless param.respond_to?(:name)
+
+          params << RubyIndexer::Entry::OptionalParameter.new(name: param.name)
+        end
+
+        # Rest parameter
+        if inner_params.rest && inner_params.rest.respond_to?(:name)
+          name = inner_params.rest.name || :args
+          params << RubyIndexer::Entry::RestParameter.new(name: name)
+        end
+
+        # Keyword parameters
+        inner_params.keywords&.each do |param|
+          next unless param.respond_to?(:name)
+
+          if param.respond_to?(:value) && param.value
+            params << RubyIndexer::Entry::OptionalKeywordParameter.new(name: param.name)
+          else
+            params << RubyIndexer::Entry::KeywordParameter.new(name: param.name)
+          end
+        end
+
+        params
+      end
+
       def singularize(name)
         name_str = name.to_s
         if name_str.end_with?("ies")
@@ -213,18 +345,6 @@ module RubyLsp
           name_str
         end
       end
-
-      def ensure_id_field_indexed(location)
-        owner = @listener.current_owner
-        return unless owner
-        return if @id_indexed_owners.include?(owner.name)
-
-        @id_indexed_owners.add(owner.name)
-
-        # Add _id and id (alias) accessor methods
-        add_accessor_methods("_id", location)
-        add_accessor_methods("id", location)
-      end
     end
   end
 end

data/lib/ruby_lsp/ruby_lsp_mongoid/signature_resolver.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Mongoid
+    # Resolves method signatures from Mongoid modules in the Ruby LSP index.
+    # Used to update method signatures after initial indexing is complete.
+    module SignatureResolver
+      # Mongoid modules that provide instance methods
+      INSTANCE_METHOD_SOURCES = [
+        "Mongoid::Persistable::Savable",
+        "Mongoid::Persistable::Updatable",
+        "Mongoid::Persistable::Deletable",
+        "Mongoid::Persistable::Destroyable",
+        "Mongoid::Persistable::Upsertable",
+        "Mongoid::Attributes",
+        "Mongoid::Reloadable",
+        "Mongoid::Stateful",
+        "Mongoid::Changeable",
+        "Mongoid::Inspectable",
+      ].freeze
+
+      # Mongoid modules that provide class methods
+      CLASS_METHOD_SOURCES = [
+        "Mongoid::Findable",
+        "Mongoid::Criteria",
+        "Mongoid::Persistable::Creatable::ClassMethods",
+        "Mongoid::Clients::Sessions::ClassMethods",
+      ].freeze
+
+      # Core instance methods to look up signatures for
+      CORE_INSTANCE_METHODS = %w[
+        save save! update update! destroy delete upsert reload
+        new_record? persisted? valid? changed?
+        attributes attributes= assign_attributes read_attribute write_attribute
+        changes errors to_key to_param model_name inspect
+      ].freeze
+
+      # Core class methods to look up signatures for
+      CORE_CLASS_METHODS = %w[
+        all where find find_by find_by! first last count exists? distinct
+        create create! new build update_all delete_all destroy_all
+        collection database
+      ].freeze
+
+      # Resolve instance method signature from Mongoid modules
+      # @param index [RubyIndexer::Index] Ruby LSP index
+      # @param method_name [String] Method name to look up
+      # @return [Array<RubyIndexer::Entry::Signature>, nil] Signatures or nil if not found
+      def resolve_instance_method_signature(index, method_name)
+        INSTANCE_METHOD_SOURCES.each do |module_name|
+          entries = index.resolve_method(method_name, module_name)
+          next unless entries&.any?
+
+          entry = entries.first
+          return entry.signatures if entry.respond_to?(:signatures) && entry.signatures.any?
+        end
+
+        nil
+      end
+
+      # Resolve class method signature from Mongoid modules
+      # @param index [RubyIndexer::Index] Ruby LSP index
+      # @param method_name [String] Method name to look up
+      # @return [Array<RubyIndexer::Entry::Signature>, nil] Signatures or nil if not found
+      def resolve_class_method_signature(index, method_name)
+        CLASS_METHOD_SOURCES.each do |module_name|
+          entries = index.resolve_method(method_name, module_name)
+          next unless entries&.any?
+
+          entry = entries.first
+          return entry.signatures if entry.respond_to?(:signatures) && entry.signatures.any?
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_mongoid.rb

@@ -4,4 +4,5 @@ require "ruby_lsp/addon"
 require "ruby_lsp/internal"
 
 require_relative "../ruby_lsp_mongoid/version"
+require_relative "ruby_lsp_mongoid/signature_resolver"
 require_relative "ruby_lsp_mongoid/addon"

data/lib/ruby_lsp_mongoid/version.rb

@@ -2,6 +2,6 @@
 
 module RubyLsp
   module Mongoid
-    VERSION = "0.1.1"
+    VERSION = "0.1.2"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-mongoid
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Shia
@@ -41,6 +41,7 @@ files:
 - lib/ruby_lsp/ruby_lsp_mongoid/addon.rb
 - lib/ruby_lsp/ruby_lsp_mongoid/hover.rb
 - lib/ruby_lsp/ruby_lsp_mongoid/indexing_enhancement.rb
+- lib/ruby_lsp/ruby_lsp_mongoid/signature_resolver.rb
 - lib/ruby_lsp_mongoid/version.rb
 homepage: https://github.com/riseshia/ruby-lsp-mongoid
 licenses: