ruby-lsp-ree 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 925a5297663b9b4e653e9c837cd6bfc8942c5445f657619f867699b33e765809
-  data.tar.gz: 3d3d73751c5c60d3b55ab426b896dcfcc633c921ab0b33ca7ba1aea4b1ae04dd
+  metadata.gz: 350bb1ae1a376f2a8594e3945c396c49d01907b1c840d36311e28761c2fe9d8e
+  data.tar.gz: dfa9bc947cf5f951d62e2686290a7ac603c5dfa34652cb21be4b1547d2e3b5e1
 SHA512:
-  metadata.gz: 46a0c311c26ffe7bea0bc546476cf92a7b45f620b1d38c261be5c409b4c75b0249bfea393bc532166b461d2373491f1093bd1be3afa44b1dd2530ae67f8cf77f
-  data.tar.gz: e150468d50597f9be7988891972bd708710ecc2991dadb512c36bada2bcbf4f619873435744a4b7f0b95f6eda7dc180d8e4edeec9c487de4e5084be99c59c0b8
+  metadata.gz: eaaa38d222082eb2a55f73a977114a2632d2db2a2b7d10a0d96d2284b87fbd2c02bcab43e45ec617afa63e5c9fd4f9e64339f7cb919ba23365a5deae1aa3df4e
+  data.tar.gz: 64e7ce28fdb802eadbe27c6f7fd5d5e156c9c3d39627c9a7e191bf808fc9519eb26befa49182cc62bda12941c8e6fd4f478060ec61e33d38035aa10726c087d1

data/CHANGELOG.md

@@ -3,3 +3,20 @@
 ## [0.1.0] - 2025-01-31
 
 - Initial release
+
+## [0.1.1] - 2025-02-10
+
+- sort links for objects with FnDSL
+- autocomplete for objects with FnDSL
+- Add Link for objects with FnDSL
+- improve params in autocomplete
+- Go To Definition for symbols in link section
+- autocomplete for enums
+- autocomplete for enum values
+- Add Link for enums
+- Go To Definition for enums
+- autocomplete for ree actions
+- Add Link for ree actions
+- sort links in ree actions
+- autocomplete for ree dao
+- autocomplete for dao filters

data/Gemfile.lock

@@ -0,0 +1,19 @@
+PATH
+  remote: .
+  specs:
+    ruby-lsp-ree (0.1.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (13.2.1)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  rake (~> 13.0)
+  ruby-lsp-ree!
+
+BUNDLED WITH
+   2.4.20

data/lib/ruby_lsp/ruby_lsp_ree/addon.rb

@@ -4,6 +4,7 @@ require_relative "completion"
 require_relative "ree_indexing_enhancement"
 require_relative "ree_lsp_utils"
 require_relative "ree_formatter"
+require_relative "parsing/parsed_document_builder"
 
 module RubyLsp
   module Ree
@@ -23,10 +24,8 @@ module RubyLsp
       end
 
       def create_definition_listener(response_builder, uri, node_context, dispatcher)
-        $stderr.puts("create_definition_listener")
-
         index = @global_state.index
-        RubyLsp::Ree::Definition.new(response_builder, node_context, index, dispatcher)
+        RubyLsp::Ree::Definition.new(response_builder, node_context, index, dispatcher, uri)
       end
 
       def create_completion_listener(response_builder, node_context, dispatcher, uri)

data/lib/ruby_lsp/ruby_lsp_ree/completion.rb

@@ -1,17 +1,22 @@
 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 = 4
+      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)
@@ -24,142 +29,62 @@ 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
 
-        doc_info = parse_document_from_uri(@uri)
-
-        class_name_objects.take(15).each 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)
-
-          label_details = Interface::CompletionItemLabelDetails.new(
-            description: "from: :#{package_name}",
-            detail: ""
-          )
-
-          @response_builder << 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(doc_info, class_name, package_name, entry)
-          )
-        end
+        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_uri(@uri)
 
