ruby-lsp-ree 0.1.21 → 0.1.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f11e82aca2c43fe42fb37077f3bc8590c5c68e06c13d9068c6872ae859faaad
-  data.tar.gz: 07fa4705541847c82764e5c4e27c13b190c240e63c12bb86a98fd49577be6090
+  metadata.gz: be41c6719d100fed8169e29ecfb808cf73611625cd14982727ee7763ab55d809
+  data.tar.gz: 2dac21136c9605aadeb19544f3efb6d9cf3044b40cfeaca2279203ba846f101d
 SHA512:
-  metadata.gz: b7bc67742989ee60af3e3b9f4dd38b44183522e86d7b8f1af90c255edb10179086e55255312fd80abf7306af37d318f0e8343f6183926ffb424288ff479fce4f
-  data.tar.gz: 593ebeac60988a3a9f9db7137d99a313b07d7ebd6385e7e3a566c93960a7ebfd803ce1fccef8d595b12ecd53c5e22a3afa41b4fad279d8de49870ffa9a1c4737
+  metadata.gz: 03f9fd7161d065c127b7f479b547b92edad8923b9a24eaa12b687382ad50b1946fa37029281bdda7aa9b9159ddc19f281f304479ec9c35e8516701eaf13b4e6b
+  data.tar.gz: d2324472049d592331c2ad8a32e156fa374f85f644ab67ce366cecdd486260804c0830aa6372c040669ca291584cd39368860b8ebc29f1c4013bb927a20e5a12

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.1.22] - 2025-05-30
+
+- unused links formatter: improve usage detection
+- Go To Definition: handle link aliases
+- Go To Definition: go to package from link params
+
 ## [0.1.21] - 2025-05-21
 
 - formatter: deduplicate dao columns

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ruby-lsp-ree (0.1.21)
+    ruby-lsp-ree (0.1.22)
 
 GEM
   remote: https://rubygems.org/

data/lib/ruby_lsp/ruby_lsp_ree/formatters/unused_links_formatter.rb

@@ -26,7 +26,7 @@ module RubyLsp
           remove_imports = []
 
           if link_node.has_import_section?
-            remove_imports = link_node.imports.reject{ |imp| import_is_used?(link_node, imp) }
+            remove_imports = link_node.imports.reject{ |imp| import_is_used?(parsed_doc, link_node, imp) }
             editor.remove_link_imports(link_node, remove_imports)
 
             if link_node.imports.size == remove_imports.size
@@ -34,7 +34,7 @@ module RubyLsp
             end
           end
 
-          next if link_is_used?(link_node, remove_imports) || parsed_doc.includes_mapper_dsl?
+          next if link_is_used?(parsed_doc, link_node, remove_imports) || parsed_doc.includes_mapper_dsl?
 
           editor.remove_link(link_node)
           removed_links += 1
@@ -50,12 +50,12 @@ module RubyLsp
 
       private
 
-      def import_is_used?(link_node, link_import)
-        editor.contains_link_import_usage?(link_node, link_import) || dsl_parser.contains_object_usage?(link_import)
+      def import_is_used?(parsed_doc, link_node, link_import)
+        editor.contains_link_import_usage?(parsed_doc, link_node, link_import) || dsl_parser.contains_object_usage?(link_import)
       end
 
-      def link_is_used?(link_node, remove_imports)
-        editor.contains_link_usage?(link_node) || link_node.imports.size > remove_imports.size || dsl_parser.contains_object_usage?(link_node.name)
+      def link_is_used?(parsed_doc, link_node, remove_imports)
+        editor.contains_link_usage?(parsed_doc, link_node) || link_node.imports.size > remove_imports.size || dsl_parser.contains_object_usage?(link_node.name)
       end
     end
   end

data/lib/ruby_lsp/ruby_lsp_ree/handlers/definition_handler.rb

@@ -75,10 +75,10 @@ module RubyLsp
         result = []
         
         parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_ast(@root_node, @uri)
-        link_node = parsed_doc.find_link_node(message)
+        link_node = parsed_doc.find_link_by_usage_name(message)
 
         definition_item = if link_node
