ruby-lsp-ree 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 350bb1ae1a376f2a8594e3945c396c49d01907b1c840d36311e28761c2fe9d8e
-  data.tar.gz: dfa9bc947cf5f951d62e2686290a7ac603c5dfa34652cb21be4b1547d2e3b5e1
+  metadata.gz: a1104f2c78afb874d9277a4e2d1c8b5adaf925bdb4fb9abb23b08a9e5a27aff9
+  data.tar.gz: 061f2b31a9aac045d279797b7561597db1825e396547b5afd94d6bfc4015af1e
 SHA512:
-  metadata.gz: eaaa38d222082eb2a55f73a977114a2632d2db2a2b7d10a0d96d2284b87fbd2c02bcab43e45ec617afa63e5c9fd4f9e64339f7cb919ba23365a5deae1aa3df4e
-  data.tar.gz: 64e7ce28fdb802eadbe27c6f7fd5d5e156c9c3d39627c9a7e191bf808fc9519eb26befa49182cc62bda12941c8e6fd4f478060ec61e33d38035aa10726c087d1
+  metadata.gz: 7f29b69bb720eadc44261c63719ca950cec24db996d0d4d83117c20c3a145bb6be8934420acb850ba92841feefe4985f0e0c1caa7129cd50a41a4419f3a2ca1e
+  data.tar.gz: fea1f33dd0bcdfe401afe15304797fca57c254cf8472b34a8ef40d7f011d2bb60edb1010177129671fcbfc0f7ca69b212832c2c70ef8b8f125025a20be0ca17a

data/CHANGELOG.md

@@ -19,4 +19,14 @@
 - Add Link for ree actions
 - sort links in ree actions
 - autocomplete for ree dao
-- autocomplete for dao filters
+- autocomplete for dao filters
+
+## [0.1.2] - 2025-02-14
+
+- 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

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ruby-lsp-ree (0.1.1)
+    ruby-lsp-ree (0.1.2)
 
 GEM
   remote: https://rubygems.org/
@@ -9,6 +9,7 @@ GEM
     rake (13.2.1)
 
 PLATFORMS
+  x86_64-darwin-23
   x86_64-linux
 
 DEPENDENCIES
@@ -16,4 +17,4 @@ DEPENDENCIES
   ruby-lsp-ree!
 
 BUNDLED WITH
-   2.4.20
+   2.6.3

data/lib/ruby_lsp/ruby_lsp_ree/addon.rb

@@ -29,8 +29,6 @@ module RubyLsp
       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)
       end

data/lib/ruby_lsp/ruby_lsp_ree/completion.rb

@@ -9,8 +9,8 @@ module RubyLsp
       include RubyLsp::Ree::ReeLspUtils
       include RubyLsp::Ree::CompletionUtils
 
-      CHARS_COUNT = 3
-      CANDIDATES_LIMIT = 20
+      CHARS_COUNT = 1
+      CANDIDATES_LIMIT = 100
       
       def initialize(response_builder, node_context, index, dispatcher, uri)
         @response_builder = response_builder
@@ -29,10 +29,10 @@ module RubyLsp
         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_uri(@uri)
+        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)
-        puts_items_into_response(completion_items)
+        put_items_into_response(completion_items)
       end
 
       def on_call_node_enter(node)
@@ -44,16 +44,21 @@ module RubyLsp
           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_uri(@uri)
+        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_ast(@node_context.parent, @uri)
 
         completion_items = get_ree_objects_completions_items(ree_objects, parsed_doc, node)
-        puts_items_into_response(completion_items)
+        put_items_into_response(completion_items)
       end
 
       def receiver_is_enum?(node)
@@ -64,12 +69,16 @@ module RubyLsp
         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)
-        puts_items_into_response(completion_items)
+        put_items_into_response(completion_items)
       end
 
       def dao_filter_completion(node)
@@ -77,10 +86,19 @@ module RubyLsp
         location = node.receiver.location
 
         completion_items = get_dao_filters_completion_items(dao_obj, location)
-        puts_items_into_response(completion_items)
+        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 puts_items_into_response(items)
+      def put_items_into_response(items)
         items.each do |item|
           @response_builder << item
         end

data/lib/ruby_lsp/ruby_lsp_ree/completion_utils.rb

@@ -6,6 +6,40 @@ module RubyLsp
       include Requests::Support::Common
       include RubyLsp::Ree::ReeLspUtils
 
+      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)
         
@@ -79,10 +113,11 @@ module RubyLsp
           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: ""
+            detail: " #{file_name}"
           )
 
           Interface::CompletionItem.new(
@@ -163,7 +198,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 +207,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 +234,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
 

data/lib/ruby_lsp/ruby_lsp_ree/definition.rb

@@ -14,17 +14,56 @@ module RubyLsp
         @index = index
         @uri = uri
 
-        dispatcher.register(self, :on_call_node_enter, :on_symbol_node_enter, :on_string_node_enter)
+        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)
+          # 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.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
-        $stderr.puts("definition on_call_node_enter #{message}")
-
         return unless message
 
         method = @index[message].detect{ !_1.location.nil? }