-        nil
+        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)
-        return if node.receiver
-        return if node.name.to_s.size < CHARS_COUNT
-
-        ree_objects = @index.prefix_search(node.name.to_s)
-          .take(50).map(&:first)
-          .select{ _1.comments }
-          .select{ _1.comments.to_s.lines.first&.chomp == 'ree_object' }
-          .take(10)
-
-        return if ree_objects.size == 0
-
-        doc_info = parse_document_from_uri(@uri)
-
-        ree_objects.each do |ree_object|
-          fn_name = ree_object.name
-
-          package_name = package_name_from_uri(ree_object.uri)
-
-          params_str = ree_object.signatures.first.parameters.map(&:name).join(', ')
-
-          label_details = Interface::CompletionItemLabelDetails.new(
-            description: "from: :#{package_name}",
-            detail: "(#{params_str})"
-          )
-
-          $stderr.puts("ree object #{ree_object.inspect}")
-
-          @response_builder << Interface::CompletionItem.new(
-            label: fn_name,
-            label_details: label_details,
-            filter_text: fn_name,
-            text_edit: Interface::TextEdit.new(
-              range:  range_from_location(node.location),
-              new_text: "#{fn_name}(#{params_str})",
-            ),
-            kind: Constant::CompletionItemKind::METHOD,
-            data: {
-              owner_name: "Object",
-              guessed_type: false,
-            },
-            additional_text_edits: get_additional_text_edits_for_method(doc_info, fn_name, package_name)
-          )
+        if receiver_is_enum?(node)
+          return enum_value_completion(node)
         end
-        
-        nil
-      end
 
-      def get_additional_text_edits_for_constant(doc_info, class_name, package_name, entry)
-        if doc_info.linked_objects.map(&:imports).flatten.include?(class_name)
-          $stderr.puts("links already include #{class_name}")
-          return []
+        if receiver_is_dao?(node)
+          return dao_filter_completion(node)
         end
 
-        entry_uri = entry.uri.to_s
-
-        link_text = if doc_info.package_name == package_name
-          fn_name = File.basename(entry_uri, ".*")
-          "\n\s\s\s\slink :#{fn_name}, import: -> { #{class_name} }"
-        else
-          path = path_from_package(entry_uri)
-          "\n\s\s\s\slink \"#{path}\", import: -> { #{class_name} }"
-        end
+        return if node.receiver
+        return if node.name.to_s.size < CHARS_COUNT
 
-        new_text = link_text
+        ree_objects = ReeObjectFinder.search_objects(@index, node.name.to_s, CANDIDATES_LIMIT)
+        return if ree_objects.size == 0
 
-        unless doc_info.block_node
-          new_text = "\sdo#{link_text}\n\s\send\n"
-        end
+        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_uri(@uri)
 
-        range = get_range_for_fn_insert(doc_info, link_text)
+        completion_items = get_ree_objects_completions_items(ree_objects, parsed_doc, node)
+        puts_items_into_response(completion_items)
+      end
 
-        [
-          Interface::TextEdit.new(
-            range:    range,
-            new_text: new_text,
-          )
-        ]
+      def receiver_is_enum?(node)
+        node.receiver && node.receiver.is_a?(Prism::CallNode) && ReeObjectFinder.find_enum(@index, node.receiver.name.to_s)
       end
 
-      def get_additional_text_edits_for_method(doc_info, fn_name, package_name)
-        if doc_info.linked_objects.map(&:name).include?(fn_name)
-          $stderr.puts("links already include #{fn_name}")
-          return []
-        end
+      def receiver_is_dao?(node)
+        node.receiver && node.receiver.is_a?(Prism::CallNode) && ReeObjectFinder.find_dao(@index, node.receiver.name.to_s)
+      end
 
-        link_text = if doc_info.package_name == package_name
-          "\n\s\s\s\slink :#{fn_name}"
-        else
-          "\n\s\s\s\slink :#{fn_name}, from: :#{package_name}"
-        end
+      def enum_value_completion(node)
+        enum_obj = ReeObjectFinder.find_enum(@index, node.receiver.name.to_s)
+        location = node.receiver.location
         
-        new_text = link_text
+        completion_items = get_enum_values_completion_items(enum_obj, location)
+        puts_items_into_response(completion_items)
+      end
 
-        unless doc_info.block_node
-          new_text = "\sdo#{link_text}\n\s\send\n"
-        end
+      def dao_filter_completion(node)
+        dao_obj = ReeObjectFinder.find_dao(@index, node.receiver.name.to_s)
+        location = node.receiver.location
 