-          @finder.find_object_for_package(message, link_node.link_package_name)
+          @finder.find_object_for_package(link_node.name, link_node.link_package_name)
         else
           @finder.find_object(message)
         end
@@ -106,7 +106,7 @@ module RubyLsp
         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]
+        method_candidates = @index[link_node.name]
         return [] if !method_candidates || method_candidates.size == 0
         
         method = method_candidates.detect{ package_name_from_uri(_1.uri) == package_name }
@@ -225,6 +225,32 @@ module RubyLsp
 
         result
       end
+
+      def get_package_definition_items(node)
+        package_name = node.unescaped
+
+        parent_node = @node_context.parent
+        link_node = RubyLsp::Ree::ParsedLinkNode.new(parent_node, package_name_from_uri(@uri))
+
+        method_candidates = @index[link_node.name]
+        return [] if !method_candidates || method_candidates.size == 0
+        
+        method = method_candidates.detect{ package_name_from_uri(_1.uri) == package_name }
+        return [] unless method
+
+        package_path = package_path_from_uri(method.uri.to_s)
+        package_main_file_path = File.join(package_path, 'package', "#{package_name}.rb")
+
+        [
+          Interface::Location.new(
+            uri: package_main_file_path,
+            range: Interface::Range.new(
+              start: Interface::Position.new(line: 0, character: 0),
+              end: Interface::Position.new(line: 0, character: 0),
+            ),
+          )
+        ]
+      end
     end
   end
 end

data/lib/ruby_lsp/ruby_lsp_ree/listeners/definition_listener.rb

@@ -45,7 +45,11 @@ module RubyLsp
         definition_items = if @ree_context.is_error_definition?
           @handler.get_error_code_definition_items(node)
         elsif @ree_context.is_link_object?
-          @handler.get_linked_object_definition_items(node)
+          if @ree_context.is_package_argument?
+            @handler.get_package_definition_items(node)
+          else
+            @handler.get_linked_object_definition_items(node)
+          end
         else
           @handler.get_routes_definition_items(node)
         end

data/lib/ruby_lsp/ruby_lsp_ree/parsing/body_parsers/body_objects_parser.rb

@@ -0,0 +1,117 @@
+require 'prism'
+
+class RubyLsp::Ree::BodyObjectsParser
+  class ConstObject
+    attr_reader :name
+
+    def initialize(name:)
+      @name = name
+    end
+  end
+
+  class CallObject
+    attr_reader :name, :type, :receiver_name, :method_name
+
+    def initialize(name:, type:, receiver_name: nil)
+      @name = name
+      @type = type
+      @receiver_name = receiver_name
+      @method_name = nil
+    end
+
+    def set_method_name(method_name)
+      @method_name = method_name
+    end
+
+    def has_receiver?
+      !!@receiver_name
+    end
+  end
+
+  def initialize(target_type)
+    @target_type = target_type
+  end
+
+  def parse(node_body)
+    target_objects = []
+
+    return target_objects unless node_body
+    
+    node_body.each do |node|
+      if node.is_a?(Prism::ConstantReadNode) && @target_type == :const_object
+        target_objects << ConstObject.new(name: node.name)
+      end
+
+      if node.is_a?(Prism::CallNode)
+        if node.receiver
+          target_objects += parse([node.receiver])
+        else
+          if @target_type == :call_object
+            target_objects << CallObject.new(name: node.name, type: :method_call)
+          end
+        end
+      
+        target_objects += parse_target_objects_from_args(node.arguments)
+      else
+        if node.respond_to?(:elements)
+          target_objects += parse(node.elements)
+        end
+
+        if node.respond_to?(:predicate)
+          target_objects += parse([node.predicate])
+        end
+        
+        if node.respond_to?(:statements)
+          target_objects += parse(node.statements.body)
+        end
+
+        if node.respond_to?(:subsequent)
+          target_objects += parse([node.subsequent])
+        end
+
+        if node.respond_to?(:value) && node.value
+          target_objects += parse([node.value])
+        end
+
+        if node.respond_to?(:key) && node.key
+          target_objects += parse([node.key])
+        end
+
+        if node.respond_to?(:left) && node.left
+          target_objects += parse([node.left])
+        end
+
+        if node.respond_to?(:right) && node.right
+          target_objects += parse([node.right])
+        end
+
+        if node.respond_to?(:parts) && node.parts
+          target_objects += parse(node.parts)
+        end
+      end
+
+      if node.respond_to?(:block) && node.block && node.block.is_a?(Prism::BlockNode)
+        target_objects += parse(get_method_body(node.block))
+      end
+    end
+
+    target_objects
+  end
+
+  private
+
+  def parse_target_objects_from_args(node_arguments)
+    return [] if !node_arguments || !node_arguments.arguments
+    parse(node_arguments.arguments)
+  end
+
+  def get_method_body(node)
+    return unless node.body
+
+    if node.body.is_a?(Prism::BeginNode)
+      node.body.statements.body
+    else
+      node.body.body
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_ree/parsing/body_parsers/call_objects_parser.rb