-
         return unless method
 
         @response_builder << Interface::Location.new(
@@ -63,8 +102,7 @@ module RubyLsp
       end
 
       def on_string_node_enter(node)
-        file_name = node.unescaped + ".rb"
-        local_path = Dir[File.join('**', file_name)].first
+        local_path = find_local_file_path(node.unescaped)
 
         if local_path
           @response_builder << Interface::Location.new(

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

@@ -6,18 +6,19 @@ 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
+    :link_nodes, :values, :action_node, :action_block_node, :dao_node, :dao_block_node, :filters,
+    :bean_node, :bean_block_node, :bean_methods
 
   def initialize(ast)
     @ast = ast
   end
 
   def links_container_node
-    @fn_node || @action_node || @dao_node
+    @fn_node || @action_node || @dao_node || @bean_node
   end
 
   def links_container_block_node
-    @fn_block_node || @action_block_node || @dao_block_node
+    @fn_block_node || @action_block_node || @dao_block_node || @bean_block_node
   end
 
   def includes_link_dsl?
@@ -65,6 +66,13 @@ class RubyLsp::Ree::ParsedDocument
     @dao_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
+  end
+
   def parse_class_includes
     return unless class_node
 
@@ -113,13 +121,25 @@ class RubyLsp::Ree::ParsedDocument
 
   end
 
+  def parse_bean_methods
+    return unless class_node
+    
+    @bean_methods ||= class_node.body.body
+      .select{ _1.is_a?(Prism::DefNode) }
+      .map{ OpenStruct.new(name: _1.name.to_s, signatures: parse_signatures_from_params(_1.parameters)) }
+  end
+
   def parse_filter_signature(filter_node)
     return [] unless filter_node
 
     lambda_node = filter_node.arguments&.arguments[1]
     return [] unless lambda_node
 
-    signature_params = signature_params_from_node(lambda_node.parameters.parameters)
+    parse_signatures_from_params(lambda_node.parameters.parameters)
+  end
+
+  def parse_signatures_from_params(parameters)
+    signature_params = signature_params_from_node(parameters)
     [RubyIndexer::Entry::Signature.new(signature_params)]
   end
 

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

@@ -13,6 +13,14 @@ class RubyLsp::Ree::ParsedDocumentBuilder
     document
   end
 
+  def self.build_from_ast(ast, uri, type = nil)
+    document = build_document(ast, type)
+
+    document.set_package_name(package_name_from_uri(uri))
+
+    document
+  end
+
   def self.build_from_source(source, type = nil)
     ast = Prism.parse(source).value
     build_document(ast, type)
@@ -24,6 +32,8 @@ class RubyLsp::Ree::ParsedDocumentBuilder
       build_enum_document(ast)
     when :dao
       build_dao_document(ast)
+    when :bean
+      build_bean_document(ast)
     else
       build_regular_document(ast)
     end
@@ -35,6 +45,8 @@ class RubyLsp::Ree::ParsedDocumentBuilder
     document.parse_class_node
     document.parse_fn_node
     document.parse_action_node
+    document.parse_bean_node
+    document.parse_dao_node
     document.parse_class_includes
     document.parse_links
 
@@ -57,5 +69,14 @@ class RubyLsp::Ree::ParsedDocumentBuilder
     document.parse_filters
 
     document
-  end   
+  end  
+  
+  def self.build_bean_document(ast)
+    document = RubyLsp::Ree::ParsedDocument.new(ast)
+    
+    document.parse_class_node
+    document.parse_bean_methods
+
+    document
+  end  
 end

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

@@ -30,9 +30,32 @@ class RubyLsp::Ree::ParsedLinkNode
     @from_param.value.unescaped
   end
 
-  def parse_name
-    name_arg_node = @node.arguments.arguments.first
+  def name_arg_node
+    @node.arguments.arguments.first
+  end
+
+  def link_type
+    return @link_type if @link_type
+    
+    @link_type = case name_arg_node
+    when Prism::SymbolNode
+      :object_name
+    when Prism::StringNode
+      :file_path
+    else
+      nil
+    end
+  end
+
+  def file_path_type?
+    link_type == :file_path
+  end
 
+  def object_name_type?
+    link_type == :object_name
+  end
+
+  def parse_name
     case name_arg_node
     when Prism::SymbolNode
       name_arg_node.value

data/lib/ruby_lsp/ruby_lsp_ree/ree_formatter.rb

@@ -3,33 +3,31 @@ module RubyLsp
     class ReeFormatter
       include RubyLsp::Requests::Support::Formatter
       include RubyLsp::Ree::ReeLspUtils
-    
+
       def initialize
       end
-    
+
       def run_formatting(uri, document)
-        $stderr.puts("run_formating")
-    
         source = document.source
         sort_links(source)
       end
-    
+
       private
-    
+
       def sort_links(source)
         parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_source(source)
-        return source if parsed_doc.link_nodes.size == 0
-       
+        return source if !parsed_doc.link_nodes&.any?
+
         if parsed_doc.link_nodes.any?{ _1.location.start_line != _1.location.end_line }
           $stderr.puts("multiline link definitions, don't sort")
           return source
         end
-    
+
         # sort link nodes
         sorted_link_nodes = parsed_doc.link_nodes.sort{ |a, b|
           a_name = a.node.arguments.arguments.first
           b_name = b.node.arguments.arguments.first
-          
+
           if a_name.is_a?(Prism::SymbolNode) && !b_name.is_a?(Prism::SymbolNode)
             -1
           elsif b_name.is_a?(Prism::SymbolNode) && !a_name.is_a?(Prism::SymbolNode)
@@ -38,25 +36,25 @@ module RubyLsp
             a_name.unescaped <=> b_name.unescaped
           end
         }
-          
+
         # check if no re-order
         if parsed_doc.link_nodes.map{ _1.node.arguments.arguments.first.unescaped } == sorted_link_nodes.map{ _1.node.arguments.arguments.first.unescaped }
           return source
         end
-    
+
         # insert nodes to source
         link_lines = parsed_doc.link_nodes.map{ _1.location.start_line }
-    
+
         source_lines = source.lines
-    
+
         sorted_lines = sorted_link_nodes.map do |sorted_link|
           source_lines[sorted_link.location.start_line - 1]
         end
-    
+
         link_lines.each_with_index do |link_line, index|
           source_lines[link_line - 1] = sorted_lines[index]
         end
-    
+
         source_lines.join()
       end
     end

data/lib/ruby_lsp/ruby_lsp_ree/ree_indexing_enhancement.rb

@@ -6,7 +6,7 @@ module RubyLsp
     class ReeIndexingEnhancement < RubyIndexer::Enhancement
       include RubyLsp::Ree::ReeLspUtils
 
-      REE_INDEXED_OBJECTS = [:fn, :enum, :action, :dao]
+      REE_INDEXED_OBJECTS = [:fn, :enum, :action, :dao, :bean]
 
       def on_call_node_enter(node)
         return unless @listener.current_owner
@@ -39,11 +39,11 @@ module RubyLsp
         class_node = ast.statements.body.detect{ |node| node.is_a?(Prism::ClassNode) }
         return [] unless class_node
 
-        call_node = class_node.body.body.detect{ |node| node.name == :call }
+        call_node = class_node.body.body.detect{ |node| node.respond_to?(:name) && node.name == :call }
         return [] unless call_node
-        
+
         signature_params = signature_params_from_node(call_node.parameters)
-        
+
         [RubyIndexer::Entry::Signature.new(signature_params)]
       end
 

data/lib/ruby_lsp/ruby_lsp_ree/ree_lsp_utils.rb

@@ -3,16 +3,27 @@ module RubyLsp
     module ReeLspUtils
       Entry = RubyIndexer::Entry
 
+      def find_local_file_path(file_path)
+        file_name = file_path + ".rb"
+        Dir[File.join('**', file_name)].first
+      end
+
       def package_name_from_uri(uri)
         uri_parts = uri.to_s.split('/')
-        package_index = uri_parts.find_index('package') + 1
-        uri_parts[package_index]
+        
+        package_folder_index = uri_parts.find_index('package')
+        return unless package_folder_index
+
+        uri_parts[package_folder_index + 1]
       end
 
-      def path_from_package(uri)
+      def path_from_package_folder(uri)
         uri_parts = uri.chomp(File.extname(uri)).split('/')
-        pack_folder_index = uri_parts.index('package')
-        uri_parts.drop(pack_folder_index+1).join('/')
+
+        package_folder_index = uri_parts.index('package')
+        return unless package_folder_index
+
+        uri_parts.drop(package_folder_index+1).join('/')
       end
 
       def get_ree_type(ree_object)

data/lib/ruby_lsp/ruby_lsp_ree/ree_object_finder.rb

@@ -1,17 +1,20 @@
 module RubyLsp
   module Ree
     class ReeObjectFinder
-      MAX_LIMIT = 100
+      MAX_LIMIT = 1000
 
       REE_OBJECT_STRING = 'ree_object'
       ENUM_TYPE_STRING = 'type: :enum'
       DAO_TYPE_STRING = 'type: :dao'
+      BEAN_TYPE_STRING = 'type: :bean'
 
       def self.search_objects(index, name, limit)
         index.prefix_search(name)
-          .take(MAX_LIMIT).map(&:first)
+          .take(MAX_LIMIT)
+          .flatten
           .select{ _1.comments }
           .select{ _1.comments.to_s.lines.first&.chomp == REE_OBJECT_STRING }
+          .sort_by{ _1.name.length }
           .take(limit)
       end
 
@@ -28,6 +31,13 @@ module RubyLsp
 
         objects_by_name.detect{ _1.comments.lines[1]&.chomp == DAO_TYPE_STRING }
       end
+
+      def self.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
     end
   end
 end

data/lib/ruby_lsp_ree/version.rb

@@ -3,7 +3,7 @@
 module Ruby
   module Lsp
     module Ree
-      VERSION = "0.1.1"
+      VERSION = "0.1.2"
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-ree
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-02-10 00:00:00.000000000 Z
+date: 2025-02-14 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby LSP addon that adds extra editor functionality for Ree applications
 email: