ruby-lsp-ree 0.1.22 → 0.1.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be41c6719d100fed8169e29ecfb808cf73611625cd14982727ee7763ab55d809
-  data.tar.gz: 2dac21136c9605aadeb19544f3efb6d9cf3044b40cfeaca2279203ba846f101d
+  metadata.gz: 149a5de21eba9546be0724fa9af412299bb013bb4f413ff0f59d8ba8676261d8
+  data.tar.gz: bf136b0f946e1d79c43a67c29e32084b3aa90f8f4725984063789ec91c3e3404
 SHA512:
-  metadata.gz: 03f9fd7161d065c127b7f479b547b92edad8923b9a24eaa12b687382ad50b1946fa37029281bdda7aa9b9159ddc19f281f304479ec9c35e8516701eaf13b4e6b
-  data.tar.gz: d2324472049d592331c2ad8a32e156fa374f85f644ab67ce366cecdd486260804c0830aa6372c040669ca291584cd39368860b8ebc29f1c4013bb927a20e5a12
+  metadata.gz: 792a7249438e7b086bc98b274077a2fb3af406558167bb0a910a4787440550da742a90d7a97a1e5bd56b8db8c15abc2848d835812c90d275a4d0169ae32b156e
+  data.tar.gz: 31dbbcc00c85d4cfc9913e156589f112809e73d8b4d80ac27f6f9ca4d481c383c3e4adb7ed131e2c9d002bc0224dfce545761bde2c5d8fc78d1883a440abda61

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## [0.1.24] - 2025-06-27
+
+- ree 1.2 syntax support
+- links section sorting updated
+
 ## [0.1.22] - 2025-05-30
 
 - unused links formatter: improve usage detection

data/Gemfile.lock

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

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

@@ -11,6 +11,7 @@ module RubyLsp
 
         current_package = package_name_from_uri(uri)
         parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_source(source, package_name: current_package)
+        return source if !parsed_doc
 
         finder = ReeObjectFinder.new(@index)
         editor = RubyLsp::Ree::ReeSourceEditor.new(source)

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

@@ -73,4 +73,4 @@ module RubyLsp
       end
     end
   end
-end
+end

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

@@ -1,4 +1,6 @@
 require_relative 'base_formatter'
+require_relative '../ree_source_editor'
+require_relative '../renderers/link_renderer'
 
 module RubyLsp
   module Ree
@@ -7,44 +9,35 @@ module RubyLsp
         parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_source(source)
         return source if !parsed_doc || !parsed_doc.link_nodes&.any?
 
-        if parsed_doc.link_nodes.any?{ _1.location.start_line != _1.location.end_line }
-          $stderr.puts("multiline link definitions, don't sort")
-          return source
+        # Order of groups:
+        # - links from the current package without options
+        # - links from the current package with options
+        # - links from other packages
+        # - links with filenames
+        # - import links
+
+        editor = RubyLsp::Ree::ReeSourceEditor.new(source)
+        renderer = RubyLsp::Ree::LinkRenderer.new
+        # cleanup old links
+        parsed_doc.link_nodes.each do |link_node|
+          editor.remove_link(link_node)
         end
-
-        # sort link nodes
-        sorted_link_nodes = parsed_doc.link_nodes.sort{ |a, b|
-          a_name = a.node.arguments.arguments.first
-          b_name = b.node.arguments.arguments.first
-
-          if a_name.is_a?(Prism::SymbolNode) && !b_name.is_a?(Prism::SymbolNode)
-            -1
-          elsif b_name.is_a?(Prism::SymbolNode) && !a_name.is_a?(Prism::SymbolNode)
-            1
-          else
-            a_name.unescaped <=> b_name.unescaped
-          end
-        }
-
-        # check if no re-order
-        if parsed_doc.link_nodes.map{ _1.node.arguments.arguments.first.unescaped } == sorted_link_nodes.map{ _1.node.arguments.arguments.first.unescaped }
-          return source
-        end
-
-        # insert nodes to source
-        link_lines = parsed_doc.link_nodes.map{ _1.location.start_line }
-
-        source_lines = source.lines
-
-        sorted_lines = sorted_link_nodes.map do |sorted_link|
-          source_lines[sorted_link.location.start_line - 1]
-        end
-
-        link_lines.each_with_index do |link_line, index|
-          source_lines[link_line - 1] = sorted_lines[index]
+        editor.cleanup_blank_lines(parsed_doc.link_nodes.first.location.start_line-1, parsed_doc.link_nodes.last.location.end_line-1)
+
+        link_groups = [
+          parsed_doc.link_nodes.select(&:object_name_type?).select{ !_1.has_kwargs? }.sort_by(&:name),
+          parsed_doc.link_nodes.select(&:object_name_type?).select(&:has_kwargs?).select{ !_1.from_arg_value }.sort_by(&:name),
+          parsed_doc.link_nodes.select(&:object_name_type?).select{ !!_1.from_arg_value }.sort_by(&:link_package_name),
+          parsed_doc.link_nodes.select(&:file_path_type?).sort_by(&:name),
+          parsed_doc.link_nodes.select(&:import_link_type?).sort_by(&:link_package_name),
+        ]
+
+        link_groups_texts = link_groups.map do |link_group|
+          link_group.map{ renderer.render(_1) }.join('')
         end
 