@@ -1,33 +1,20 @@
+require_relative 'body_objects_parser'
+
 class RubyLsp::Ree::CallObjectsParser
   attr_reader :parsed_doc
 
-  class CallObject
-    attr_reader :name, :type, :receiver_name, :method_name
-
-    def initialize(name:, type:, receiver_name: nil)
-      @name = name
-      @type = type
-      @receiver_name = receiver_name
-      @method_name = nil
-    end
-
-    def set_method_name(method_name)
-      @method_name = method_name
-    end
-  end
-
   def initialize(parsed_doc)
     @parsed_doc = parsed_doc
+    @body_parser = RubyLsp::Ree::BodyObjectsParser.new(:call_object)
   end
 
   def class_call_objects
     call_objects = []
     return unless parsed_doc.has_body?
 
-    call_objects += parse_body_call_objects(parsed_doc.class_node.body.body)
+    call_objects += @body_parser.parse(parsed_doc.class_node.body.body)
 
     parsed_doc.parse_instance_methods
-
     parsed_doc.doc_instance_methods.each do |doc_instance_method|
       call_objects += method_call_objects(doc_instance_method)
     end
@@ -39,107 +26,9 @@ class RubyLsp::Ree::CallObjectsParser
     method_body = method_object.method_body
     return [] unless method_body
 
-    call_nodes = parse_body_call_objects(method_body)
-    call_expressions = [] # don't parse call expressions for now parse_body_call_expressions(method_body)
-
-    call_objects = call_nodes + call_expressions
+    call_objects = @body_parser.parse(method_body)
 
     call_objects.each{ |call_object| call_object.set_method_name(method_object.name) }
     call_objects
   end
-
-  private 
-
-  def parse_body_call_objects(node_body)
-    call_objects = []
-
-    return call_objects unless node_body
-    
-    node_body.each do |node|
-      if node.is_a?(Prism::CallNode)
-        if node.receiver
-          receiver = get_first_receiver(node)
-      
-          if receiver.is_a?(Prism::CallNode)
-            call_objects += parse_body_call_objects([receiver])
-          end
-        else
-          call_objects << CallObject.new(name: node.name, type: :method_call)
-        end
-      
-        call_objects += parse_call_objects_from_args(node.arguments)
-      else
-        if node.respond_to?(:elements)
-          call_objects += parse_body_call_objects(node.elements)
-        end
-
-        if node.respond_to?(:predicate)
-          call_objects += parse_body_call_objects([node.predicate])
-        end
-        
-        if node.respond_to?(:statements)
-          call_objects += parse_body_call_objects(node.statements.body)
-        end
-
-        if node.respond_to?(:value) && node.value
-          call_objects += parse_body_call_objects([node.value])
-        end
-
-        if node.respond_to?(:left) && node.left
-          call_objects += parse_body_call_objects([node.left])
-        end
-
-        if node.respond_to?(:right) && node.right
-          call_objects += parse_body_call_objects([node.right])
-        end
-
-        if node.respond_to?(:parts) && node.parts
-          call_objects += parse_body_call_objects(node.parts)
-        end
-      end
-
-      if node.respond_to?(:block) && node.block && node.block.is_a?(Prism::BlockNode)
-        call_objects += parse_body_call_objects(get_method_body(node.block))
-      end
-    end
-
-    call_objects
-  end
-
-  def parse_call_objects_from_args(node_arguments)
-    return [] if !node_arguments || !node_arguments.arguments
-    parse_body_call_objects(node_arguments.arguments)
-  end
-
-  def parse_body_call_expressions(node_body)
-    call_expressions = []
-    
-    node_body.each do |node|
-      if node.respond_to?(:block) && node.block && node.block.is_a?(Prism::BlockArgumentNode) && node.block.expression.is_a?(Prism::SymbolNode)
-        call_expressions << CallObject.new(name: node.block.expression.unescaped.to_sym, type: :proc_to_sym)
-      end
-    end
-
-    call_expressions
-  end
-
-  def get_method_body(node)
-    return unless node.body
-
-    if node.body.is_a?(Prism::BeginNode)
-      node.body.statements.body
-    else
-      node.body.body
-    end
-  end
-
-  def get_first_receiver(node)
-    return nil unless node.receiver
-
-    if node.receiver.is_a?(Prism::CallNode) && node.receiver.receiver
-      return get_first_receiver(node.receiver)
-    end
-
-    node.receiver
-  end
 end