-        range = get_range_for_fn_insert(doc_info, link_text)
+        completion_items = get_dao_filters_completion_items(dao_obj, location)
+        puts_items_into_response(completion_items)
+      end
 
-        [
-          Interface::TextEdit.new(
-            range:    range,
-            new_text: new_text,
-          )
-        ]
+      def puts_items_into_response(items)
+        items.each do |item|
+          @response_builder << item
+        end
       end
     end
   end
-end
+end

data/lib/ruby_lsp/ruby_lsp_ree/completion_utils.rb

@@ -0,0 +1,234 @@
+require_relative "ree_lsp_utils"
+
+module RubyLsp
+  module Ree
+    module CompletionUtils
+      include Requests::Support::Common
+      include RubyLsp::Ree::ReeLspUtils
+
+      def get_dao_filters_completion_items(dao_obj, location)
+        dao_node = RubyLsp::Ree::ParsedDocumentBuilder.build_from_uri(dao_obj.uri, :dao)
+        
+        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),
+        )
+
+        dao_node.filters.map do |filter|
+          signature = filter.signatures.first
+
+          label_details = Interface::CompletionItemLabelDetails.new(
+            description: "filter",
+            detail: get_detail_string(signature)
+          )
+
+          Interface::CompletionItem.new(
+            label: filter.name,
+            label_details: label_details,
+            filter_text: filter.name,
+            text_edit: Interface::TextEdit.new(
+              range:  range,
+              new_text: get_method_string(filter.name, signature)
+            ),
+            kind: Constant::CompletionItemKind::METHOD,
+            insert_text_format: Constant::InsertTextFormat::SNIPPET,
+            data: {
+              owner_name: "Object",
+              guessed_type: false,
+            }
+          )
+        end
+      end
+
+      def get_enum_values_completion_items(enum_obj, location)
+        enum_node = RubyLsp::Ree::ParsedDocumentBuilder.build_from_uri(enum_obj.uri, :enum)
+
+        class_name = enum_node.get_class_name
+
+        label_details = Interface::CompletionItemLabelDetails.new(
+          description: "from: #{class_name}",
+          detail: ''
+        )
+
+        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),
+        )
+
+        enum_node.values.map do |val|
+          Interface::CompletionItem.new(
+            label: val.name,
+            label_details: label_details,
+            filter_text: val.name,
+            text_edit: Interface::TextEdit.new(
+              range:  range,
+              new_text: val.name
+            ),
+            kind: Constant::CompletionItemKind::METHOD,
+            data: {
+              owner_name: "Object",
+              guessed_type: false,
+            }
+          )
+        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)
+
+          label_details = Interface::CompletionItemLabelDetails.new(
+            description: "from: :#{package_name}",
+            detail: ""
+          )
+
+          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
+
+      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)
+          signature = ree_object.signatures.first
+          ree_type = get_ree_type(ree_object)
+
+          label_details = Interface::CompletionItemLabelDetails.new(
+            description: "#{ree_type}, from: :#{package_name}",
+            detail: get_detail_string(signature)
+          )
+
+          Interface::CompletionItem.new(
+            label: ree_object_name,
+            label_details: label_details,
+            filter_text: ree_object_name,
+            text_edit: Interface::TextEdit.new(
+              range:  range_from_location(node.location),
+              new_text: get_method_string(ree_object_name, signature)
+            ),
+            kind: Constant::CompletionItemKind::METHOD,
+            insert_text_format: Constant::InsertTextFormat::SNIPPET,
+            data: {
+              owner_name: "Object",
+              guessed_type: false,
+            },
+            additional_text_edits: get_additional_text_edits_for_method(parsed_doc, ree_object_name, package_name)
+          )
+        end
+      end
+
+      def get_detail_string(signature)
+        return '' unless signature
+
+        "(#{get_parameters_string(signature)})"
+      end
+
+      def get_parameters_string(signature)
+        return '' unless signature
+
+        signature.parameters.map(&:decorated_name).join(', ')
+      end
+
+      def get_method_string(fn_name, signature)
+        return fn_name unless signature
+        
+        "#{fn_name}(#{get_parameters_placeholder(signature)})"
+      end
+
+      def get_parameters_placeholder(signature)
+        return '' unless signature
+
+        signature.parameters.to_enum.with_index.map do |signature_param, index|
+          case signature_param          
+          when RubyIndexer::Entry::KeywordParameter, RubyIndexer::Entry::OptionalKeywordParameter
+            "#{signature_param.name}: ${#{index+1}:#{signature_param.name}}"
+          else
+            "${#{index+1}:#{signature_param.name}}"
+          end
+        end.join(', ')
+      end
+
+      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
+
+        entry_uri = entry.uri.to_s
+
+        link_text = if parsed_doc.package_name == package_name
+          fn_name = File.basename(entry_uri, ".*")
+          "\s\slink :#{fn_name}, import: -> { #{class_name} }"
+        else
+          path = path_from_package(entry_uri)
+          "\s\slink \"#{path}\", import: -> { #{class_name} }"
+        end
+
+        if parsed_doc.links_container_node
+          link_text = "\s\s" + link_text
+        end
+        
+        new_text = "\n" + link_text
+
+
+        if parsed_doc.has_blank_links_container?
+          new_text = "\sdo#{link_text}\n\s\send\n"
+        end
+
+        range = get_range_for_fn_insert(parsed_doc, link_text)
+
+        [
+          Interface::TextEdit.new(
+            range:    range,
+            new_text: new_text,
+          )
+        ]
+      end
+
+      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
+
+        link_text = if parsed_doc.package_name == package_name
+          "\s\slink :#{fn_name}"
+        else
+          "\s\slink :#{fn_name}, from: :#{package_name}"
+        end
+
+        if parsed_doc.links_container_node
+          link_text = "\s\s" + link_text
+        end
+        
+        new_text = "\n" + link_text
+
+        if parsed_doc.has_blank_links_container?
+          new_text = "\sdo#{link_text}\n\s\send\n"
+        end
+
+        range = get_range_for_fn_insert(parsed_doc, link_text)
+
+        [
+          Interface::TextEdit.new(
+            range:    range,
+            new_text: new_text,
+          )
+        ]
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_ree/definition.rb