-        source_lines.join()
+        editor.insert_link_block(parsed_doc, link_groups_texts.select{ _1.size > 0 }.join("\n"))
+        editor.source
       end
     end
   end

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

@@ -25,6 +25,7 @@ module RubyLsp
         parsed_doc.link_nodes.each do |link_node|
           remove_imports = []
 
+          link_node.has_import_section?
           if link_node.has_import_section?
             remove_imports = link_node.imports.reject{ |imp| import_is_used?(parsed_doc, link_node, imp) }
             editor.remove_link_imports(link_node, remove_imports)
@@ -34,10 +35,18 @@ module RubyLsp
             end
           end
 
-          next if link_is_used?(parsed_doc, link_node, remove_imports) || parsed_doc.includes_mapper_dsl?
+          next if parsed_doc.includes_mapper_dsl?
+          
+          has_imports = link_node.imports.size > remove_imports.size
+          next if has_imports
 
-          editor.remove_link(link_node)
-          removed_links += 1
+          remove_objects = link_node.linked_objects.select{ !link_object_is_used?(parsed_doc, link_node, _1) }
+          editor.remove_linked_objects(link_node, remove_objects)
+
+          if link_node.linked_objects.size == remove_objects.size 
+            editor.remove_link(link_node)
+            removed_links += 1
+          end
         end
 
         if removed_links == links_count
@@ -54,8 +63,8 @@ module RubyLsp
         editor.contains_link_import_usage?(parsed_doc, link_node, link_import) || dsl_parser.contains_object_usage?(link_import)
       end
 
-      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)
+      def link_object_is_used?(parsed_doc, link_node, linked_object)
+        editor.contains_linked_object_usage?(parsed_doc, link_node, linked_object) || dsl_parser.contains_object_usage?(linked_object.usage_name)
       end
     end
   end

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

@@ -1,8 +1,10 @@
 require_relative "../utils/ree_lsp_utils"
 require_relative "../ree_object_finder"
 require_relative "../parsing/parsed_link_node"
+require_relative "../parsing/parsed_link_node_builder"
 require_relative "../parsing/parsed_document_builder"
 require_relative "../utils/ree_locale_utils"
+require_relative "../ree_context"
 
 module RubyLsp
   module Ree
@@ -17,15 +19,15 @@ module RubyLsp
         @node_context = node_context
         @root_node = @node_context.instance_variable_get(:@nesting_nodes).first
         @finder = ReeObjectFinder.new(@index)
+        @ree_context = RubyLsp::Ree::ReeContext.new(node_context)
       end
 
       def get_constant_definition_items(node)
         result = []
 
-        link_nodes = if @node_context.parent.is_a?(Prism::CallNode) && @node_context.parent.name == :link
+        link_nodes = if @ree_context.is_link_object?
           # inside link node
-          link_node = RubyLsp::Ree::ParsedLinkNode.new(@node_context.parent)
-          link_node.parse_imports
+          link_node = RubyLsp::Ree::ParsedLinkNodeBuilder.build_from_node(@node_context.parent, nil)
           [link_node]
         else
           parsed_doc = if @node_context.parent.is_a?(Prism::CallNode)
@@ -36,7 +38,7 @@ module RubyLsp
 
           parsed_doc.link_nodes
         end
-        
+
         link_nodes.each do |link_node|
           if link_node.imports.include?(node.name.to_s)
             uri = ''
@@ -45,6 +47,16 @@ module RubyLsp
               next unless path
 
               uri = File.join(Dir.pwd, path)
+            elsif link_node.import_link_type?
+              class_candidates = @finder.search_classes(node.name.to_s)
+              next unless class_candidates
+
+              class_candidates = class_candidates.flatten
+              package_name = link_node.link_package_name || package_name_from_uri(@uri)
+              class_candidate = class_candidates.detect{ package_name_from_uri(_1.uri) == package_name }
+              next unless class_candidate
+
+              uri = class_candidate.uri.to_s
             else
               package_name = link_node.link_package_name || package_name_from_uri(@uri)
 
@@ -103,10 +115,16 @@ module RubyLsp
         result = []
         parent_node = @node_context.parent
 
-        link_node = RubyLsp::Ree::ParsedLinkNode.new(parent_node, package_name_from_uri(@uri))
+        link_node = RubyLsp::Ree::ParsedLinkNodeBuilder.build_from_node(parent_node, package_name_from_uri(@uri))
         package_name = link_node.link_package_name
 