data/lib/ruby_lsp/ruby_lsp_ree/parsing/body_parsers/const_objects_parser.rb

@@ -0,0 +1,37 @@
+require_relative 'body_objects_parser'
+
+class RubyLsp::Ree::ConstObjectsParser
+  attr_reader :parsed_doc
+
+  def initialize(parsed_doc)
+    @parsed_doc = parsed_doc
+    @body_parser = RubyLsp::Ree::BodyObjectsParser.new(:const_object)
+  end
+
+  def class_const_objects
+    const_objects = []
+    return unless parsed_doc.has_body?
+
+    const_objects += @body_parser.parse(parsed_doc.class_node.body.body)
+
+    parsed_doc.parse_instance_methods
+    parsed_doc.doc_instance_methods.each do |doc_instance_method|
+      const_objects += method_const_objects(doc_instance_method)
+    end
+
+    const_objects
+  end
+
+  def method_const_objects(method_object)
+    method_body = method_object.method_body
+    return [] unless method_body
+
+    const_objects = @body_parser.parse(method_body)
+
+    if method_object.has_contract?
+      const_objects += @body_parser.parse([method_object.contract_node])
+    end
+
+    const_objects
+  end
+end

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

@@ -44,6 +44,10 @@ class RubyLsp::Ree::ParsedBaseDocument
     @link_nodes.detect{ node_name(_1) == name }
   end
 
+  def find_link_by_usage_name(name)
+    @link_nodes.detect{ _1.usage_name == name }
+  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

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

@@ -3,6 +3,7 @@ require_relative 'parsed_link_node'
 require_relative 'parsed_method_node'
 require_relative "../ree_constants"
 require_relative "body_parsers/call_objects_parser"
+require_relative "body_parsers/const_objects_parser"
 
 require 'ostruct'
 
@@ -195,6 +196,10 @@ class RubyLsp::Ree::ParsedClassDocument < RubyLsp::Ree::ParsedBaseDocument
     RubyLsp::Ree::CallObjectsParser.new(self).class_call_objects
   end
 
+  def parse_const_objects
+    RubyLsp::Ree::ConstObjectsParser.new(self).class_const_objects
+  end
+
   def class_name
     class_node.constant_path.name.to_s
   end

data/lib/ruby_lsp/ruby_lsp_ree/ree_context.rb

@@ -6,21 +6,41 @@ module RubyLsp
     class ReeContext
       include RubyLsp::Ree::ReeConstants
 
+      FROM_ARG_KEY = 'from'
+
       def initialize(node_context)
         @node_context = node_context
       end
 
       def is_error_definition?
-        return false if !@node_context || !@node_context.parent || !@node_context.parent.is_a?(Prism::CallNode)
+        return false unless has_call_parent?
         
         ERROR_DEFINITION_NAMES.include?(@node_context.parent.name)
       end
 
       def is_link_object?
-        return false if !@node_context || !@node_context.parent || !@node_context.parent.is_a?(Prism::CallNode)
+        return false unless has_call_parent?
 
         @node_context.parent.name == :link
       end
