ruby-lsp-ree 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 925a5297663b9b4e653e9c837cd6bfc8942c5445f657619f867699b33e765809
-  data.tar.gz: 3d3d73751c5c60d3b55ab426b896dcfcc633c921ab0b33ca7ba1aea4b1ae04dd
+  metadata.gz: a1104f2c78afb874d9277a4e2d1c8b5adaf925bdb4fb9abb23b08a9e5a27aff9
+  data.tar.gz: 061f2b31a9aac045d279797b7561597db1825e396547b5afd94d6bfc4015af1e
 SHA512:
-  metadata.gz: 46a0c311c26ffe7bea0bc546476cf92a7b45f620b1d38c261be5c409b4c75b0249bfea393bc532166b461d2373491f1093bd1be3afa44b1dd2530ae67f8cf77f
-  data.tar.gz: e150468d50597f9be7988891972bd708710ecc2991dadb512c36bada2bcbf4f619873435744a4b7f0b95f6eda7dc180d8e4edeec9c487de4e5084be99c59c0b8
+  metadata.gz: 7f29b69bb720eadc44261c63719ca950cec24db996d0d4d83117c20c3a145bb6be8934420acb850ba92841feefe4985f0e0c1caa7129cd50a41a4419f3a2ca1e
+  data.tar.gz: fea1f33dd0bcdfe401afe15304797fca57c254cf8472b34a8ef40d7f011d2bb60edb1010177129671fcbfc0f7ca69b212832c2c70ef8b8f125025a20be0ca17a

data/CHANGELOG.md

@@ -3,3 +3,30 @@
 ## [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
+
+## [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

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

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,15 +24,11 @@ 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)
-        $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

@@ -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 = 1
+      CANDIDATES_LIMIT = 100
       
       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,80 @@ 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_ast(@node_context.parent, @uri)
 
-        nil
+        completion_items = get_class_name_completion_items(class_name_objects, parsed_doc, node, @index, CANDIDATES_LIMIT)
+        put_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
+
+        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 = @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)
+        ree_objects = ReeObjectFinder.search_objects(@index, node.name.to_s, CANDIDATES_LIMIT)
 
         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)
-          )
-        end
-        
-        nil
-      end
+        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_ast(@node_context.parent, @uri)
 
-      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 []
-        end
+        completion_items = get_ree_objects_completions_items(ree_objects, parsed_doc, node)
+        put_items_into_response(completion_items)
+      end
 
-        entry_uri = entry.uri.to_s
+      def receiver_is_enum?(node)
+        node.receiver && node.receiver.is_a?(Prism::CallNode) && ReeObjectFinder.find_enum(@index, node.receiver.name.to_s)
+      end
 
-        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
+      def receiver_is_dao?(node)
+        node.receiver && node.receiver.is_a?(Prism::CallNode) && ReeObjectFinder.find_dao(@index, node.receiver.name.to_s)
+      end
 
-        new_text = link_text
+      def receiver_is_bean?(node)
+        node.receiver && node.receiver.is_a?(Prism::CallNode) && ReeObjectFinder.find_bean(@index, node.receiver.name.to_s)
+      end
 
-        unless doc_info.block_node
-          new_text = "\sdo#{link_text}\n\s\send\n"
-        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)
+        put_items_into_response(completion_items)
+      end
 
-        range = get_range_for_fn_insert(doc_info, link_text)
+      def dao_filter_completion(node)
+        dao_obj = ReeObjectFinder.find_dao(@index, node.receiver.name.to_s)
+        location = node.receiver.location
 
-        [
-          Interface::TextEdit.new(
-            range:    range,
-            new_text: new_text,
-          )
-        ]
+        completion_items = get_dao_filters_completion_items(dao_obj, location)
+        put_items_into_response(completion_items)
       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 bean_method_completion(node)
+        bean_obj = ReeObjectFinder.find_bean(@index, node.receiver.name.to_s)
+        location = node.receiver.location
 
-        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
-        
-        new_text = link_text
-
-        unless doc_info.block_node
-          new_text = "\sdo#{link_text}\n\s\send\n"
-        end
+        completion_items = get_bean_methods_completion_items(bean_obj, location)
 
-        range = get_range_for_fn_insert(doc_info, link_text)
+        put_items_into_response(completion_items)
+      end
 
-        [
-          Interface::TextEdit.new(
-            range:    range,
-            new_text: new_text,
-          )
-        ]
+      def put_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,267 @@
+require_relative "ree_lsp_utils"
+
+module RubyLsp
+  module Ree
+    module CompletionUtils
+      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)
+        
+        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)
+          file_name = File.basename(entry.uri.to_s)
+          
+          label_details = Interface::CompletionItemLabelDetails.new(
+            description: "from: :#{package_name}",
+            detail: " #{file_name}"
+          )
+
+          Interface::CompletionItem.new(
+            label: class_name,
+            label_details: label_details,
+            filter_text: class_name,
+            text_edit: Interface::TextEdit.new(
+              range:  range_from_location(node.location),
+              new_text: class_name,
+            ),
+            kind: Constant::CompletionItemKind::CLASS,
+            additional_text_edits: get_additional_text_edits_for_constant(parsed_doc, class_name, package_name, entry)
+          )
+        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)
+          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_folder(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)
+          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,26 +1,93 @@
+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, :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
 
-        # dispatcher.register(self, :on_call_node_enter, :on_symbol_node_enter, :on_string_node_enter)
-        dispatcher.register(self, :on_call_node_enter)
+            @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(
+          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_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(
@@ -33,6 +100,22 @@ module RubyLsp
 
         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