ruby-lsp-ree 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1104f2c78afb874d9277a4e2d1c8b5adaf925bdb4fb9abb23b08a9e5a27aff9
-  data.tar.gz: 061f2b31a9aac045d279797b7561597db1825e396547b5afd94d6bfc4015af1e
+  metadata.gz: a1d126a7d0c8462f33b63113cf86ae134f8cb029da147273bdb2f8cb76cb448e
+  data.tar.gz: dbb25c53fc012b487a3ed9555ad470c10445603e808aa3f44442070b4fc57851
 SHA512:
-  metadata.gz: 7f29b69bb720eadc44261c63719ca950cec24db996d0d4d83117c20c3a145bb6be8934420acb850ba92841feefe4985f0e0c1caa7129cd50a41a4419f3a2ca1e
-  data.tar.gz: fea1f33dd0bcdfe401afe15304797fca57c254cf8472b34a8ef40d7f011d2bb60edb1010177129671fcbfc0f7ca69b212832c2c70ef8b8f125025a20be0ca17a
+  metadata.gz: 50d85fbda0c61e33709823c7e8b5f263d94eba2d6822b1e84f011ad0b058adf6d5766a5fe27b6613c537b2e36f878a8ef50ddf7fad7dd41cfd954011fe90c156
+  data.tar.gz: 66c76a82263258d76fcc7cc604e6aa499deb209ae80c6ae8a5bad1dd486f7ee70c9e0af896277c0cc01631ad99c91f5b5b827e18337b0d95e4d18622d1c2c389

data/.ruby-version

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

data/CHANGELOG.md

@@ -1,8 +1,26 @@
-## [Unreleased]
+## [0.1.4] - 2025-02-25
 
-## [0.1.0] - 2025-01-31
+- autocompletion in spec files
+- Add Link in spec files
+- improved support of new files and unsaved documents
 
-- Initial release
+## [0.1.3] - 2025-02-21
+
+- 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
+
+## [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 +39,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.4)
 
 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,44 @@