-        method_candidates = @index[link_node.name]
+        object_name = if link_node.multi_object_link? && node.is_a?(Prism::SymbolNode) && link_node.has_linked_object?(node.unescaped)
+          node.unescaped
+        else
+          link_node.name
+        end
+
+        method_candidates = @index[object_name]
         return [] if !method_candidates || method_candidates.size == 0
         
         method = method_candidates.detect{ package_name_from_uri(_1.uri) == package_name }
@@ -230,15 +248,12 @@ module RubyLsp
         package_name = node.unescaped
 
         parent_node = @node_context.parent
-        link_node = RubyLsp::Ree::ParsedLinkNode.new(parent_node, package_name_from_uri(@uri))
+        link_node = RubyLsp::Ree::ParsedLinkNodeBuilder.build_from_node(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
+        object_uri = find_object_uri_for_package(link_node, package_name).to_s
+        return [] unless object_uri
 
-        package_path = package_path_from_uri(method.uri.to_s)
+        package_path = package_path_from_uri(object_uri.to_s)
         package_main_file_path = File.join(package_path, 'package', "#{package_name}.rb")
 
         [
@@ -251,6 +266,31 @@ module RubyLsp
           )
         ]
       end
+
+      private
+
+      def find_object_uri_for_package(link_node, package_name)
+        if link_node.import_link_type?
+          class_candidates = @finder.search_classes(link_node.imports.first)
+          return nil unless class_candidates
+
+          class_candidates = class_candidates.flatten
+          class_candidate = class_candidates.detect{ package_name_from_uri(_1.uri) == package_name }
+          return nil unless class_candidate
+
+          class_candidate.uri
+        else
+          link_node.name
+
+          method_candidates = @index[link_node.name]
+          return nil if !method_candidates || method_candidates.size == 0
+          
+          method = method_candidates.detect{ package_name_from_uri(_1.uri) == package_name }
+          return  unless method
+
+          method.uri
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,19 @@
+require 'prism'
+
+class RubyLsp::Ree::BasicParser
+  def node_name(node)
+    return nil unless node.respond_to?(:name)
+
+    node.name
+  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/body_objects_parser.rb

@@ -1,6 +1,6 @@
-require 'prism'
+require_relative 'basic_parser'
 
-class RubyLsp::Ree::BodyObjectsParser
+class RubyLsp::Ree::BodyObjectsParser < RubyLsp::Ree::BasicParser
   class ConstObject
     attr_reader :name
 
@@ -32,12 +32,14 @@ class RubyLsp::Ree::BodyObjectsParser
     @target_type = target_type
   end
 
-  def parse(node_body)
+  def parse(nodes)
     target_objects = []
 
-    return target_objects unless node_body
-    
-    node_body.each do |node|
+    return target_objects unless nodes
+
+    nodes.each do |node|
+      next if node.is_a?(Prism::DefNode) # for now don't step into method, parse each method separately
+      
       if node.is_a?(Prism::ConstantReadNode) && @target_type == :const_object
         target_objects << ConstObject.new(name: node.name)
       end
@@ -46,6 +48,8 @@ class RubyLsp::Ree::BodyObjectsParser
         if node.receiver
           target_objects += parse([node.receiver])
         else
+          next if node.name == :link || node.name == :import # don't parse objects inside links
+
           if @target_type == :call_object
             target_objects << CallObject.new(name: node.name, type: :method_call)
           end
@@ -62,7 +66,7 @@ class RubyLsp::Ree::BodyObjectsParser
         end
         
         if node.respond_to?(:statements)
-          target_objects += parse(node.statements.body)
+          target_objects += parse([node.statements])
         end
 
         if node.respond_to?(:subsequent)
@@ -88,10 +92,34 @@ class RubyLsp::Ree::BodyObjectsParser
         if node.respond_to?(:parts) && node.parts
           target_objects += parse(node.parts)
         end
+
+        if node.respond_to?(:rescue_clause) && node.rescue_clause
+          target_objects += parse([node.rescue_clause])
+        end
+
+        if node.respond_to?(:else_clause) && node.else_clause
+          target_objects += parse([node.else_clause])
+        end
+
+        if node.respond_to?(:ensure_clause) && node.ensure_clause
+          target_objects += parse([node.ensure_clause])
+        end
+
+        if node.respond_to?(:body) && node.body
+          if node.body.is_a?(Array)
+            target_objects += parse(node.body)
+          else
+            target_objects += parse([node.body])
+          end
+        end
       end
 
       if node.respond_to?(:block) && node.block && node.block.is_a?(Prism::BlockNode)
-        target_objects += parse(get_method_body(node.block))
+        if node.block.body.is_a?(Array)
+          target_objects += parse(node.block.body)
+        else
+          target_objects += parse([node.block.body])
+        end
       end
     end
 