@@ -1,16 +1,20 @@
+require_relative "ree_lsp_utils"
+require_relative "parsing/parsed_link_node"
+
 module RubyLsp
   module Ree
     class Definition
       include Requests::Support::Common
+      include RubyLsp::Ree::ReeLspUtils
 
-      def initialize(response_builder, node_context, index, dispatcher)
+      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)
-        dispatcher.register(self, :on_call_node_enter)
+        dispatcher.register(self, :on_call_node_enter, :on_symbol_node_enter, :on_string_node_enter)
       end
 
       def on_call_node_enter(node)
@@ -33,6 +37,47 @@ module RubyLsp
 
         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)
+        file_name = node.unescaped + ".rb"
+        local_path = Dir[File.join('**', file_name)].first
+
+        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/parsing/parsed_document.rb

@@ -0,0 +1,130 @@
+require_relative 'parsed_link_node'
+
+class RubyLsp::Ree::ParsedDocument
+  include RubyLsp::Ree::ReeLspUtils
+
+  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
+
+  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
+  end
+
+  def includes_link_dsl?
+    @class_includes.any?{ _1.name == LINK_DSL_MODULE }
+  end
+
+  def includes_linked_constant?(const_name)
+    @link_nodes.map(&:imports).flatten.include?(const_name)
+  end
+
+  def includes_linked_object?(obj_name)
+    @link_nodes.map(&:name).include?(obj_name)
+  end
+
+  def has_blank_links_container?
+    links_container_node && !links_container_block_node
+  end
+
+  def set_package_name(package_name)
+    @package_name = package_name
+  end
+
+  def parse_class_node
+    @class_node ||= ast.statements.body.detect{ |node| node.is_a?(Prism::ClassNode) }
+  end
+
+  def parse_fn_node
+    return unless class_node
+
+    @fn_node ||= class_node.body.body.detect{ |node| node.name == :fn }
+    @fn_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
+  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
+  end
+
+  def parse_class_includes
+    return unless class_node
+
+    @class_includes ||= class_node.body.body.select{ _1.name == :include }.map do |class_include|
+      parent_name = class_include.arguments.arguments.first.parent.name.to_s
+      module_name = class_include.arguments.arguments.first.name
+    
+      OpenStruct.new(
+        name: [parent_name, module_name].compact.join('::')
+      )          
+    end
+  end
+
+  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 }
+    elsif class_includes.any?{ _1.name == LINK_DSL_MODULE }
+      class_node.body.body.select{ |node| node.name == :link }
+    else
+      []
+    end
+
+    @link_nodes = nodes.map do |link_node|
+      link_node = RubyLsp::Ree::ParsedLinkNode.new(link_node, package_name)
+      link_node.parse_imports
+      link_node
+    end
+  end
+
+  def parse_values
+    return unless class_node
+    
+    @values ||= class_node.body.body
+      .select{ _1.name == :val }
+      .map{ OpenStruct.new(name: _1.arguments.arguments.first.unescaped) }
+  end
+
+  def parse_filters
+    return unless class_node
+    
+    @filters ||= class_node.body.body
+      .select{ _1.name == :filter }
+      .map{ OpenStruct.new(name: _1.arguments.arguments.first.unescaped, signatures: parse_filter_signature(_1)) }
+
+  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)
+    [RubyIndexer::Entry::Signature.new(signature_params)]
+  end
+
+  def get_class_name
+    name_parts = [class_node.constant_path&.parent&.name, class_node.constant_path.name]
+    name_parts.compact.map(&:to_s).join('::')
+  end
+end

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

