ruby-lsp-ree 0.1.20 → 0.1.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46e3cdb9ee36b1b88e20d71c218ce355571da9aa6d405dfe0dcd879e1b37a5ef
-  data.tar.gz: a668bef693a29e639c6acb57f1a8ad2415d630242a2eecc04ff188f3d2fd93f4
+  metadata.gz: be41c6719d100fed8169e29ecfb808cf73611625cd14982727ee7763ab55d809
+  data.tar.gz: 2dac21136c9605aadeb19544f3efb6d9cf3044b40cfeaca2279203ba846f101d
 SHA512:
-  metadata.gz: bad0e641f6076ceb9544c0e159598a64e44343e890bddb627603d3ba9c0124b6a654f271e5599bc8e045ab7fac117b1844ce25bac5b6d2c4bb1b8457587b43b4
-  data.tar.gz: 8e691510c967c4788bc3ba9636571644a611bbe909a8e17f1cab4ea140f81f0878f346e0523f7d0020ae3d007248e402a21be3ab4afa201eb7d328afd1c79160
+  metadata.gz: 03f9fd7161d065c127b7f479b547b92edad8923b9a24eaa12b687382ad50b1946fa37029281bdda7aa9b9159ddc19f281f304479ec9c35e8516701eaf13b4e6b
+  data.tar.gz: d2324472049d592331c2ad8a32e156fa374f85f644ab67ce366cecdd486260804c0830aa6372c040669ca291584cd39368860b8ebc29f1c4013bb927a20e5a12

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [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
+- unused links formatter: handle link aliases
+
 ## [0.1.20] - 2025-05-15
 
 - formatter: add missing columns to entities

data/Gemfile.lock

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

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

@@ -1,4 +1,5 @@
 require_relative 'base_formatter'
+require_relative '../ree_source_editor'
 
 module RubyLsp
   module Ree
@@ -17,6 +18,8 @@ module RubyLsp
         return source unless parsed_doc.includes_dao_dsl?
         return source unless parsed_doc.has_schema?
 
+        source = deduplicate_dao_fields(parsed_doc, source)
+
         dao_folder_index = path_parts.index('dao')
         entities_folder = path_parts.take(dao_folder_index).join('/') + '/entities'
 
@@ -71,6 +74,30 @@ module RubyLsp
 
         File.write(entity_path, source_lines.join)
       end
+
+      def deduplicate_dao_fields(parsed_doc, source)
+        grouped_fields = parsed_doc.dao_fields.group_by(&:name)
+        uniq_fields = []
+        fields_to_remove = []
+
+        grouped_fields.each do |name, fields|
+          uniq_fields << fields.first
+          if fields.size > 1
+            fields_to_remove += fields[1..-1]
+          end
+        end
+
+        return source if fields_to_remove.size == 0
+
+        parsed_doc.set_dao_fields(uniq_fields)
+        editor = RubyLsp::Ree::ReeSourceEditor.new(source)
+
+        fields_to_remove.each do |field|
+          editor.remove_dao_field(field)
+        end
+
+        editor.source
+      end
     end
   end
 end

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/parsing/parsed_dao_document.rb

@@ -32,6 +32,10 @@ class RubyLsp::Ree::ParsedDaoDocument < RubyLsp::Ree::ParsedClassDocument
     @schema_node.arguments.arguments.first.name.to_s
   end
 
+  def set_dao_fields(fields)
+    @dao_fields = fields
+  end
+
   private 
 
   def parse_dao_fields

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

@@ -5,6 +5,7 @@ class RubyLsp::Ree::ParsedLinkNode
 
   FROM_ARG_KEY = 'from'
   IMPORT_ARG_KEY = 'import'
+  AS_ARG_KEY = 'as'
 
   class ImportItem
     attr_reader :name, :original_name
@@ -44,6 +45,11 @@ class RubyLsp::Ree::ParsedLinkNode
     @node.location
   end
 
+  def usage_name
+    return @alias_name if @alias_name
+    @name
+  end
+
   def from_arg_value
     return unless @from_param
 
@@ -75,17 +81,6 @@ class RubyLsp::Ree::ParsedLinkNode
     link_type == :object_name
   end
 
-  def parse_name
-    case name_arg_node
-    when Prism::SymbolNode
-      name_arg_node.value
-    when Prism::StringNode
-      name_arg_node.unescaped
-    else
-      ""
-    end
-  end
-
   def parse_imports
     @import_items ||= get_import_items
   end
@@ -123,12 +118,25 @@ class RubyLsp::Ree::ParsedLinkNode
 
   private
 
+  def parse_name
+    case name_arg_node
+    when Prism::SymbolNode
+      name_arg_node.value
+    when Prism::StringNode
+      name_arg_node.unescaped
+    else
+      ""
+    end
+  end
+
   def parse_params
     @kw_args = @node.arguments.arguments.detect{ |arg| arg.is_a?(Prism::KeywordHashNode) }
     @from_param = nil
     return unless @kw_args
 
     @from_param = @kw_args.elements.detect{ _1.key.unescaped == FROM_ARG_KEY }
+    @as_param = @kw_args.elements.detect{ _1.key.unescaped == AS_ARG_KEY }
+    @alias_name = @as_param ? @as_param.value.unescaped : nil
   end
 
   def last_arg

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,18 +13,29 @@ 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.name}\W/)}
+        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
 
       def remove_link(link_node)
-        set_empty_lines!(link_node.location.start_line-1, link_node.location.end_line-1)
+        set_empty_lines_for_location!(link_node.location)
       end
 
       def remove_link_imports(link_node, link_imports)
@@ -58,10 +69,8 @@ module RubyLsp
         set_empty_lines!(link_container_start_line+1, link_container_end_line)
       end
 
-      def set_empty_lines!(start_line, end_line)
-        (start_line .. end_line).each do |i|
-          source_lines[i] = ''
-        end
+      def remove_dao_field(field)
+        set_empty_lines_for_location!(field.location)
       end
 
       def add_links(parsed_doc, ree_objects, current_package)
@@ -127,6 +136,18 @@ module RubyLsp
           source_lines[line] = source_lines[line][0..start_column] + ", from: :#{new_package}" + source_lines[line][start_column+1..-1]
         end
       end
+
+      private
+
+      def set_empty_lines_for_location!(location)
+        set_empty_lines!(location.start_line-1, location.end_line-1)
+      end
+
+      def set_empty_lines!(start_line, end_line)
+        (start_line .. end_line).each do |i|
+          source_lines[i] = ''
+        end
+      end
     end
   end
 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.20"
+    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.20
+  version: 0.1.22
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-05-16 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