@@ -104,14 +132,4 @@ class RubyLsp::Ree::BodyObjectsParser
     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

@@ -23,10 +23,10 @@ class RubyLsp::Ree::CallObjectsParser
   end
 
   def method_call_objects(method_object)
-    method_body = method_object.method_body
+    method_body = method_object.full_method_body
     return [] unless method_body
 
-    call_objects = @body_parser.parse(method_body)
+    call_objects = @body_parser.parse([method_body])
 
     call_objects.each{ |call_object| call_object.set_method_name(method_object.name) }
     call_objects

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

@@ -23,10 +23,10 @@ class RubyLsp::Ree::ConstObjectsParser
   end
 
   def method_const_objects(method_object)
-    method_body = method_object.method_body
+    method_body = method_object.full_method_body
     return [] unless method_body
 
-    const_objects = @body_parser.parse(method_body)
+    const_objects = @body_parser.parse([method_body])
 
     if method_object.has_contract?
       const_objects += @body_parser.parse([method_object.contract_node])

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

@@ -0,0 +1,19 @@
+require_relative 'basic_parser'
+require_relative '../parsed_link_node_builder'
+
+class RubyLsp::Ree::LinksParser < RubyLsp::Ree::BasicParser
+  attr_reader :container
+
+  def initialize(container, package_name)
+    @container = container
+    @document_package_name = package_name
+  end
+
+  def parse_links
+    nodes = container.select{ |node| node_name(node) == :link || node_name(node) == :import }
+
+    nodes.map do |link_node|
+      RubyLsp::Ree::ParsedLinkNodeBuilder.build_from_node(link_node, @document_package_name)
+    end
+  end
+end

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

@@ -1,4 +1,6 @@
-class RubyLsp::Ree::LocalVariablesParser
+require_relative 'basic_parser'
+
+class RubyLsp::Ree::LocalVariablesParser < RubyLsp::Ree::BasicParser
   attr_reader :parsed_doc, :method_object
 
   class LocalVariable
@@ -39,14 +41,4 @@ class RubyLsp::Ree::LocalVariablesParser
   
     local_variables
   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/parsed_base_document.rb

@@ -37,7 +37,7 @@ class RubyLsp::Ree::ParsedBaseDocument
   end
 
   def includes_linked_object?(obj_name)
-    @link_nodes.map(&:name).include?(obj_name)
+    @link_nodes.map(&:linked_objects).flatten.map(&:name).include?(obj_name)
   end
 
   def find_link_node(name)

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

@@ -4,6 +4,7 @@ require_relative 'parsed_method_node'
 require_relative "../ree_constants"
 require_relative "body_parsers/call_objects_parser"
 require_relative "body_parsers/const_objects_parser"
+require_relative "body_parsers/links_parser"
 
 require 'ostruct'
 
@@ -106,21 +107,18 @@ class RubyLsp::Ree::ParsedClassDocument < RubyLsp::Ree::ParsedBaseDocument
   end
 
   def parse_links
-    return unless has_body?
+    @link_nodes = []
+    return [] unless has_body?
 
-    nodes = if links_container_node && @links_container_block_node && @links_container_block_node.body
-      @links_container_block_node.body.body.select{ |node| node_name(node) == :link }
+    links_container_body = if links_container_node && @links_container_block_node && @links_container_block_node.body
+      @links_container_block_node.body.body 
     elsif class_includes.any?{ node_name(_1) == LINK_DSL_MODULE }
-      class_node.body.body.select{ |node| node_name(node) == :link }
+      class_node.body.body
     else
-      []
+      return []
     end
 
-    @link_nodes = nodes.map do |link_node|
-      link_node = RubyLsp::Ree::ParsedLinkNode.new(link_node, package_name)
-      link_node.parse_imports # TODO move parse imports inside link_node constructor
-      link_node
-    end
+    @link_nodes = RubyLsp::Ree::LinksParser.new(links_container_body, package_name).parse_links
   end
 
   def parse_values

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

@@ -0,0 +1,45 @@
+require_relative 'parsed_link_node'
+
+class RubyLsp::Ree::ParsedFilePathLinkNode < RubyLsp::Ree::ParsedLinkNode
+  def link_package_name
+    @name.split('/').first
+  end
+
+  def link_type
+    :file_path
+  end
+
+  def file_path_type?
+    true
+  end
+
+  def import_block_open_location
+    import_arg.opening_loc
+  end
+
+  def import_block_close_location
+    import_arg.closing_loc
+  end
+
+  private
+
+  def parse_name
+    name_arg_node.unescaped
+  end
+
+  def parse_linked_objects
+    @linked_objects = []
+  end
+
+  def import_arg
+    @node.arguments.arguments.detect{ _1.is_a?(Prism::LambdaNode) }
+  end
+
+  def get_import_items
+    return [] unless has_import_section?   
+    return [] unless import_arg.body
+      
+    import_body = import_arg.body.body.first
+    parse_object_link_multiple_imports(import_body)
+  end
+end

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