@@ -0,0 +1,61 @@
+require 'prism'
+require_relative 'parsed_document'
+
+class RubyLsp::Ree::ParsedDocumentBuilder
+  extend RubyLsp::Ree::ReeLspUtils
+
+  def self.build_from_uri(uri, type = nil)
+    ast = Prism.parse_file(uri.path).value
+    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)
+  end
+
+  def self.build_document(ast, type)
+    case type
+    when :enum
+      build_enum_document(ast)
+    when :dao
+      build_dao_document(ast)
+    else
+      build_regular_document(ast)
+    end
+  end
+
+  def self.build_regular_document(ast)
+    document = RubyLsp::Ree::ParsedDocument.new(ast)
+    
+    document.parse_class_node
+    document.parse_fn_node
+    document.parse_action_node
+    document.parse_class_includes
+    document.parse_links
+
+    document
+  end   
+
+  def self.build_enum_document(ast)
+    document = RubyLsp::Ree::ParsedDocument.new(ast)
+    
+    document.parse_class_node
+    document.parse_values
+
+    document
+  end   
+
+  def self.build_dao_document(ast)
+    document = RubyLsp::Ree::ParsedDocument.new(ast)
+    
+    document.parse_class_node
+    document.parse_filters
+
+    document
+  end   
+end

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

@@ -0,0 +1,71 @@
+require 'prism'
+
+class RubyLsp::Ree::ParsedLinkNode
+  attr_reader :node, :document_package, :name, :imports
+
+  FROM_ARG_KEY = 'from'
+  IMPORT_ARG_KEY = 'import'
+
+  def initialize(node, document_package = nil)
+    @node = node
+    @document_package = document_package
+    @name = parse_name
+  end
+
+  def link_package_name
+    from_arg_value || document_package
+  end
+
+  def location
+    @node.location
+  end
+
+  def from_arg_value
+    @kw_args ||= @node.arguments.arguments.detect{ |arg| arg.is_a?(Prism::KeywordHashNode) }
+    return unless @kw_args
+
+    @from_param ||= @kw_args.elements.detect{ _1.key.unescaped == FROM_ARG_KEY }
+    return unless @from_param
+
+    @from_param.value.unescaped
+  end
+
+  def parse_name
+    name_arg_node = @node.arguments.arguments.first
+
+    case name_arg_node
+    when Prism::SymbolNode
+      name_arg_node.value
+    when Prism::StringNode
+      name_arg_node.unescaped
+    else
+      ""
+    end
+  end
+
+  def parse_imports
+    @imports ||= get_imports
+  end
+
+  private
+
+  def get_imports
+    return [] if @node.arguments.arguments.size == 1
+    
+    last_arg = @node.arguments.arguments.last
+
+    if last_arg.is_a?(Prism::KeywordHashNode)
+      import_arg = last_arg.elements.detect{ _1.key.unescaped == IMPORT_ARG_KEY }
+      return [] unless import_arg
+
+      [import_arg.value.body.body.first.name.to_s]
+    elsif last_arg.is_a?(Prism::LambdaNode)
+      [last_arg.body.body.first.name.to_s]
+    else
+      return []
+    end
+  rescue => e
+    $stderr.puts("can't parse imports: #{e.message}")
+    return []
+  end
+end

data/lib/ruby_lsp/ruby_lsp_ree/ree_formatter.rb

@@ -17,25 +17,18 @@ module RubyLsp
       private
     
       def sort_links(source)
-        doc_info = parse_document_from_source(source)
-      
-        return source unless doc_info.fn_node
-        return source if doc_info.fn_node && !doc_info.block_node
-        
-        if doc_info.link_nodes.size < doc_info.block_node.body.body.size
-          $stderr.puts("block contains not only link, don't sort")
-          return source
-        end
-    
-        if doc_info.link_nodes.any?{ _1.location.start_line != _1.location.end_line }
+        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_source(source)
+        return source if parsed_doc.link_nodes.size == 0
+       
+        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 = doc_info.link_nodes.sort{ |a, b|
-          a_name = a.arguments.arguments.first
-          b_name = b.arguments.arguments.first
+        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
@@ -47,12 +40,12 @@ module RubyLsp
         }
           
         # check if no re-order
-        if doc_info.link_nodes.map{ _1.arguments.arguments.first.unescaped } == sorted_link_nodes.map{ _1.arguments.arguments.first.unescaped }
+        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 = doc_info.link_nodes.map{ _1.location.start_line }
+        link_lines = parsed_doc.link_nodes.map{ _1.location.start_line }
     
         source_lines = source.lines
     

data/lib/ruby_lsp/ruby_lsp_ree/ree_indexing_enhancement.rb

@@ -1,42 +1,37 @@
+require 'prism'
+require_relative "ree_lsp_utils"
+
 module RubyLsp
   module Ree
     class ReeIndexingEnhancement < RubyIndexer::Enhancement
+      include RubyLsp::Ree::ReeLspUtils
+
+      REE_INDEXED_OBJECTS = [:fn, :enum, :action, :dao]
+
       def on_call_node_enter(node)
         return unless @listener.current_owner
 
-        # Return early unless the method call is the one we want to handle
-        return unless node.name == :fn
+        return unless REE_INDEXED_OBJECTS.include?(node.name)
         return unless node.arguments
+        return unless node.arguments.child_nodes.first.is_a?(Prism::SymbolNode)
+
+        obj_name = node.arguments.child_nodes.first.unescaped
+        return unless current_filename == obj_name
 
-        # index = @listener.instance_variable_get(:@index)
-        
         location = node.location
-        fn_name = node.arguments.child_nodes.first.unescaped
-        signatures = parse_signatures(fn_name)
-        comments = "ree_object\nsome_documentation"
-      
-        # visibility = RubyIndexer::Entry::Visibility::PUBLIC
-        # owner = index['Object'].first
-
-        # index.add(RubyIndexer::Entry::Method.new(
-        #   fn_name,
-        #   @listener.instance_variable_get(:@uri),
-        #   location,
-        #   location,
-        #   comments,
-        #   signatures,
-        #   visibility,
-        #   owner,
-        # ))
+        signatures = parse_signatures(obj_name)
+        comments = "ree_object\ntype: :#{node.name}"
 
         @listener.add_method(
-          fn_name,
+          obj_name,
           location, 
           signatures,
           comments: comments
         )
       end
 
+      private
+
       def parse_signatures(fn_name)
         uri = @listener.instance_variable_get(:@uri)
         ast = Prism.parse_file(uri.path).value
@@ -47,10 +42,15 @@ module RubyLsp
         call_node = class_node.body.body.detect{ |node| node.name == :call }
         return [] unless call_node
         
