ruby-lsp-mongoid 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a0ab653d0a88cf1ad6cc028fee44f4e74e90528d9435a62c8ba600371e2b25b8
+  data.tar.gz: 7f913b8a4028be0151cdb591d98049bb6173835e85a925b6bc1517bc6e8c2a4e
+SHA512:
+  metadata.gz: bf1bbab9edc8c6632cdfbb31b26a58505bb885b7ff4b7b6aff6965df7d1d78cae117d8a44bf31bfd4cd248ef72fbeb5de3ab07bf49d461972a56409a1fd1d321
+  data.tar.gz: cd83a370ef45d4c2e2d343966ca69e5429ea7893150c24d9a824837300490aedc4e6f23ce33ecb3f7d7f0379d6bc1bc11f995249008a1c8bca621fe581156431

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/AGENTS.md

@@ -0,0 +1,87 @@
+# Ruby LSP Mongoid - Agent Guidelines
+
+## Project Overview
+
+This is a Ruby LSP add-on that provides index enhancements for Mongoid DSL-generated methods. Similar to ruby-lsp-rails, it helps Ruby LSP understand dynamically generated methods from Mongoid models.
+
+## TDD Development Workflow
+
+This project follows strict Test-Driven Development (TDD) practices based on Kent Beck's principles.
+
+### TDD Cycle: Red → Green → Refactor
+
+1. **Red:** Write a failing test first
+2. **Green:** Write minimal code to make the test pass
+3. **Refactor:** Clean up code while keeping tests green
+4. **Commit:** Only commit when all tests pass
+
+### Code Quality Standards
+
+- Eliminate duplication ruthlessly
+- Express intent clearly through naming
+- Keep methods small and focused
+- Use the simplest solution that works
+- Separate structural changes from behavioral changes
+
+## Important Conventions
+
+1. **Language:** **ALL code-related content MUST be written in English:**
+   - Commit messages (both title and body)
+   - Pull request titles and descriptions
+   - Code comments
+   - Variable names, function names, class names
+   - Documentation and README updates
+   - Test descriptions
+   - Error messages and log output
+   - **Exception:** You may communicate with the user in Korean for clarifications and discussions, but all artifacts (commits, PRs, code) must be in English
+
+2. **Frozen String Literals:** All Ruby files use `# frozen_string_literal: true`
+
+3. **Testing:** Uses RSpec for testing
+
+4. **Naming:**
+   - Module: `RubyLsp::Mongoid` (add-on namespace)
+   - Gem: `ruby-lsp-mongoid`
+   - Files follow Ruby conventions (snake_case)
+
+## Before Making Changes
+
+**Pre-Implementation Checklist:**
+
+1. **Read relevant files in parallel** - Use multiple Read tool calls together
+2. **Always run tests first:**
+   ```bash
+   bundle exec rspec
+   ```
+
+**Pre-Commit Checklist:**
+
+1. **Run all tests** - Ensure nothing breaks
+   ```bash
+   bundle exec rspec
+   ```
+2. **Check for untracked files** - Add relevant new files
+   ```bash
+   git status
+   ```
+3. **Make ONE atomic commit** - Group all related changes together (code + new files)
+
+## Commit Strategy
+
+### Atomic Commits
+
+**Always group related changes into single commits:**
+
+✅ **Good** - Single commit:
+```
+"Add field DSL indexing support"
+- Implement field declaration parsing
+- Register generated accessor methods
+- Add test cases
+```
+
+❌ **Bad** - Multiple commits:
+```
+"Add field DSL parsing"
+"Add tests"
+```

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-12-02
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Shia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,156 @@
+# Ruby LSP Mongoid
+
+A [Ruby LSP](https://github.com/Shopify/ruby-lsp) add-on that provides enhanced editor features for [Mongoid](https://www.mongodb.com/docs/mongoid/current/) applications.
+
+Similar to [ruby-lsp-rails](https://github.com/Shopify/ruby-lsp-rails), this add-on enhances Ruby LSP with Mongoid-specific functionality by providing index enhancements for methods generated by Mongoid DSLs.
+
+> **Note:** This project is under active development. See [TODO.md](TODO.md) for planned features.
+
+## Installation
+
+Add this gem to your application's Gemfile:
+
+```ruby
+group :development do
+  gem "ruby-lsp-mongoid"
+end
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+Ruby LSP will automatically detect and load the add-on.
+
+## Requirements
+
+- Ruby 3.3+
+- [Ruby LSP](https://github.com/Shopify/ruby-lsp)
+- [Mongoid](https://github.com/mongodb/mongoid)
+
+## How It Works
+
+Ruby LSP Mongoid implements the [Ruby LSP add-on interface](https://shopify.github.io/ruby-lsp/add-ons.html) to provide index enhancements. It statically analyzes Mongoid model files to understand which DSL methods are used and registers the generated methods with Ruby LSP's index.
+
+## Features
+
+### Go-to-Definition & Autocomplete for Mongoid DSL Methods
+
+Ruby LSP Mongoid indexes methods generated by Mongoid DSLs. Once indexed, Ruby LSP's built-in features automatically work:
+
+- **Go-to-Definition**: Jump to the DSL declaration from method calls
+- **Autocomplete**: See generated methods in completion suggestions (e.g., type `user.` to see `posts`, `profile`, etc.)
+
+#### Field Accessors
+
+```ruby
+class User
+  include Mongoid::Document
+
+  field :name, type: String
+  field :email, type: String
+  field :age, type: Integer
+end
+
+user = User.new
+user.name   # Go-to-definition works! → jumps to `field :name`
+user.name=  # Writer method also indexed
+```
+
+#### Associations
+
+```ruby
+class User
+  include Mongoid::Document
+
+  has_many :posts
+  has_one :profile
+  belongs_to :organization
+  has_and_belongs_to_many :roles
+end
+
+user.posts       # → jumps to `has_many :posts`
+user.post_ids    # has_many also generates `_ids` accessor
+user.profile     # → jumps to `has_one :profile`
+user.build_profile  # builder methods indexed
+user.create_profile
+```
+
+#### Embedded Documents
+
+```ruby
+class Post
+  include Mongoid::Document
+
+  embeds_many :comments
+  embeds_one :metadata
+end
+
+class Comment
+  include Mongoid::Document
+
+  embedded_in :post
+end
+
+post.comments  # → jumps to `embeds_many :comments`
+post.metadata  # → jumps to `embeds_one :metadata`
+comment.post   # → jumps to `embedded_in :post`
+```
+
+#### Scopes
+
+```ruby
+class Post
+  include Mongoid::Document
+
+  scope :published, -> { where(published: true) }
+  scope :recent, -> { order(created_at: :desc) }
+end
+
+Post.published  # → jumps to `scope :published`
+Post.recent     # → jumps to `scope :recent`
+```
+
+### Hover Information
+
+When hovering over Mongoid DSL declarations, you'll see additional information:
+
+#### Field Options
+
+Hovering over a field symbol shows its type, alias, and default value:
+
+```ruby
+field :active, type: Boolean, default: true
+#      ^^^^^^
+# Hover shows: "type: Boolean, default: true"
+```
+
+#### Association Target Class
+
+Hovering over an association symbol shows the target class with a clickable link:
+
+```ruby
+has_many :posts
+#        ^^^^^^
+# Hover shows: "has_many: [Post](file:///path/to/post.rb#L1)"
+```
+
+This works for all association and embedded document DSLs:
+- `has_many`, `has_one`, `belongs_to`, `has_and_belongs_to_many`
+- `embeds_many`, `embeds_one`, `embedded_in`
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/riseshia/ruby-lsp-mongoid.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/TODO.md

@@ -0,0 +1,16 @@
+# TODO
+
+## Planned Features
+
+This add-on will provide Ruby LSP with information about methods dynamically generated by Mongoid DSLs, enabling:
+
+- [ ] **Go to Definition** - Navigate to the source of dynamically generated methods
+- [ ] **Hover** - Documentation for generated methods
+
+## Supported Mongoid DSLs
+
+The add-on will recognize methods generated by the following Mongoid DSLs:
+
+### Others
+- [ ] Callbacks - Lifecycle callback methods
+- [ ] Validations - Validation-related methods

data/lib/ruby_lsp/ruby_lsp_mongoid/addon.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../../ruby_lsp_mongoid/version"
+require_relative "indexing_enhancement"
+require_relative "hover"
+
+module RubyLsp
+  module Mongoid
+    class Addon < ::RubyLsp::Addon
+      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}")
+      end
+
+      def deactivate; end
+
+      def name
+        "Ruby LSP Mongoid"
+      end
+
+      def version
+        VERSION
+      end
+
+      def create_hover_listener(response_builder, node_context, dispatcher)
+        return unless @global_state
+
+        Hover.new(response_builder, node_context, @global_state.index, dispatcher)
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_mongoid/hover.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Mongoid
+    class Hover
+      include RubyLsp::Requests::Support::Common
+
+      FIELD_DSL = :field
+      ASSOCIATION_DSLS = %i[
+        embeds_many embeds_one embedded_in
+        has_many has_one belongs_to has_and_belongs_to_many
+      ].freeze
+
+      def initialize(response_builder, node_context, index, dispatcher)
+        @response_builder = response_builder
+        @node_context = node_context
+        @index = index
+
+        dispatcher.register(self, :on_symbol_node_enter)
+      end
+
+      def on_symbol_node_enter(node)
+        call_node = @node_context.call_node
+        return unless call_node.is_a?(Prism::CallNode)
+
+        if call_node.name == FIELD_DSL
+          handle_field(call_node)
+        elsif ASSOCIATION_DSLS.include?(call_node.name)
+          handle_association(call_node)
+        end
+      end
+
+      private
+
+      def handle_field(node)
+        owner = @node_context.nesting.last
+        return unless owner
+
+        name = extract_name(node)
+        return unless name
+
+        entries = @index.resolve_method(name.to_s, owner)
+        return unless entries&.any?
+
+        entry = entries.first
+        comments = entry.comments
+        return if comments.nil? || comments.empty?
+
+        @response_builder.push(comments, category: :documentation)
+      end
+
+      def handle_association(node)
+        association_type = node.name
+        association_name = extract_name(node)
+        return unless association_name
+
+        class_name = extract_class_name_option(node) || classify(association_name)
+        generate_association_hover(class_name, association_type)
+      end
+
+      def extract_name(call_node)
+        arguments = call_node.arguments&.arguments
+        return unless arguments
+
+        name_arg = arguments.first
+
+        case name_arg
+        when Prism::SymbolNode
+          name_arg.value
+        when Prism::StringNode
+          name_arg.content
+        end
+      end
+
+      def extract_class_name_option(call_node)
+        arguments = call_node.arguments&.arguments
+        return unless arguments
+
+        keyword_hash = arguments.find { |arg| arg.is_a?(Prism::KeywordHashNode) }
+        return unless keyword_hash
+
+        element = keyword_hash.elements.find do |el|
+          el.is_a?(Prism::AssocNode) &&
+            el.key.is_a?(Prism::SymbolNode) &&
+            el.key.value == "class_name"
+        end
+
+        return unless element
+
+        case element.value
+        when Prism::SymbolNode
+          element.value.value
+        when Prism::StringNode
+          element.value.content
+        when Prism::ConstantReadNode
+          element.value.name.to_s
+        when Prism::ConstantPathNode
+          element.value.full_name
+        end
+      end
+
+      def classify(name)
+        singular = singularize(name)
+        singular.to_s.split("_").map(&:capitalize).join
+      end
+
+      def singularize(name)
+        name_str = name.to_s
+        if name_str.end_with?("ies")
+          name_str[0..-4] + "y"
+        elsif name_str.end_with?("s")
+          name_str[0..-2]
+        else
+          name_str
+        end
+      end
+
+      def generate_association_hover(class_name, association_type)
+        entries = @index[class_name]
+
+        if entries&.any?
+          entry = entries.first
+          line = entry.location.start_line
+          content = "#{association_type}: [#{class_name}](#{entry.uri}#L#{line})"
+        else
+          content = "#{association_type}: #{class_name}"
+        end
+
+        @response_builder.push(content, category: :documentation)
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_mongoid/indexing_enhancement.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Mongoid
+    class IndexingEnhancement < RubyIndexer::Enhancement
+      def on_call_node_enter(call_node)
+        owner = @listener.current_owner
+        return unless owner
+
+        case call_node.name
+        when :field
+          handle_field(call_node)
+        when :embeds_many, :embedded_in
+          handle_accessor_dsl(call_node)
+        when :has_many, :has_and_belongs_to_many
+          handle_many_association(call_node)
+        when :has_one, :belongs_to, :embeds_one
+          handle_singular_association(call_node)
+        when :scope
+          handle_scope(call_node)
+        end
+      end
+
+      def on_call_node_leave(call_node); end
+
+      private
+
+      def handle_field(call_node)
+        name = extract_name(call_node)
+        return unless name
+
+        loc = call_node.location
+        comment = build_field_options_comment(call_node)
+
+        add_accessor_methods(name, loc, comments: comment)
+
+        # Handle as: option for field alias
+        alias_name = extract_option_value(call_node, "as")
+        add_accessor_methods(alias_name, loc, comments: comment) if alias_name
+      end
+
+      def handle_accessor_dsl(call_node)
+        name = extract_name(call_node)
+        return unless name
+
+        add_accessor_methods(name, call_node.location)
+      end
+
+      def handle_many_association(call_node)
+        name = extract_name(call_node)
+        return unless name
+
+        loc = call_node.location
+
+        add_accessor_methods(name, loc)
+
+        singular_name = singularize(name)
+        add_accessor_methods("#{singular_name}_ids", loc)
+      end
+
+      def handle_singular_association(call_node)
+        name = extract_name(call_node)
+        return unless name
+
+        loc = call_node.location
+
+        add_accessor_methods(name, loc)
+        add_builder_methods(name, loc)
+      end
+
+      def handle_scope(call_node)
+        name = extract_name(call_node)
+        return unless name
+
+        owner = @listener.current_owner
+        return unless owner
+
+        add_singleton_method(name.to_s, call_node.location, owner)
+      end
+
+      def extract_name(call_node)
+        arguments = call_node.arguments&.arguments
+        return unless arguments
+
+        name_arg = arguments.first
+
+        case name_arg
+        when Prism::SymbolNode
+          name_arg.value
+        when Prism::StringNode
+          name_arg.content
+        end
+      end
+
+      def extract_option_value(call_node, key)
+        arguments = call_node.arguments&.arguments
+        return unless arguments
+
+        keyword_hash = arguments.find { |arg| arg.is_a?(Prism::KeywordHashNode) }
+        return unless keyword_hash
+
+        element = keyword_hash.elements.find do |el|
+          el.is_a?(Prism::AssocNode) &&
+            el.key.is_a?(Prism::SymbolNode) &&
+            el.key.value == key
+        end
+
+        return unless element
+
+        case element.value
+        when Prism::SymbolNode
+          element.value.value
+        when Prism::StringNode
+          element.value.content
+        when Prism::ConstantReadNode
+          element.value.name.to_s
+        when Prism::ConstantPathNode
+          element.value.full_name
+        end
+      end
+
+      def extract_option_source(call_node, key)
+        arguments = call_node.arguments&.arguments
+        return unless arguments
+
+        keyword_hash = arguments.find { |arg| arg.is_a?(Prism::KeywordHashNode) }
+        return unless keyword_hash
+
+        element = keyword_hash.elements.find do |el|
+          el.is_a?(Prism::AssocNode) &&
+            el.key.is_a?(Prism::SymbolNode) &&
+            el.key.value == key
+        end
+
+        element&.value&.slice
+      end
+
+      def build_field_options_comment(call_node)
+        options = []
+
+        type_value = extract_option_value(call_node, "type")
+        options << "type: #{type_value}" if type_value
+
+        as_value = extract_option_value(call_node, "as")
+        options << "as: #{as_value}" if as_value
+
+        default_source = extract_option_source(call_node, "default")
+        options << "default: #{default_source}" if default_source
+
+        options.any? ? options.join(", ") : nil
+      end
+
+      def add_accessor_methods(name, location, comments: nil)
+        reader_signatures = [RubyIndexer::Entry::Signature.new([])]
+        @listener.add_method(name.to_s, location, reader_signatures, comments: comments)
+
+        writer_signatures = [
+          RubyIndexer::Entry::Signature.new([RubyIndexer::Entry::RequiredParameter.new(name: :value)]),
+        ]
+        @listener.add_method("#{name}=", location, writer_signatures, comments: comments)
+      end
+
+      def add_builder_methods(name, location)
+        builder_signatures = [RubyIndexer::Entry::Signature.new([])]
+        @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)
+        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,
+          uri,
+          location,
+          location,
+          "",
+          signatures,
+          :public,
+          singleton,
+        ))
+      end
+
+      def singularize(name)
+        name_str = name.to_s
+        if name_str.end_with?("ies")
+          name_str[0..-4] + "y"
+        elsif name_str.end_with?("s")
+          name_str[0..-2]
+        else
+          name_str
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_mongoid.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "ruby_lsp/addon"
+require "ruby_lsp/internal"
+
+require_relative "../ruby_lsp_mongoid/version"
+require_relative "ruby_lsp_mongoid/addon"

data/lib/ruby_lsp_mongoid/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Mongoid
+    VERSION = "0.1.0"
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: ruby-lsp-mongoid
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shia
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-lsp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+description: A Ruby LSP Addon for Mongoid.
+email:
+- rise.shia@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- AGENTS.md
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- TODO.md
+- lib/ruby_lsp/ruby_lsp_mongoid.rb
+- 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_mongoid/version.rb
+homepage: https://github.com/riseshia/ruby-lsp-mongoid
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/riseshia/ruby-lsp-mongoid
+  source_code_uri: https://github.com/riseshia/ruby-lsp-mongoid
+  changelog_uri: https://github.com/riseshia/ruby-lsp-mongoid/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A Ruby LSP Addon for Mongoid
+test_files: []