@@ -0,0 +1,44 @@
+require_relative 'parsed_link_node'
+
+class RubyLsp::Ree::ParsedImportLinkNode < RubyLsp::Ree::ParsedLinkNode
+  def link_package_name
+    from_arg_value || document_package
+  end
+
+  def link_type
+    :import_link
+  end
+
+  def import_link_type?
+    true
+  end
+
+  def import_block_open_location
+    import_arg.opening_loc
+  end
+
+  def import_block_close_location
+    import_arg.closing_loc
+  end
+
+  private
+
+  def parse_name
+    ''
+  end
+
+  def parse_linked_objects
+    @linked_objects = []
+  end
+
+  def import_arg
+    @node.arguments.arguments.detect{ _1.is_a?(Prism::LambdaNode) }
+  end
+
+  def get_import_items
+    return [] unless has_import_section?
+    
+    import_body = import_arg.body.body.first
+    parse_object_link_multiple_imports(import_body)
+  end
+end

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

@@ -1,7 +1,7 @@
 require 'prism'
 
 class RubyLsp::Ree::ParsedLinkNode
-  attr_reader :node, :document_package, :name, :import_items, :from_param
+  attr_reader :node, :document_package, :name, :import_items, :from_param, :linked_objects, :kw_args
 
   FROM_ARG_KEY = 'from'
   IMPORT_ARG_KEY = 'import'
@@ -24,21 +24,36 @@ class RubyLsp::Ree::ParsedLinkNode
     end
   end
 
+  class LinkedObject
+    attr_reader :name, :alias_name, :location
+
+    def initialize(name:, alias_name:, location:)
+      @name = name
+      @alias_name = alias_name
+      @location = location
+    end
+
+    def usage_name
+      return @alias_name if @alias_name
+      @name
+    end
+  end
+
   def initialize(node, document_package = nil)
     @node = node
     @document_package = document_package
     @name = parse_name
 
     parse_params
+    parse_linked_objects
+  end
+
+  def multi_object_link?
+    false
   end
 
   def link_package_name
-    case link_type
-    when :object_name
-      from_arg_value || document_package
-    when :file_path
-      @name.split('/').first
-    end
+    raise "abstract method"
   end
 
   def location
@@ -52,7 +67,6 @@ class RubyLsp::Ree::ParsedLinkNode
 
   def from_arg_value
     return unless @from_param
-
     @from_param.value.respond_to?(:unescaped) ? @from_param.value.unescaped : nil
   end
 
@@ -61,24 +75,19 @@ class RubyLsp::Ree::ParsedLinkNode
   end
 
   def link_type
-    return @link_type if @link_type
-    
-    @link_type = case name_arg_node
-    when Prism::SymbolNode
-      :object_name
-    when Prism::StringNode
-      :file_path
-    else
-      nil
-    end
+    raise "abstract method"
   end
 
   def file_path_type?
-    link_type == :file_path
+    false
   end
 
   def object_name_type?
-    link_type == :object_name
+    false
+  end
+
+  def import_link_type?
+    false
   end
 
   def parse_imports
@@ -90,43 +99,33 @@ class RubyLsp::Ree::ParsedLinkNode
   end
 
   def has_import_section?
-    return false if @node.arguments.arguments.size == 1
-
     !!import_arg
   end
 
+  def has_kwargs?
+    !!@kw_args
+  end
+
   def first_arg_location
     @node.arguments.arguments.first.location
   end
 
   def import_block_open_location
-    if object_name_type?
-      import_arg.value.opening_loc
-    else
-      import_arg.opening_loc
-    end
+    raise "abstract method"
   end
 
   def import_block_close_location
-    # TODO maybe use two classes for link types
-    if object_name_type?
-      import_arg.value.closing_loc
-    else
-      import_arg.closing_loc
-    end
+    raise "abstract method"
+  end
+
+  def has_linked_object?(object_name)
+    @linked_objects.map(&:name).include?(object_name)
   end
 
   private
 
   def parse_name
-    case name_arg_node
-    when Prism::SymbolNode
-      name_arg_node.value
-    when Prism::StringNode
-      name_arg_node.unescaped
-    else
-      ""
-    end
+    raise "abstract method"
   end
 
   def parse_params
@@ -139,35 +138,16 @@ class RubyLsp::Ree::ParsedLinkNode
     @alias_name = @as_param ? @as_param.value.unescaped : nil
   end
 
-  def last_arg
-    @node.arguments.arguments.last
+  def parse_linked_objects
+    raise "abstract method"
   end
 
   def import_arg