-        signature_params = @listener.send(:list_params, call_node.parameters)
-
+        signature_params = signature_params_from_node(call_node.parameters)
+        
         [RubyIndexer::Entry::Signature.new(signature_params)]
       end
+
+      def current_filename
+        uri = @listener.instance_variable_get(:@uri)
+        File.basename(uri.path, '.rb')  
+      end
     end
   end
 end

data/lib/ruby_lsp/ruby_lsp_ree/ree_lsp_utils.rb

@@ -1,6 +1,8 @@
 module RubyLsp
   module Ree
     module ReeLspUtils
+      Entry = RubyIndexer::Entry
+
       def package_name_from_uri(uri)
         uri_parts = uri.to_s.split('/')
         package_index = uri_parts.find_index('package') + 1
@@ -13,66 +15,29 @@ module RubyLsp
         uri_parts.drop(pack_folder_index+1).join('/')
       end
 
-      def parse_document_from_uri(uri)
-        ast = Prism.parse_file(uri.path).value
-        result = parse_document(ast)
-
-        result.package_name = package_name_from_uri(uri)
-
-        result
-      end
+      def get_ree_type(ree_object)
+        type_comment = ree_object.comments.to_s.lines[1]
+        return unless type_comment
 
-      def parse_document_from_source(source)
-        ast = Prism.parse(source).value
-        parse_document(ast)
+        type_comment.split(' ').last
       end
 
-      def parse_document(ast)
-        class_node = ast.statements.body.detect{ |node| node.is_a?(Prism::ClassNode) }
-        fn_node = class_node.body.body.detect{ |node| node.name == :fn }
-        block_node = fn_node.block
-
-        link_nodes = if block_node && block_node.body
-          block_node.body.body.select{ |node| node.name == :link }
-        else
-          []
-        end
+      def get_range_for_fn_insert(parsed_doc, link_text)
+        fn_line = nil
+        position = nil
 
-        linked_objects = link_nodes.map do |link_node|
-          name_arg_node = link_node.arguments.arguments.first
+        if parsed_doc.links_container_node
+          links_container_node = parsed_doc.links_container_node
+          fn_line = links_container_node.location.start_line
 
-          name_val = case name_arg_node
-          when Prism::SymbolNode
-            name_arg_node.value
-          when Prism::StringNode
-            name_arg_node.unescaped
+          position = if parsed_doc.links_container_block_node
+            parsed_doc.links_container_block_node.opening_loc.end_column + 1
           else
-            ""
+            links_container_node.arguments.location.end_column + 1
           end
-
-          OpenStruct.new(
-            name: name_val,
-            imports: parse_link_node_imports(link_node)
-          )
-        end
-
-        return OpenStruct.new(
-          ast: ast,
-          class_node: class_node,
-          fn_node: fn_node,
-          block_node: block_node,
-          link_nodes: link_nodes,
-          linked_objects: linked_objects
-        )
-      end   
-
-      def get_range_for_fn_insert(doc_info, link_text)
-        fn_line = doc_info.fn_node.location.start_line
-
-        position = if doc_info.block_node
-          doc_info.block_node.opening_loc.end_column + 1
-        else
-          doc_info.fn_node.arguments.location.end_column + 1
+        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
         end
 
         Interface::Range.new(
@@ -81,24 +46,94 @@ module RubyLsp
         )
       end
 
-      def parse_link_node_imports(node)
-        return [] if node.arguments.arguments.size == 1
-        
-        last_arg = node.arguments.arguments.last
 
