ruby-lsp-ree 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1104f2c78afb874d9277a4e2d1c8b5adaf925bdb4fb9abb23b08a9e5a27aff9
-  data.tar.gz: 061f2b31a9aac045d279797b7561597db1825e396547b5afd94d6bfc4015af1e
+  metadata.gz: 8eb134e8d6b0ac3bf5321789ed6617ea1347ee096b1e642f953885b398524030
+  data.tar.gz: 460f2cc171155affbafe236535604b116d0af15bbcf14c3925470a8ff3616211
 SHA512:
-  metadata.gz: 7f29b69bb720eadc44261c63719ca950cec24db996d0d4d83117c20c3a145bb6be8934420acb850ba92841feefe4985f0e0c1caa7129cd50a41a4419f3a2ca1e
-  data.tar.gz: fea1f33dd0bcdfe401afe15304797fca57c254cf8472b34a8ef40d7f011d2bb60edb1010177129671fcbfc0f7ca69b212832c2c70ef8b8f125025a20be0ca17a
+  metadata.gz: cf49632399253b97f3b3df77ae7767008141900552461de8bca6b7395ac0d48fa4dbc5a353d2245f50147d7d119059b3f4d5a3f55aa41ae4fd11521d58b7930d
+  data.tar.gz: 0f392c77bbe2bdee9e9f613bc856c1d93b9bb9a2c87a93078017388fb253b27325d244ba289b36c24ff7e71e9f72b4f9c11abb663a7a2f675b5a9661aae29554

data/.ruby-version

@@ -0,0 +1 @@
+3.3.0

data/CHANGELOG.md

@@ -1,8 +1,20 @@
-## [Unreleased]
+## [0.1.3] - 2025-02-21
 
-## [0.1.0] - 2025-01-31
+- improved Go To Definition for ree object methods and imported constants
+- support for :mapper objects
+- support for :aggregate objects
+- improved autocompletion for imported constants
+- basic hover information for ree objects
 
-- Initial release
+## [0.1.2] - 2025-02-14
+
+- support for :bean objects
+- Go To Definition for imported constants
+- use current (not saved) version of the document in autocomplete
+- use current (not saved) version of the document in definition
+- increase autocomplete list limits (affects short functions)
+- improved const autocomplete
+- improved ree errors handling
 
 ## [0.1.1] - 2025-02-10
 
@@ -21,12 +33,8 @@
 - autocomplete for ree dao
 - autocomplete for dao filters
 
-## [0.1.2] - 2025-02-14
+## [0.1.0] - 2025-01-31
 
-- support for :bean objects
-- Go To Definition for imported constants
-- use current (no saved) version of the document in autocomplete
-- use current (no saved) version of the document in definition
-- increase autocomplete list limits (affects short functions)
-- improved const autocomplete
-- improved ree errors handling
+- Initial release
+
+## [Unreleased]

data/Gemfile

@@ -6,3 +6,9 @@ source "https://rubygems.org"
 gemspec
 
 gem "rake", "~> 13.0"
+
+group :test do
+  gem 'rspec'
+  gem 'ruby-lsp'
+  gem "sorbet-static-and-runtime"
+end

data/Gemfile.lock

@@ -1,12 +1,44 @@
 PATH
   remote: .
   specs:
-    ruby-lsp-ree (0.1.2)
+    ruby-lsp-ree (0.1.3)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    diff-lcs (1.6.0)
+    language_server-protocol (3.17.0.4)
+    logger (1.6.6)
+    prism (1.3.0)
     rake (13.2.1)
+    rbs (3.8.1)
+      logger
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.3)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.2)
+    ruby-lsp (0.23.11)
+      language_server-protocol (~> 3.17.0)
+      prism (>= 1.2, < 2.0)
+      rbs (>= 3, < 4)
+      sorbet-runtime (>= 0.5.10782)
+    sorbet (0.5.11835)
+      sorbet-static (= 0.5.11835)
+    sorbet-runtime (0.5.11835)
+    sorbet-static (0.5.11835-universal-darwin)
+    sorbet-static (0.5.11835-x86_64-linux)
+    sorbet-static-and-runtime (0.5.11835)
+      sorbet (= 0.5.11835)
+      sorbet-runtime (= 0.5.11835)
 
 PLATFORMS
   x86_64-darwin-23
@@ -14,7 +46,10 @@ PLATFORMS
 
 DEPENDENCIES
   rake (~> 13.0)
+  rspec
+  ruby-lsp
   ruby-lsp-ree!
+  sorbet-static-and-runtime
 
 BUNDLED WITH
    2.6.3

data/Rakefile

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

data/lib/ruby_lsp/ruby_lsp_ree/addon.rb

@@ -1,8 +1,9 @@
 require "ruby_lsp/addon"
-require_relative "definition"
-require_relative "completion"
+require_relative "listeners/definition_listener"
+require_relative "listeners/completion_listener"
+require_relative "listeners/hover_listener"
 require_relative "ree_indexing_enhancement"
-require_relative "ree_lsp_utils"
+require_relative "utils/ree_lsp_utils"
 require_relative "ree_formatter"
 require_relative "parsing/parsed_document_builder"
 
@@ -25,12 +26,17 @@ module RubyLsp
 
       def create_definition_listener(response_builder, uri, node_context, dispatcher)
         index = @global_state.index
-        RubyLsp::Ree::Definition.new(response_builder, node_context, index, dispatcher, uri)
+        RubyLsp::Ree::DefinitionListener.new(response_builder, node_context, index, dispatcher, uri)
       end
 
       def create_completion_listener(response_builder, node_context, dispatcher, uri)
         index = @global_state.index
-        RubyLsp::Ree::Completion.new(response_builder, node_context, index, dispatcher, uri)
+        RubyLsp::Ree::CompletionListener.new(response_builder, node_context, index, dispatcher, uri)
+      end
+
+      def create_hover_listener(response_builder, node_context, dispatcher)
+        index = @global_state.index
+        RubyLsp::Ree::HoverListener.new(response_builder, node_context, index, dispatcher)
       end
     end
   end

data/lib/ruby_lsp/ruby_lsp_ree/{completion_utils.rb → handlers/completion_handler.rb}

@@ -1,11 +1,43 @@
-require_relative "ree_lsp_utils"
+require_relative "../utils/ree_lsp_utils"
+require_relative "../ree_object_finder"
 
 module RubyLsp
   module Ree
-    module CompletionUtils
+    class CompletionHandler
       include Requests::Support::Common
       include RubyLsp::Ree::ReeLspUtils
 
+      RECEIVER_OBJECT_TYPES = [:enum, :dao, :bean]
+      CANDIDATES_LIMIT = 100
+
+      def initialize(index, uri, node_context)
+        @index = index
+        @uri = uri
+        @node_context = node_context
+        @finder = ReeObjectFinder.new(@index)
+      end
+
+      def get_ree_receiver(receiver_node)
+        return if !receiver_node || !receiver_node.is_a?(Prism::CallNode)
+      
+        @finder.find_objects_by_types(receiver_node.name.to_s, RECEIVER_OBJECT_TYPES).first
+      end
+
+      def get_ree_object_methods_completions_items(ree_receiver, receiver_node, node)
+        location = receiver_node.location
+
+        case @finder.object_type(ree_receiver)
+        when :enum
+          get_enum_values_completion_items(ree_receiver, location)
+        when :bean
+          get_bean_methods_completion_items(ree_receiver, location)
+        when :dao
+          get_dao_filters_completion_items(ree_receiver, location)
+        else
+          []
+        end
+      end
+
       def get_bean_methods_completion_items(bean_obj, location)
         bean_node = RubyLsp::Ree::ParsedDocumentBuilder.build_from_uri(bean_obj.uri, :bean)
         
@@ -107,34 +139,75 @@ module RubyLsp
         end
       end
 