-    if object_name_type?
-      last_arg.elements.detect{ _1.key.unescaped == IMPORT_ARG_KEY }
-    else
-      last_arg
-    end
+    raise "abstract method"
   end
 
   def get_import_items
-    return [] if @node.arguments.arguments.size == 1
-    
-    if object_name_type?
-      return [] unless import_arg
-      import_body = import_arg.value.body.body.first
-      parse_object_link_multiple_imports(import_body)
-    elsif last_arg.is_a?(Prism::LambdaNode)
-      return [] unless last_arg.body
-      import_body = last_arg.body.body.first
-      parse_object_link_multiple_imports(import_body)
-    else
-      return []
-    end
-  rescue => e
-    $stderr.puts("can't parse imports: #{e.message}")
-    return []
+    raise "abstract method"
   end
 
   def parse_object_link_multiple_imports(import_body)

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

@@ -0,0 +1,22 @@
+require 'prism'
+require_relative 'parsed_link_node'
+require_relative 'parsed_object_link_node'
+require_relative 'parsed_file_path_link_node'
+require_relative 'parsed_import_link_node'
+
+class RubyLsp::Ree::ParsedLinkNodeBuilder
+  def self.build_from_node(node, package_name)
+    first_arg = node.arguments.arguments.first
+    
+    link_node = if first_arg.is_a?(Prism::SymbolNode)
+      RubyLsp::Ree::ParsedObjectLinkNode.new(node, package_name)
+    elsif first_arg.is_a?(Prism::StringNode)
+      RubyLsp::Ree::ParsedFilePathLinkNode.new(node, package_name)
+    else
+      RubyLsp::Ree::ParsedImportLinkNode.new(node, package_name)
+    end
+
+    link_node.parse_imports
+    link_node
+  end
+end

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

@@ -38,6 +38,10 @@ class RubyLsp::Ree::ParsedMethodNode
     get_method_body(@method_node)
   end
 
+  def full_method_body
+    @method_node.body
+  end
+
   def raised_errors_nested
     return @raised_errors_nested if @raised_errors_nested
     raised = raised_errors

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

@@ -0,0 +1,51 @@
+require_relative 'parsed_link_node'
+
+class RubyLsp::Ree::ParsedObjectLinkNode < RubyLsp::Ree::ParsedLinkNode
+  def multi_object_link?
+    @linked_objects.size > 1
+  end
+
+  def link_package_name
+    from_arg_value || document_package
+  end
+
+  def link_type
+    :object_name
+  end
+
+  def object_name_type?
+    true
+  end
+
+  def import_block_open_location
+    import_arg.value.opening_loc
+  end
+
+  def import_block_close_location
+    import_arg.value.closing_loc
+  end
+
+  private
+
+  def parse_name
+    name_arg_node.value
+  end
+
+  def parse_linked_objects
+    @linked_objects = @node.arguments.arguments.select{ _1.is_a?(Prism::SymbolNode) }.map do |arg|
+      LinkedObject.new(name: arg.unescaped, alias_name: @alias_name, location: arg.location)
+    end
+  end
+
+  def import_arg
+    return unless @kw_args
+    @kw_args.elements.detect{ _1.key.unescaped == IMPORT_ARG_KEY }
+  end
+
+  def get_import_items
+    return [] unless has_import_section?
+    
+    import_body = import_arg.value.body.body.first
+    parse_object_link_multiple_imports(import_body)
+  end
+end

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

@@ -1,5 +1,6 @@
 require_relative 'parsed_base_document'
 require_relative 'parsed_link_node'
+require_relative "body_parsers/links_parser"
 require 'ostruct'
 
 class RubyLsp::Ree::ParsedRspecDocument < RubyLsp::Ree::ParsedBaseDocument
@@ -36,12 +37,7 @@ class RubyLsp::Ree::ParsedRspecDocument < RubyLsp::Ree::ParsedBaseDocument
   end
 
   def parse_links
-    nodes = @describe_node.block.body.body.select{ |node| node.name == :link }
-
-    @link_nodes = nodes.map do |link_node|
-      link_node = RubyLsp::Ree::ParsedLinkNode.new(link_node, package_name)
-      link_node.parse_imports
-      link_node
-    end
+    container = @describe_node.block.body.body
+    @link_nodes = RubyLsp::Ree::LinksParser.new(container, package_name).parse_links
   end
 end

data/lib/ruby_lsp/ruby_lsp_ree/ree_context.rb

@@ -21,13 +21,15 @@ module RubyLsp
       def is_link_object?
         return false unless has_call_parent?
 
-        @node_context.parent.name == :link
+        @node_context.parent.name == :link ||  @node_context.parent.name == :import
       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