-        if last_arg.is_a?(Prism::KeywordHashNode)
-          import_arg = last_arg.elements.detect{ _1.key.unescaped == 'import' }
-          return [] unless import_arg
+      # params(parameters_node: Prism::ParametersNode).returns(Array[Entry::Parameter])
+      # copied from ruby-lsp DeclarationListener#list_params
+      def signature_params_from_node(parameters_node)
+        return [] unless parameters_node
+  
+        parameters = []
+  
+        parameters_node.requireds.each do |required|
+          name = parameter_name(required)
+          next unless name
+  
+          parameters << Entry::RequiredParameter.new(name: name)
+        end
+  
+        parameters_node.optionals.each do |optional|
+          name = parameter_name(optional)
+          next unless name
+  
+          parameters << Entry::OptionalParameter.new(name: name)
+        end
+  
+        rest = parameters_node.rest
+  
+        if rest.is_a?(Prism::RestParameterNode)
+          rest_name = rest.name || Entry::RestParameter::DEFAULT_NAME
+          parameters << Entry::RestParameter.new(name: rest_name)
+        end
+  
+        parameters_node.keywords.each do |keyword|
+          name = parameter_name(keyword)
+          next unless name
+  
+          case keyword
+          when Prism::RequiredKeywordParameterNode
+            parameters << Entry::KeywordParameter.new(name: name)
+          when Prism::OptionalKeywordParameterNode
+            parameters << Entry::OptionalKeywordParameter.new(name: name)
+          end
+        end
+  
+        keyword_rest = parameters_node.keyword_rest
+  
+        case keyword_rest
+        when Prism::KeywordRestParameterNode
+          keyword_rest_name = parameter_name(keyword_rest) || Entry::KeywordRestParameter::DEFAULT_NAME
+          parameters << Entry::KeywordRestParameter.new(name: keyword_rest_name)
+        when Prism::ForwardingParameterNode
+          parameters << Entry::ForwardingParameter.new
+        end
+  
+        parameters_node.posts.each do |post|
+          name = parameter_name(post)
+          next unless name
+  
+          parameters << Entry::RequiredParameter.new(name: name)
+        end
+  
+        block = parameters_node.block
+        parameters << Entry::BlockParameter.new(name: block.name || Entry::BlockParameter::DEFAULT_NAME) if block
+  
+        parameters
+      end
+
+      # params(node: Prism::Node).returns(Symbol)
+      # copied from ruby-lsp DeclarationListener#parameter_name
+      def parameter_name(node)
+        case node
+        when Prism::RequiredParameterNode, Prism::OptionalParameterNode,
+          Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode,
+          Prism::RestParameterNode, Prism::KeywordRestParameterNode
+          node.name
+        when Prism::MultiTargetNode
+          names = node.lefts.map { |parameter_node| parameter_name(parameter_node) }
+
+          rest = node.rest
+          if rest.is_a?(Prism::SplatNode)
+            name = rest.expression&.slice
+            names << (rest.operator == "*" ? "*#{name}".to_sym : name&.to_sym)
+          end
+
+          names << nil if rest.is_a?(Prism::ImplicitRestNode)
+
+          names.concat(node.rights.map { |parameter_node| parameter_name(parameter_node) })
 
-          [import_arg.value.body.body.first.name.to_s]
-        elsif last_arg.is_a?(Prism::LambdaNode)
-          [last_arg.body.body.first.name.to_s]
-        else
-          return []
+          names_with_commas = names.join(", ")
+          :"(#{names_with_commas})"
         end
-      rescue => e
-        $stderr.puts("can't parse imports: #{e.message}")
-        return []
       end
     end
   end

data/lib/ruby_lsp/ruby_lsp_ree/ree_object_finder.rb

@@ -0,0 +1,33 @@
+module RubyLsp
+  module Ree
+    class ReeObjectFinder
+      MAX_LIMIT = 100
+
+      REE_OBJECT_STRING = 'ree_object'
+      ENUM_TYPE_STRING = 'type: :enum'
+      DAO_TYPE_STRING = 'type: :dao'
+
+      def self.search_objects(index, name, limit)
+        index.prefix_search(name)
+          .take(MAX_LIMIT).map(&:first)
+          .select{ _1.comments }
+          .select{ _1.comments.to_s.lines.first&.chomp == REE_OBJECT_STRING }
+          .take(limit)
+      end
+
+      def self.find_enum(index, 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]
+        return unless objects_by_name
+
+        objects_by_name.detect{ _1.comments.lines[1]&.chomp == DAO_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.0"
+      VERSION = "0.1.1"
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-ree
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-01-31 00:00:00.000000000 Z
+date: 2025-02-10 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby LSP addon that adds extra editor functionality for Ree applications
 email:
@@ -20,15 +20,21 @@ files:
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - 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/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_ree.rb
 - lib/ruby_lsp_ree/version.rb
 - ruby-lsp-ree.gemspec