-      def get_class_name_completion_items(class_name_objects, parsed_doc, node, index, limit)
-        class_name_objects.take(limit).map do |full_class_name|
-          entry = index[full_class_name].first
-          class_name = full_class_name.split('::').last
-
-          package_name = package_name_from_uri(entry.uri)
-          file_name = File.basename(entry.uri.to_s)
-          
-          label_details = Interface::CompletionItemLabelDetails.new(
-            description: "from: :#{package_name}",
-            detail: " #{file_name}"
-          )
-
-          Interface::CompletionItem.new(
-            label: class_name,
-            label_details: label_details,
-            filter_text: class_name,
-            text_edit: Interface::TextEdit.new(
-              range:  range_from_location(node.location),
-              new_text: class_name,
-            ),
-            kind: Constant::CompletionItemKind::CLASS,
-            additional_text_edits: get_additional_text_edits_for_constant(parsed_doc, class_name, package_name, entry)
-          )
+      def get_class_name_completion_items(node)
+        node_name = node.name.to_s
+        class_name_objects = @finder.search_class_objects(node_name)
+        
+        return [] if class_name_objects.size == 0
+
+        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_ast(@node_context.parent, @uri)
+
+        imported_consts = []
+        not_imported_consts = []
+
+        class_name_objects.take(CANDIDATES_LIMIT).each do |full_class_name|
+          entries = @index[full_class_name]
+
+          entries.each do |entry|
+            class_name = full_class_name.split('::').last
+            package_name = package_name_from_uri(entry.uri)
+            file_name = File.basename(entry.uri.to_s)
+
+            matched_import = parsed_doc.find_import_for_package(class_name, package_name)
+
+            if matched_import   
+              label_details = Interface::CompletionItemLabelDetails.new(
+                description: "imported from: :#{package_name}",
+                detail: ""
+              )
+              
+              imported_consts << Interface::CompletionItem.new(
+                label: class_name,
+                label_details: label_details,
+                filter_text: class_name,
+                text_edit: Interface::TextEdit.new(
+                  range:  range_from_location(node.location),
+                  new_text: class_name,
+                ),
+                kind: Constant::CompletionItemKind::CLASS,
+                additional_text_edits: []
+              )
+            else
+              label_details = Interface::CompletionItemLabelDetails.new(
+                description: "from: :#{package_name}",
+                detail: " #{file_name}"
+              )
+
+              not_imported_consts << Interface::CompletionItem.new(
+                label: class_name,
+                label_details: label_details,
+                filter_text: class_name,
+                text_edit: Interface::TextEdit.new(
+                  range:  range_from_location(node.location),
+                  new_text: class_name,
+                ),
+                kind: Constant::CompletionItemKind::CLASS,
+                additional_text_edits: get_additional_text_edits_for_constant(parsed_doc, class_name, package_name, entry)
+              )
+            end
+          end
         end
+
+        imported_consts + not_imported_consts
       end
 
-      def get_ree_objects_completions_items(ree_objects, parsed_doc, node)
+      def get_ree_objects_completions_items(node)
+        ree_objects = @finder.search_objects(node.name.to_s, CANDIDATES_LIMIT)
+
+        return [] if ree_objects.size == 0
+  
+        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_ast(@node_context.parent, @uri)
+
         ree_objects.map do |ree_object|
           ree_object_name = ree_object.name
           package_name = package_name_from_uri(ree_object.uri)
@@ -254,6 +327,7 @@ module RubyLsp
         end
 
         range = get_range_for_fn_insert(parsed_doc, link_text)