+        
+        first_arg = @node_context.parent.arguments.arguments.first
+        return false if @node_context.node.unescaped == symbol_node_name(first_arg)
 
         kw_args = @node_context.parent.arguments.arguments.detect{ |arg| arg.is_a?(Prism::KeywordHashNode) }
         return false unless kw_args
@@ -41,6 +43,11 @@ module RubyLsp
       def has_call_parent?
         @node_context && @node_context.parent && @node_context.parent.is_a?(Prism::CallNode)
       end
+
+      def symbol_node_name(node)
+        return nil unless node.is_a?(Prism::SymbolNode)
+        node.unescaped
+      end
     end
   end
 end

data/lib/ruby_lsp/ruby_lsp_ree/ree_formatter.rb

@@ -54,6 +54,7 @@ module RubyLsp
 
       def detect_missing_error_locales(uri, document)
         parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_source(document.source)
+        return [] unless parsed_doc
 
         locales_folder = package_locales_folder_path(uri.path)
         return [] if !locales_folder || !File.directory?(locales_folder)

data/lib/ruby_lsp/ruby_lsp_ree/ree_source_editor.rb

@@ -13,15 +13,15 @@ module RubyLsp
         @source_lines.join
       end
 
-      def contains_link_usage?(parsed_doc, link_node)
+      def contains_linked_object_usage?(parsed_doc, link_node, linked_object)
         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)
+          return no_receiver_method_names.include?(linked_object.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/)}
+        source_lines_except_link.any?{ |source_line| source_line.match?(/\W#{linked_object.usage_name}\W/)}
       end
 
       def contains_link_import_usage?(parsed_doc, link_node, link_import)
@@ -38,14 +38,38 @@ module RubyLsp
         set_empty_lines_for_location!(link_node.location)
       end
 
+      def remove_linked_objects(link_node, linked_objects)
+        return if linked_objects.size == 0
+
+        if link_node.multi_object_link?
+          set_empty_lines_for_location!(link_node.location)
+          line = link_node.location.start_line - 1
+          offset = link_node.location.start_column - 1
+          offset_str = " " * offset
+          # TODO use renderer class
+          linked_object_names = linked_objects.map(&:name)
+          remaining_objects = link_node.linked_objects.select{ !linked_object_names.include?(_1.name) }
+          source_lines[line] = "#{offset_str}link #{remaining_objects.map{ ":#{_1.name}" }.join(', ')}"
+          if link_node.from_arg_value
+            source_lines[line] += ", from: :#{link_node.from_arg_value}"
+          end
+          source_lines[line] += "\n"
+        else
+          set_empty_lines_for_location!(link_node.location)
+        end
+      end
+
       def remove_link_imports(link_node, link_imports)
+        return if link_imports.size == 0
         imports_str = link_node.import_items.reject{ link_imports.include?(_1.name) }.map(&:to_s).join(' & ')
 
         block_start_col = link_node.import_block_open_location.start_column
         block_line = link_node.import_block_open_location.start_line-1
         block_end_line = link_node.import_block_close_location.end_line-1
+        block_end_col = link_node.import_block_close_location.end_column
+        # TODO use renderer class
 
-        source_lines[block_line] = source_lines[block_line][0..block_start_col] + " #{imports_str} }\n"
+        source_lines[block_line] = source_lines[block_line][0..block_start_col] + " #{imports_str} }" + source_lines[block_end_line][block_end_col..-1]
         set_empty_lines!(block_line+1, block_end_line)
       end
 
@@ -73,6 +97,22 @@ module RubyLsp
         set_empty_lines_for_location!(field.location)
       end
 
+      def cleanup_blank_lines(start_line, end_line)
+        (start_line .. end_line).each do |i|
+          source_lines[i] = '' if source_lines[i].strip == ''
+        end
+      end
+
+      def insert_link_block(parsed_doc, links_text)
+        line = if parsed_doc.links_container_node
+          parsed_doc.links_container_node.location.start_line
+        else
+          parsed_doc.link_nodes.first.location.start_line - 1
+        end
+
+        source_lines[line] = links_text
+      end
+
       def add_links(parsed_doc, ree_objects, current_package)
         new_text = ''
 

data/lib/ruby_lsp/ruby_lsp_ree/renderers/link_renderer.rb

@@ -0,0 +1,130 @@
+module RubyLsp
+  module Ree
+    class LinkRenderer
+      LINE_LENGTH = 80
+
+      def render(link_node)
+        offset = link_node.location.start_column
+        offset_str = " " * offset
+
+        if link_node.object_name_type?
+          render_object_link(link_node, offset_str)
+        elsif link_node.file_path_type?
+          render_file_path_link(link_node, offset_str)
+        elsif link_node.import_link_type?
+          render_import_link(link_node, offset_str)
+        else
+          raise "unknown link type for render"
+        end
+      end
+
+      private
+
+      def render_object_link(link_node, offset_str)
+        link_text = "#{offset_str}link "
+        last_line = link_text
+
+        link_node.linked_objects.each_with_index do |linked_object, index|
+          linked_object_str = ":#{linked_object.name}"
+          last_line = link_text.lines.last
+
+          if index == 0
+            link_text += linked_object_str
+            next
+          end
+
+          if (last_line + ", #{linked_object_str}").size <= LINE_LENGTH
+            link_text += ", #{linked_object_str}"
+          else
+            link_text += ",\n#{offset_str}     #{linked_object_str}"
+          end
+        end
+
+        link_text = render_kwargs(link_text, link_node, offset_str)
+
+        link_text += "\n"
+        link_text
+      end
+
+      def render_file_path_link(link_node, offset_str)
+        link_text = "#{offset_str}link '#{link_node.name}', -> {"
+        link_text = render_imports(link_text, link_node, offset_str)
+       
+        if link_node.has_kwargs?
+          kwargs_str = link_node.kw_args.elements.map{ "#{_1.key.unescaped}: :#{_1.value.unescaped}"}.join(', ')
+          link_text += ", #{kwargs_str}"
+        end
+
+        link_text += "\n"
+        link_text
+      end
+
+      def render_import_link(link_node, offset_str)
+        link_text = "#{offset_str}import -> {"
+        link_text = render_imports(link_text, link_node, offset_str)
+
+        if link_node.has_kwargs?
+          kwargs_str = link_node.kw_args.elements.map{ "#{_1.key.unescaped}: :#{_1.value.unescaped}"}.join(', ')
+          link_text += ", #{kwargs_str}"
+        end
+
+        link_text += "\n"
+        link_text
+      end
+
+      def render_imports(link_text, link_node, offset_str)
+        imports_str = link_node.import_items.map(&:to_s).join(' & ')
+
+        if (link_text+imports_str).size < LINE_LENGTH
+          link_text += " #{imports_str} }"
+        else
+          link_text += "\n"
+
+          imports_str = "#{offset_str}  "
+          last_line = imports_str
+          link_node.import_items.each_with_index do |import_item, index|
+            last_line = imports_str.lines.last
+
+            if index == 0
+              imports_str += import_item.to_s
+              next
+            end
+
+            if (last_line + " & #{import_item.to_s}").size <= LINE_LENGTH
+              imports_str += " & #{import_item.to_s}"
+            else
+              imports_str += " &\n#{offset_str}  #{import_item.to_s}"
+            end
+          end
+
+          link_text += imports_str
+          link_text += "\n#{offset_str}}"
+        end
+
+        link_text
+      end
+
+      def render_kwargs(link_text, link_node, offset_str)
+        return link_text unless link_node.has_kwargs?
+          
+        if link_node.object_name_type? && link_node.has_import_section?
+          link_text += ", import: -> {"          
+          link_text = render_imports(link_text, link_node, offset_str)
+        end
+
+        kwargs_str = link_node.kw_args.elements.reject{ _1.key.unescaped == 'import' }.map{ "#{_1.key.unescaped}: #{value_name(_1)}"}.join(', ')
+        link_text += ", #{kwargs_str}" if kwargs_str.size > 0
+
+        link_text
+      end
+
+      def value_name(elem)
+        if elem.value.respond_to?(:unescaped)
+         ":#{elem.value.unescaped}"
+        else
+          elem.value.name.to_s
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp_ree/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-ree
 version: !ruby/object:Gem::Version
-  version: 0.1.22
+  version: 0.1.24
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-05-30 00:00:00.000000000 Z
+date: 2025-06-27 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby LSP addon that adds extra editor functionality for Ree applications
 email:
@@ -44,17 +44,23 @@ 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/basic_parser.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/links_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
 - lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_dao_document.rb
 - lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_document_builder.rb
 - lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_entity_document.rb
+- lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_file_path_link_node.rb
+- lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_import_link_node.rb
 - lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_link_node.rb
+- lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_link_node_builder.rb
 - lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_method_node.rb
+- lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_object_link_node.rb
 - lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_route_document.rb
 - lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_rspec_document.rb
 - lib/ruby_lsp/ruby_lsp_ree/ree_constants.rb
@@ -66,6 +72,7 @@ files:
 - lib/ruby_lsp/ruby_lsp_ree/ree_rename_handler.rb
 - lib/ruby_lsp/ruby_lsp_ree/ree_source_editor.rb
 - lib/ruby_lsp/ruby_lsp_ree/ree_template_applicator.rb
+- lib/ruby_lsp/ruby_lsp_ree/renderers/link_renderer.rb
 - lib/ruby_lsp/ruby_lsp_ree/utils/ree_locale_utils.rb
 - lib/ruby_lsp/ruby_lsp_ree/utils/ree_lsp_utils.rb
 - lib/ruby_lsp/ruby_lsp_ree/utils/yaml_file_parser.rb