-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
+        @root_node = @node_context.instance_variable_get(:@nesting_nodes).first
+        @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 +140,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(@root_node, @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(@root_node, @uri)
+
         ree_objects.map do |ree_object|
           ree_object_name = ree_object.name
           package_name = package_name_from_uri(ree_object.uri)
@@ -233,6 +307,8 @@ module RubyLsp
       end
 
       def get_additional_text_edits_for_method(parsed_doc, fn_name, package_name)
+        return [] unless parsed_doc
+
         if parsed_doc.includes_linked_object?(fn_name)
           return []
         end
@@ -254,6 +330,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/{definition.rb → handlers/definition_handler.rb}

@@ -1,30 +1,36 @@
-require_relative "ree_lsp_utils"
-require_relative "parsing/parsed_link_node"
+require_relative "../utils/ree_lsp_utils"
+require_relative "../ree_object_finder"
+require_relative "../parsing/parsed_link_node"
+require_relative "../parsing/parsed_document_builder"
 
 module RubyLsp
   module Ree
-    class Definition
+    class DefinitionHandler
       include Requests::Support::Common
       include RubyLsp::Ree::ReeLspUtils
 
-      def initialize(response_builder, node_context, index, dispatcher, uri)
-        @response_builder = response_builder
-        @node_context = node_context
-        @nesting = node_context.nesting
+      def initialize(index, uri, node_context)
         @index = index
         @uri = uri
-
-        dispatcher.register(self, :on_call_node_enter, :on_symbol_node_enter, :on_string_node_enter, :on_constant_read_node_enter)
+        @node_context = node_context
+        @finder = ReeObjectFinder.new(@index)
       end
 
-      def on_constant_read_node_enter(node)
-        link_nodes = if @node_context.parent.is_a?(Prism::CallNode)
+      def get_constant_definition_items(node)
+        result = []
+
+        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
         
@@ -48,7 +54,7 @@ module RubyLsp
               uri = method.uri.to_s
             end
 
-            @response_builder << Interface::Location.new(
+            result << Interface::Location.new(
               uri: uri,
               range: Interface::Range.new(
                 start: Interface::Position.new(line: 0, character: 0),
@@ -57,40 +63,46 @@ module RubyLsp
             )
           end
         end
+
+        result
       end
 
-      def on_call_node_enter(node)
+      def get_ree_objects_definition_items(node)
         message = node.message
-        return unless message
+        result = []
+        
+        definition_item = ReeObjectFinder.new(@index).find_object(message)
+        return [] unless definition_item
 
-        method = @index[message].detect{ !_1.location.nil? }
-        return unless method
+        definition_uri = definition_item.uri.to_s
+        return [] unless definition_uri
 
-        @response_builder << Interface::Location.new(
-          uri: method.uri.to_s,
+        result << Interface::Location.new(
+          uri: definition_uri,
           range: Interface::Range.new(
             start: Interface::Position.new(line: 0, character: 0),
             end: Interface::Position.new(line: 0, character: 0),
           ),
         )
 
-        nil
+        result
       end
 
-      def on_symbol_node_enter(node)
+      def get_linked_object_definition_items(node)
+        result = []
         parent_node = @node_context.parent
-        return unless parent_node.name == :link
+        return [] unless parent_node.name == :link
 
         link_node = RubyLsp::Ree::ParsedLinkNode.new(parent_node, package_name_from_uri(@uri))
         package_name = link_node.link_package_name
 
         method_candidates = @index[node.unescaped]
-        return if !method_candidates || method_candidates.size == 0
+        return [] if !method_candidates || method_candidates.size == 0
         
         method = method_candidates.detect{ package_name_from_uri(_1.uri) == package_name }
-        return unless method
+        return [] unless method
 
-        @response_builder << Interface::Location.new(
+        result << Interface::Location.new(
           uri: method.uri.to_s,
           range: Interface::Range.new(
             start: Interface::Position.new(line: 0, character: 0),
@@ -98,23 +110,22 @@ module RubyLsp
           ),
         )
 
-        nil
+        result
       end
 
-      def on_string_node_enter(node)
+      def get_linked_filepath_definition_items(node)
+        result = []
         local_path = find_local_file_path(node.unescaped)
 
-        if local_path
-          @response_builder << Interface::Location.new(
-            uri: File.join(Dir.pwd, local_path),
-            range: Interface::Range.new(
-              start: Interface::Position.new(line: 0, character: 0),
-              end: Interface::Position.new(line: 0, character: 0),
-            ),
-          )
-        end
+        return [] unless local_path
 
-        nil
+        result << Interface::Location.new(
+          uri: File.join(Dir.pwd, local_path),
+          range: Interface::Range.new(
+            start: Interface::Position.new(line: 0, character: 0),
+            end: Interface::Position.new(line: 0, character: 0),
+          ),
+        )
       end
     end
   end

data/lib/ruby_lsp/ruby_lsp_ree/handlers/hover_handler.rb

@@ -0,0 +1,49 @@
+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 HoverHandler
+      include Requests::Support::Common
+      include RubyLsp::Ree::ReeLspUtils
+
+      def initialize(index, node_context)
+        @index = index
+        @node_context = node_context
+        @finder = ReeObjectFinder.new(@index)
+      end
+
+      def get_ree_object_hover_items(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
+
+        [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/listeners/completion_listener.rb

@@ -0,0 +1,53 @@
+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)
+      rescue => e
+        $stderr.puts("error in completion listener(on_constant_read_node_enter): #{e.message} : #{e.backtrace.first}")
+      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)
+      rescue => e
+        $stderr.puts("error in completion listener(on_call_node_enter): #{e.message} : #{e.backtrace.first}")
+      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/listeners/definition_listener.rb

@@ -0,0 +1,63 @@
+require_relative "../handlers/definition_handler"
+
+module RubyLsp
+  module Ree
+    class DefinitionListener
+      include Requests::Support::Common
+
+      def initialize(response_builder, node_context, index, dispatcher, uri)
+        @response_builder = response_builder
+        @handler = RubyLsp::Ree::DefinitionHandler.new(index, uri, node_context)
+
+        dispatcher.register(
+          self, 
+          :on_call_node_enter, 
+          :on_symbol_node_enter, 
+          :on_string_node_enter, 
+          :on_constant_read_node_enter
+        )
+      end
+
+      def on_constant_read_node_enter(node)
+        definition_items = @handler.get_constant_definition_items(node)
+        put_items_into_response(definition_items)
+      rescue => e
+        $stderr.puts("error in definition listener(on_constant_read_node_enter): #{e.message} : #{e.backtrace.first}")
+      end
+
+      def on_call_node_enter(node)
+        return unless node.message
+
+        if node.receiver
+          # ruby lsp handles such cases itself
+          return
+        else
+          definition_items = @handler.get_ree_objects_definition_items(node)
+          put_items_into_response(definition_items)
+        end
+      rescue => e
+        $stderr.puts("error in definition listener(on_call_node_enter): #{e.message} : #{e.backtrace.first}")
+      end
+
+      def on_symbol_node_enter(node)
+        definition_items = @handler.get_linked_object_definition_items(node)
+        put_items_into_response(definition_items)
+      rescue => e
+        $stderr.puts("error in definition listener(on_symbol_node_enter): #{e.message} : #{e.backtrace.first}")
+      end
+
+      def on_string_node_enter(node)
+        definition_items = @handler.get_linked_filepath_definition_items(node)
+        put_items_into_response(definition_items)
+      rescue => e
+        $stderr.puts("error in definition listener(on_string_node_enter): #{e.message} : #{e.backtrace.first}")
+      end
+
+      def put_items_into_response(items)
+        items.each do |item|
+          @response_builder << item
+        end
+      end
+    end
+  end
+end