+        return unless range
 
         [
           Interface::TextEdit.new(

data/lib/ruby_lsp/ruby_lsp_ree/listeners/completion_listener.rb

@@ -0,0 +1,49 @@
+require_relative "../handlers/completion_handler"
+
+module RubyLsp
+  module Ree
+    class CompletionListener
+      include Requests::Support::Common
+
+      CHARS_COUNT = 1
+      
+      def initialize(response_builder, node_context, index, dispatcher, uri)
+        @response_builder = response_builder
+        @handler = RubyLsp::Ree::CompletionHandler.new(index, uri, node_context)
+
+        dispatcher.register(self, :on_call_node_enter)
+        dispatcher.register(self, :on_constant_read_node_enter)
+      end
+
+      def on_constant_read_node_enter(node)
+        node_name = node.name.to_s
+        return if node_name.size < CHARS_COUNT
+
+        completion_items = @handler.get_class_name_completion_items(node)
+        put_items_into_response(completion_items)
+      end
+
+      def on_call_node_enter(node)
+        completion_items = []
+        ree_receiver = @handler.get_ree_receiver(node.receiver)
+
+        if ree_receiver
+          completion_items = @handler.get_ree_object_methods_completions_items(ree_receiver, node.receiver, node)
+        else
+          return if node.receiver
+          return if node.name.to_s.size < CHARS_COUNT
+  
+          completion_items = @handler.get_ree_objects_completions_items(node)
+        end
+        
+        put_items_into_response(completion_items)
+      end
+
+      def put_items_into_response(items)
+        items.each do |item|
+          @response_builder << item
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_ree/{definition.rb → listeners/definition_listener.rb}

@@ -1,9 +1,11 @@
-require_relative "ree_lsp_utils"
-require_relative "parsing/parsed_link_node"
+require_relative "../utils/ree_lsp_utils"
+require_relative "../parsing/parsed_link_node"
+require_relative "../parsing/parsed_document_builder"
+require_relative "../ree_object_finder"
 
 module RubyLsp
   module Ree
-    class Definition
+    class DefinitionListener
       include Requests::Support::Common
       include RubyLsp::Ree::ReeLspUtils
 
@@ -18,13 +20,18 @@ module RubyLsp
       end
 
       def on_constant_read_node_enter(node)
-        link_nodes = if @node_context.parent.is_a?(Prism::CallNode)
+        link_nodes = if @node_context.parent.is_a?(Prism::CallNode) && @node_context.parent.name == :link
           # inside link node
           link_node = RubyLsp::Ree::ParsedLinkNode.new(@node_context.parent)
           link_node.parse_imports
           [link_node]
         else
-          parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_ast(@node_context.parent, @uri)
+          parsed_doc = if @node_context.parent.is_a?(Prism::CallNode)
+            RubyLsp::Ree::ParsedDocumentBuilder.build_from_uri(@uri)
+          else
+            RubyLsp::Ree::ParsedDocumentBuilder.build_from_ast(@node_context.parent, @uri)
+          end
+
           parsed_doc.link_nodes
         end
         
@@ -63,11 +70,20 @@ module RubyLsp
         message = node.message
         return unless message
 
-        method = @index[message].detect{ !_1.location.nil? }
-        return unless method
+        definition_uri = nil
+
+        if node.receiver
+          # ruby lsp handles such cases itself
+          return
+        else
+          definition_item = ReeObjectFinder.new(@index).find_object(message)
+          definition_uri = definition_item.uri.to_s
+        end
+
+        return unless definition_uri
 
         @response_builder << Interface::Location.new(
-          uri: method.uri.to_s,
+          uri: definition_uri,
           range: Interface::Range.new(
             start: Interface::Position.new(line: 0, character: 0),
             end: Interface::Position.new(line: 0, character: 0),

data/lib/ruby_lsp/ruby_lsp_ree/listeners/hover_listener.rb

@@ -0,0 +1,65 @@
+require_relative "../ree_object_finder"
+require_relative "../parsing/parsed_document_builder"
+require_relative "../parsing/parsed_link_node"
+require_relative "../utils/ree_lsp_utils"
+
+module RubyLsp
+  module Ree
+    class HoverListener
+      include RubyLsp::Ree::ReeLspUtils
+
+      def initialize(response_builder, node_context, index, dispatcher)
+        @response_builder = response_builder
+        @node_context = node_context
+        @finder = ReeObjectFinder.new(index)
+
+        dispatcher.register(self, :on_call_node_enter)
+        dispatcher.register(self, :on_constant_read_node_enter)
+      end
+
+      def on_constant_read_node_enter(node)
+        # ree_object = @finder.search_classes(node.name.to_s).first
+
+        # $stderr.puts("ree_object #{ree_object.inspect}")
+
+        # return unless ree_object
+
+        # $stderr.puts("ree_object comm #{ree_object.comments.to_s}")
+
+        # @response_builder.push(ree_object.comments.to_s, category: :documentation)
+      end
+
+      def on_call_node_enter(node)
+        ree_object = @finder.find_object(node.name.to_s)
+
+        return unless ree_object
+
+        documentation =  <<~DOC
+        Ree object, type: :#{@finder.object_type(ree_object)}
+
+        usage: #{node.name.to_s}#{get_detail_string(ree_object)}
+        
+        package: #{package_name_from_uri(ree_object.uri)}
+
+        file: #{path_from_package_folder(ree_object.uri)}
+        DOC
+
+        $stderr.puts(documentation)
+
+        @response_builder.push(documentation, category: :documentation)
+      end
+
+      def get_detail_string(ree_object)
+        return '' if ree_object.signatures.size == 0
+
+        "(#{get_parameters_string(ree_object.signatures.first)})"
+      end
+
+      def get_parameters_string(signature)
+        return '' unless signature
+
+        signature.parameters.map(&:decorated_name).join(', ')
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_document.rb

@@ -5,20 +5,17 @@ class RubyLsp::Ree::ParsedDocument
 
   LINK_DSL_MODULE = 'Ree::LinkDSL'
 
-  attr_reader :ast, :package_name, :class_node, :fn_node, :fn_block_node, :class_includes,
-    :link_nodes, :values, :action_node, :action_block_node, :dao_node, :dao_block_node, :filters,
-    :bean_node, :bean_block_node, :bean_methods
+  attr_reader :ast, :package_name, :class_node, :fn_node, :class_includes,
+    :link_nodes, :values, :action_node, :dao_node, :filters,
+    :bean_node, :bean_methods, :mapper_node, :links_container_block_node, :aggregate_node
 
   def initialize(ast)
     @ast = ast
   end
 
   def links_container_node
-    @fn_node || @action_node || @dao_node || @bean_node
-  end
-
-  def links_container_block_node
-    @fn_block_node || @action_block_node || @dao_block_node || @bean_block_node
+    # TODO don't use separate node, use one field for all and additional type field: links_container_node_type
+    @fn_node || @action_node || @dao_node || @bean_node || @mapper_node || @aggregate_node
   end
 
   def includes_link_dsl?
@@ -33,8 +30,24 @@ class RubyLsp::Ree::ParsedDocument
     @link_nodes.map(&:name).include?(obj_name)
   end
 
+  def find_link_node(name)
+    @link_nodes.detect{ _1.name == name }
+  end
+
+  def find_link_with_imported_object(name)
+    @link_nodes.detect do |link_node|
+      link_node.imports.include?(name)
+    end
+  end
+
+  def find_import_for_package(name, package_name)
+    @link_nodes.detect do |link_node|
+      link_node.imports.include?(name) && link_node.link_package_name == package_name
+    end
+  end
+
   def has_blank_links_container?
-    links_container_node && !links_container_block_node
+    links_container_node && !@links_container_block_node
   end
 
   def set_package_name(package_name)
@@ -49,28 +62,42 @@ class RubyLsp::Ree::ParsedDocument
     return unless class_node
 
     @fn_node ||= class_node.body.body.detect{ |node| node.name == :fn }
-    @fn_block_node = @fn_node&.block
+    @links_container_block_node ||= @fn_node&.block
   end
 
   def parse_action_node
     return unless class_node
 
     @action_node ||= class_node.body.body.detect{ |node| node.name == :action }
-    @action_block_node = @action_node&.block
+    @links_container_block_node ||= @action_node&.block
   end
 
   def parse_dao_node
     return unless class_node
 
     @dao_node ||= class_node.body.body.detect{ |node| node.name == :dao }
-    @dao_block_node = @dao_node&.block
+    @links_container_block_node ||= @dao_node&.block
   end
 
   def parse_bean_node
     return unless class_node
 
     @bean_node ||= class_node.body.body.detect{ |node| node.name == :bean }
-    @bean_block_node = @bean_node&.block
+    @links_container_block_node ||= @bean_node&.block
+  end
+
+  def parse_mapper_node
+    return unless class_node
+
+    @mapper_node ||= class_node.body.body.detect{ |node| node.name == :mapper }
+    @links_container_block_node ||= @mapper_node&.block
+  end
+
+  def parse_aggregate_node
+    return unless class_node
+
+    @aggregate_node ||= class_node.body.body.detect{ |node| node.name == :aggregate }
+    @links_container_block_node ||= @aggregate_node&.block
   end
 
   def parse_class_includes
@@ -89,8 +116,8 @@ class RubyLsp::Ree::ParsedDocument
   def parse_links
     return unless class_node
 
-    nodes = if links_container_node && links_container_block_node.body
-      links_container_block_node.body.body.select{ |node| node.name == :link }
+    nodes = if links_container_node && @links_container_block_node.body
+      @links_container_block_node.body.body.select{ |node| node.name == :link }
     elsif class_includes.any?{ _1.name == LINK_DSL_MODULE }
       class_node.body.body.select{ |node| node.name == :link }
     else

data/lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_document_builder.rb

@@ -47,6 +47,8 @@ class RubyLsp::Ree::ParsedDocumentBuilder
     document.parse_action_node
     document.parse_bean_node
     document.parse_dao_node
+    document.parse_mapper_node
+    document.parse_aggregate_node
     document.parse_class_includes
     document.parse_links
 

data/lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_link_node.rb

@@ -13,7 +13,12 @@ class RubyLsp::Ree::ParsedLinkNode
   end
 
   def link_package_name
-    from_arg_value || document_package
+    case link_type
+    when :object_name
+      from_arg_value || document_package
+    when :file_path
+      @name.split('/').first
+    end
   end
 
   def location

data/lib/ruby_lsp/ruby_lsp_ree/ree_indexing_enhancement.rb

@@ -1,12 +1,12 @@
 require 'prism'
-require_relative "ree_lsp_utils"
+require_relative "utils/ree_lsp_utils"
 
 module RubyLsp
   module Ree
     class ReeIndexingEnhancement < RubyIndexer::Enhancement
       include RubyLsp::Ree::ReeLspUtils
 
-      REE_INDEXED_OBJECTS = [:fn, :enum, :action, :dao, :bean]
+      REE_INDEXED_OBJECTS = [:fn, :enum, :action, :dao, :bean, :mapper, :aggregate]
 
       def on_call_node_enter(node)
         return unless @listener.current_owner

data/lib/ruby_lsp/ruby_lsp_ree/ree_object_finder.rb

@@ -7,9 +7,15 @@ module RubyLsp
       ENUM_TYPE_STRING = 'type: :enum'
       DAO_TYPE_STRING = 'type: :dao'
       BEAN_TYPE_STRING = 'type: :bean'
+      MAPPER_TYPE_STRING = 'type: :mapper'
+      AGGREGATE_TYPE_STRING = 'type: :aggregate'
 
-      def self.search_objects(index, name, limit)
-        index.prefix_search(name)
+      def initialize(index)
+        @index = index
+      end
+
+      def search_objects(name, limit)
+        @index.prefix_search(name)
           .take(MAX_LIMIT)
           .flatten
           .select{ _1.comments }
@@ -18,26 +24,69 @@ module RubyLsp
           .take(limit)
       end
 
-      def self.find_enum(index, name)
-        objects_by_name = index[name]
+      def search_class_objects(name)
+        @index
+          .names
+          .select{ _1.split('::').last[0...name.size] == name}
+      end
+
+      def search_classes(name)
+        keys = search_class_objects(name)
+        @index.instance_variable_get(:@entries).values_at(*keys)
+      end
+
+      def find_object(name)
+        objects_by_name = @index[name]
+        return unless objects_by_name
+
+        objects_by_name.detect{ _1.comments.to_s.lines.first&.chomp == REE_OBJECT_STRING }
+      end
+
+      def find_objects_by_types(name, types)
+        objects_by_name = @index[name]
+        return [] unless objects_by_name
+
+        objects_by_name.select{ types.include?(object_type(_1)) }
+      end
+
+      def find_enum(name)
+        objects_by_name = @index[name]
         return unless objects_by_name
 
         objects_by_name.detect{ _1.comments.lines[1]&.chomp == ENUM_TYPE_STRING }
       end
 
-      def self.find_dao(index, name)
-        objects_by_name = index[name]
+      def find_dao(name)
+        objects_by_name = @index[name]
         return unless objects_by_name
 
         objects_by_name.detect{ _1.comments.lines[1]&.chomp == DAO_TYPE_STRING }
       end
 
-      def self.find_bean(index, name)
-        objects_by_name = index[name]
+      def find_bean(index, name)
+        objects_by_name = @index[name]
         return unless objects_by_name
 
         objects_by_name.detect{ _1.comments.lines[1]&.chomp == BEAN_TYPE_STRING }
       end
+
+      def object_type(ree_object)
+        # TODO rewrite to use string split
+        case ree_object.comments.lines[1]&.chomp
+        when DAO_TYPE_STRING
+          :dao
+        when BEAN_TYPE_STRING
+          :bean
+        when ENUM_TYPE_STRING
+          :enum
+        when MAPPER_TYPE_STRING
+          :mapper
+        when AGGREGATE_TYPE_STRING
+          :aggregate
+        else
+          nil
+        end
+      end
     end
   end
 end

data/lib/ruby_lsp/ruby_lsp_ree/{ree_lsp_utils.rb → utils/ree_lsp_utils.rb}

@@ -18,7 +18,7 @@ module RubyLsp
       end
 
       def path_from_package_folder(uri)
-        uri_parts = uri.chomp(File.extname(uri)).split('/')
+        uri_parts = uri.to_s.chomp(File.extname(uri)).split('/')
 
         package_folder_index = uri_parts.index('package')
         return unless package_folder_index
@@ -49,6 +49,8 @@ module RubyLsp
         elsif parsed_doc.includes_link_dsl?
           fn_line = parsed_doc.link_nodes.first.location.start_line - 1
           position = parsed_doc.link_nodes.first.location.start_column
+        else
+          return nil
         end
 
         Interface::Range.new(

data/lib/ruby_lsp_ree/version.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-module Ruby
-  module Lsp
-    module Ree
-      VERSION = "0.1.2"
-    end
+module RubyLsp
+  module Ree
+    VERSION = "0.1.3"
   end
 end

data/ruby-lsp-ree.gemspec

@@ -4,7 +4,7 @@ require_relative "lib/ruby_lsp_ree/version"
 
 Gem::Specification.new do |spec|
   spec.name = "ruby-lsp-ree"
-  spec.version = Ruby::Lsp::Ree::VERSION
+  spec.version = RubyLsp::Ree::VERSION
   spec.authors = ["Ruslan Gatiyatov"]
   spec.email = ["ruslan.gatiyatov@gmail.com"]
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-ree
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-02-14 00:00:00.000000000 Z
+date: 2025-02-21 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby LSP addon that adds extra editor functionality for Ree applications
 email:
@@ -17,6 +17,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".ruby-version"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -25,16 +26,17 @@ files:
 - README.md
 - Rakefile
 - lib/ruby_lsp/ruby_lsp_ree/addon.rb
-- lib/ruby_lsp/ruby_lsp_ree/completion.rb
-- lib/ruby_lsp/ruby_lsp_ree/completion_utils.rb
-- lib/ruby_lsp/ruby_lsp_ree/definition.rb
+- lib/ruby_lsp/ruby_lsp_ree/handlers/completion_handler.rb
+- lib/ruby_lsp/ruby_lsp_ree/listeners/completion_listener.rb
+- lib/ruby_lsp/ruby_lsp_ree/listeners/definition_listener.rb
+- lib/ruby_lsp/ruby_lsp_ree/listeners/hover_listener.rb
 - lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_document.rb
 - lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_document_builder.rb
 - lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_link_node.rb
 - lib/ruby_lsp/ruby_lsp_ree/ree_formatter.rb
 - lib/ruby_lsp/ruby_lsp_ree/ree_indexing_enhancement.rb
-- lib/ruby_lsp/ruby_lsp_ree/ree_lsp_utils.rb
 - lib/ruby_lsp/ruby_lsp_ree/ree_object_finder.rb
+- lib/ruby_lsp/ruby_lsp_ree/utils/ree_lsp_utils.rb
 - lib/ruby_lsp_ree.rb
 - lib/ruby_lsp_ree/version.rb
 - ruby-lsp-ree.gemspec
@@ -61,7 +63,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.5.3
 signing_key: 
 specification_version: 4
 summary: Ruby LSP addon for Ree framework.

data/lib/ruby_lsp/ruby_lsp_ree/completion.rb

@@ -1,108 +0,0 @@
-require_relative "ree_lsp_utils"
-require_relative "completion_utils"
-require_relative "ree_object_finder"
-
-module RubyLsp
-  module Ree
-    class Completion
-      include Requests::Support::Common
-      include RubyLsp::Ree::ReeLspUtils
-      include RubyLsp::Ree::CompletionUtils
-
-      CHARS_COUNT = 1
-      CANDIDATES_LIMIT = 100
-      
-      def initialize(response_builder, node_context, index, dispatcher, uri)
-        @response_builder = response_builder
-        @index = index
-        @uri = uri
-        @node_context = node_context
-
-        dispatcher.register(self, :on_call_node_enter)
-        dispatcher.register(self, :on_constant_read_node_enter)
-      end
-
-      def on_constant_read_node_enter(node)
-        node_name = node.name.to_s
-        return if node_name.size < CHARS_COUNT
-
-        class_name_objects = @index.instance_variable_get(:@entries).keys.select{ _1.split('::').last[0...node_name.size] == node_name}
-        return if class_name_objects.size == 0
-
-        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_ast(@node_context.parent, @uri)
-
-        completion_items = get_class_name_completion_items(class_name_objects, parsed_doc, node, @index, CANDIDATES_LIMIT)
-        put_items_into_response(completion_items)
-      end
-
-      def on_call_node_enter(node)
-        if receiver_is_enum?(node)
-          return enum_value_completion(node)
-        end
-
-        if receiver_is_dao?(node)
-          return dao_filter_completion(node)
-        end
-
-        if receiver_is_bean?(node)
-          return bean_method_completion(node)
-        end
-
-        return if node.receiver
-        return if node.name.to_s.size < CHARS_COUNT
-
-        ree_objects = ReeObjectFinder.search_objects(@index, node.name.to_s, CANDIDATES_LIMIT)
-
-        return if ree_objects.size == 0
-
-        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_ast(@node_context.parent, @uri)
-
-        completion_items = get_ree_objects_completions_items(ree_objects, parsed_doc, node)
-        put_items_into_response(completion_items)
-      end
-
-      def receiver_is_enum?(node)
-        node.receiver && node.receiver.is_a?(Prism::CallNode) && ReeObjectFinder.find_enum(@index, node.receiver.name.to_s)
-      end
-
-      def receiver_is_dao?(node)
-        node.receiver && node.receiver.is_a?(Prism::CallNode) && ReeObjectFinder.find_dao(@index, node.receiver.name.to_s)
-      end
-
-      def receiver_is_bean?(node)
-        node.receiver && node.receiver.is_a?(Prism::CallNode) && ReeObjectFinder.find_bean(@index, node.receiver.name.to_s)
-      end
-
-      def enum_value_completion(node)
-        enum_obj = ReeObjectFinder.find_enum(@index, node.receiver.name.to_s)
-        location = node.receiver.location
-        
-        completion_items = get_enum_values_completion_items(enum_obj, location)
-        put_items_into_response(completion_items)
-      end
-
-      def dao_filter_completion(node)
-        dao_obj = ReeObjectFinder.find_dao(@index, node.receiver.name.to_s)
-        location = node.receiver.location
-
-        completion_items = get_dao_filters_completion_items(dao_obj, location)
-        put_items_into_response(completion_items)
-      end
-
-      def bean_method_completion(node)
-        bean_obj = ReeObjectFinder.find_bean(@index, node.receiver.name.to_s)
-        location = node.receiver.location
-
-        completion_items = get_bean_methods_completion_items(bean_obj, location)
-
-        put_items_into_response(completion_items)
-      end
-
-      def put_items_into_response(items)
-        items.each do |item|
-          @response_builder << item
-        end
-      end
-    end
-  end
-end