ruby-lsp-ree 0.1.1 → 0.1.3

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

@@ -5,19 +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
+  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
-  end
-
-  def links_container_block_node
-    @fn_block_node || @action_block_node || @dao_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?
@@ -32,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)
@@ -48,21 +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 }
+    @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
@@ -81,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
@@ -113,13 +148,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,10 @@ 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_mapper_node
+    document.parse_aggregate_node
     document.parse_class_includes
     document.parse_links
 
@@ -57,5 +71,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

@@ -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
@@ -30,9 +35,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

@@ -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]
+      REE_INDEXED_OBJECTS = [:fn, :enum, :action, :dao, :bean, :mapper, :aggregate]
 
       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_object_finder.rb

@@ -1,33 +1,92 @@
 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'
+      MAPPER_TYPE_STRING = 'type: :mapper'
+      AGGREGATE_TYPE_STRING = 'type: :aggregate'
 
-      def self.search_objects(index, name, limit)
-        index.prefix_search(name)
-          .take(MAX_LIMIT).map(&:first)
+      def initialize(index)
+        @index = index
+      end
+
+      def search_objects(name, limit)
+        @index.prefix_search(name)
+          .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
 
-      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 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}

@@ -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)
-        uri_parts = uri.chomp(File.extname(uri)).split('/')
-        pack_folder_index = uri_parts.index('package')
-        uri_parts.drop(pack_folder_index+1).join('/')
+      def path_from_package_folder(uri)
+        uri_parts = uri.to_s.chomp(File.extname(uri)).split('/')
+
+        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)
@@ -38,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.1"
-    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.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-02-10 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,90 +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 = 3
-      CANDIDATES_LIMIT = 20
-      
-      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_uri(@uri)
-
-        completion_items = get_class_name_completion_items(class_name_objects, parsed_doc, node, @index, CANDIDATES_LIMIT)
-        puts_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
-
-        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)
-
-        completion_items = get_ree_objects_completions_items(ree_objects, parsed_doc, node)
-        puts_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 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)
-      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)
-        puts_items_into_response(completion_items)
-      end
-
-      def puts_items_into_response(items)
-        items.each do |item|
-          @response_builder << item
-        end
-      end
-    end
-  end
-end