+
+      def is_package_argument?
+        return false unless has_call_parent?
+        return false if !@node_context.parent.arguments || @node_context.parent.arguments.arguments.size < 2
+        return false if @node_context.node.unescaped == @node_context.parent.arguments.arguments.first.unescaped
+
+        kw_args = @node_context.parent.arguments.arguments.detect{ |arg| arg.is_a?(Prism::KeywordHashNode) }
+        return false unless kw_args
+    
+        package_param = kw_args.elements.detect{ _1.key.unescaped == FROM_ARG_KEY }
+        package_param.value.unescaped == @node_context.node.unescaped
+      end
+
+      private
+
+      def has_call_parent?
+        @node_context && @node_context.parent && @node_context.parent.is_a?(Prism::CallNode)
+      end
     end
   end
 end

data/lib/ruby_lsp/ruby_lsp_ree/ree_source_editor.rb

@@ -13,12 +13,23 @@ module RubyLsp
         @source_lines.join
       end
 
-      def contains_link_usage?(link_node)
+      def contains_link_usage?(parsed_doc, link_node)
+        if parsed_doc.respond_to?(:parse_method_calls)
+          method_calls = parsed_doc.parse_method_calls
+          no_receiver_method_names = method_calls.reject(&:has_receiver?).map(&:name).map(&:to_s)
+          return no_receiver_method_names.include?(link_node.usage_name)
+        end
+
         source_lines_except_link = source_lines[0...(link_node.location.start_line-1)] + source_lines[(link_node.location.end_line)..-1]
         source_lines_except_link.any?{ |source_line| source_line.match?(/\W#{link_node.usage_name}\W/)}
       end
 
-      def contains_link_import_usage?(link_node, link_import)
+      def contains_link_import_usage?(parsed_doc, link_node, link_import)
+        if parsed_doc.respond_to?(:parse_const_objects)
+          const_objects = parsed_doc.parse_const_objects
+          return const_objects.map(&:name).map(&:to_s).include?(link_import)
+        end
+
         source_lines_except_link = source_lines[0...(link_node.location.start_line-1)] + source_lines[(link_node.location.end_line)..-1]
         source_lines_except_link.any?{ |source_line| source_line.match?(/\W#{link_import}\W/)}
       end

data/lib/ruby_lsp/ruby_lsp_ree/utils/ree_lsp_utils.rb

@@ -11,7 +11,7 @@ module RubyLsp
         file_name = file_path + ".rb"
         Dir[File.join('**', file_name)].first
       end
-      
+
       def package_name_from_uri(uri)
         uri_parts = uri.to_s.split('/')
         
@@ -30,6 +30,15 @@ module RubyLsp
         uri_parts[spec_folder_index + 1]
       end
 
+      def package_path_from_uri(uri)
+        uri_parts = uri.to_s.split('/')
+        
+        package_folder_index = uri_parts.find_index('package')
+        return unless package_folder_index
+
+        uri_parts.take(package_folder_index).join('/')
+      end
+
       def path_from_package_folder(uri)
         uri_parts = uri.to_s.chomp(File.extname(uri.to_s)).split('/')
 

data/lib/ruby_lsp_ree/version.rb

@@ -2,6 +2,6 @@
 
 module RubyLsp
   module Ree
-    VERSION = "0.1.21"
+    VERSION = "0.1.22"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-ree
 version: !ruby/object:Gem::Version
-  version: 0.1.21
+  version: 0.1.22
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-05-21 00:00:00.000000000 Z
+date: 2025-05-30 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby LSP addon that adds extra editor functionality for Ree applications
 email:
@@ -44,7 +44,9 @@ files:
 - 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/body_parsers/body_objects_parser.rb
 - lib/ruby_lsp/ruby_lsp_ree/parsing/body_parsers/call_objects_parser.rb
+- lib/ruby_lsp/ruby_lsp_ree/parsing/body_parsers/const_objects_parser.rb
 - lib/ruby_lsp/ruby_lsp_ree/parsing/body_parsers/local_variables_parser.rb
 - lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_base_document.rb
 - lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_class_document.rb