ruby-lsp-ree 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 350bb1ae1a376f2a8594e3945c396c49d01907b1c840d36311e28761c2fe9d8e
-  data.tar.gz: dfa9bc947cf5f951d62e2686290a7ac603c5dfa34652cb21be4b1547d2e3b5e1
+  metadata.gz: 8eb134e8d6b0ac3bf5321789ed6617ea1347ee096b1e642f953885b398524030
+  data.tar.gz: 460f2cc171155affbafe236535604b116d0af15bbcf14c3925470a8ff3616211
 SHA512:
-  metadata.gz: eaaa38d222082eb2a55f73a977114a2632d2db2a2b7d10a0d96d2284b87fbd2c02bcab43e45ec617afa63e5c9fd4f9e64339f7cb919ba23365a5deae1aa3df4e
-  data.tar.gz: 64e7ce28fdb802eadbe27c6f7fd5d5e156c9c3d39627c9a7e191bf808fc9519eb26befa49182cc62bda12941c8e6fd4f478060ec61e33d38035aa10726c087d1
+  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
 
@@ -19,4 +31,10 @@
 - Add Link for ree actions
 - sort links in ree actions
 - autocomplete for ree dao
-- autocomplete for dao filters
+- autocomplete for dao filters
+
+## [0.1.0] - 2025-01-31
+
+- 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,19 +1,55 @@
 PATH
   remote: .
   specs:
-    ruby-lsp-ree (0.1.1)
+    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
   x86_64-linux
 
 DEPENDENCIES
   rake (~> 13.0)
+  rspec
+  ruby-lsp
   ruby-lsp-ree!
+  sorbet-static-and-runtime
 
 BUNDLED WITH
-   2.4.20
+   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,14 +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)
-        $stderr.puts("create_completion_listener")
-        
         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,77 @@
-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)
+        
+        range = Interface::Range.new(
+          start: Interface::Position.new(line: location.start_line - 1, character: location.end_column + 1),
+          end: Interface::Position.new(line: location.start_line - 1, character: location.end_column + 1),
+        )
+
+        bean_node.bean_methods.map do |bean_method|
+          signature = bean_method.signatures.first
+
+          label_details = Interface::CompletionItemLabelDetails.new(
+            description: "method",
+            detail: get_detail_string(signature)
+          )
+
+          Interface::CompletionItem.new(
+            label: bean_method.name,
+            label_details: label_details,
+            filter_text: bean_method.name,
+            text_edit: Interface::TextEdit.new(
+              range:  range,
+              new_text: get_method_string(bean_method.name, signature)
+            ),
+            kind: Constant::CompletionItemKind::METHOD,
+            insert_text_format: Constant::InsertTextFormat::SNIPPET,
+            data: {
+              owner_name: "Object",
+              guessed_type: false,
+            }
+          )
+        end
+      end
+
       def get_dao_filters_completion_items(dao_obj, location)
         dao_node = RubyLsp::Ree::ParsedDocumentBuilder.build_from_uri(dao_obj.uri, :dao)
         
@@ -73,33 +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
+      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
 
-          package_name = package_name_from_uri(entry.uri)
+        imported_consts + not_imported_consts
+      end
 
-          label_details = Interface::CompletionItemLabelDetails.new(
-            description: "from: :#{package_name}",
-            detail: ""
-          )
+      def get_ree_objects_completions_items(node)
+        ree_objects = @finder.search_objects(node.name.to_s, CANDIDATES_LIMIT)
 
-          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
+        return [] if ree_objects.size == 0
+  
+        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_ast(@node_context.parent, @uri)
 
-      def get_ree_objects_completions_items(ree_objects, parsed_doc, node)
         ree_objects.map do |ree_object|
           ree_object_name = ree_object.name
           package_name = package_name_from_uri(ree_object.uri)
@@ -163,7 +271,6 @@ module RubyLsp
 
       def get_additional_text_edits_for_constant(parsed_doc, class_name, package_name, entry)
         if parsed_doc.includes_linked_constant?(class_name)
-          $stderr.puts("links already include #{class_name}")
           return []
         end
 
@@ -173,7 +280,7 @@ module RubyLsp
           fn_name = File.basename(entry_uri, ".*")
           "\s\slink :#{fn_name}, import: -> { #{class_name} }"
         else
-          path = path_from_package(entry_uri)
+          path = path_from_package_folder(entry_uri)
           "\s\slink \"#{path}\", import: -> { #{class_name} }"
         end
 
@@ -200,7 +307,6 @@ module RubyLsp
 
       def get_additional_text_edits_for_method(parsed_doc, fn_name, package_name)
         if parsed_doc.includes_linked_object?(fn_name)
-          $stderr.puts("links already include #{fn_name}")
           return []
         end
 
@@ -221,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/listeners/definition_listener.rb

@@ -0,0 +1,137 @@
+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 DefinitionListener
+      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
+        @index = index
+        @uri = uri
+
+        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)
+        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 = 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
+        
+        link_nodes.each do |link_node|
+          if link_node.imports.include?(node.name.to_s)
+            uri = ''
+            if link_node.file_path_type?
+              path = find_local_file_path(link_node.name)  
+              next unless path
+
+              uri = File.join(Dir.pwd, path)
+            else
+              package_name = link_node.link_package_name || package_name_from_uri(@uri)
+
+              method_candidates = @index[link_node.name]
+              next if !method_candidates || method_candidates.size == 0
+        
+              method = method_candidates.detect{ package_name_from_uri(_1.uri) == package_name }
+              next unless method
+
+              uri = method.uri.to_s
+            end
+
+            @response_builder << Interface::Location.new(
+              uri: uri,
+              range: Interface::Range.new(
+                start: Interface::Position.new(line: 0, character: 0),
+                end: Interface::Position.new(line: 0, character: 0),
+              ),
+            )
+          end
+        end
+      end
+
+      def on_call_node_enter(node)
+        message = node.message
+        return unless message
+
+        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: definition_uri,
+          range: Interface::Range.new(
+            start: Interface::Position.new(line: 0, character: 0),
+            end: Interface::Position.new(line: 0, character: 0),
+          ),
+        )
+
+        nil
+      end
+
+      def on_symbol_node_enter(node)
+        parent_node = @node_context.parent
+        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
+        
+        method = method_candidates.detect{ package_name_from_uri(_1.uri) == package_name }
+        return unless method
+
+        @response_builder << Interface::Location.new(
+          uri: method.uri.to_s,
+          range: Interface::Range.new(
+            start: Interface::Position.new(line: 0, character: 0),
+            end: Interface::Position.new(line: 0, character: 0),
+          ),
+        )
+
+        nil
+      end
+
+      def on_string_node_enter(node)
+        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
+
+        nil
+      end
+    end
+  end
+end

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