ruby-lsp-ree 0.1.13 → 0.1.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 830eb15946648bcdb6d03779678f3a4ed0d1f25081bf948d9951496b050a51b0
-  data.tar.gz: 6fb752c0d447d1e5a3e4d680b24ff8295555af253875d95498430951d872e919
+  metadata.gz: 7f3673076ca0aee98f0f92d6db25a2939ae21a58464a70e1a1e534bfef3458d0
+  data.tar.gz: 2191d354bbe75911cc230ca20665e5882e15eabee5de30801db1960990d42c3b
 SHA512:
-  metadata.gz: 9766f1c674d1a3d695db8f181931c72d76993c46133d733e92f996c3d016d66bcc2b158f29a4e231b6dc39d5754b0586b9714496e13cb0d365169a96841d6626
-  data.tar.gz: b2883d1193a0039850fc343e2baf6aea0e374b08fbd1dc8c04e44c76f9c16a3fb4a755269b33e260e7a38dc7d0ff2f8d9fcb90b24d83bf0d1b242a82560bfdd6
+  metadata.gz: ec2b1c6e15509e7e8f18758ef3a6912c14dccbdc6348d353331894fc53efbd072b043e49b1ee933c2b552e11404a4f322f8336aa29f267f3a842724d67fc8d7a
+  data.tar.gz: c584181adbf4ed1a02dc2545c1b65cf4ada307ade2d46aee661a97319adf43d67e6d21bb47f7b05d73bc4a2b913053ca990cae0cf1722587c350be942151e385

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.1.15] - 2025-04-18
+
+- autocomplete - don't overwrite existing arguments
+- unused links formatter - handle const aliases
+
+## [0.1.14] - 2025-04-15
+
+- do not create error definition for defined class
+- added formatter config settings
+- formatter: remove unused imports
+- fixed adding `throws` section to contract without parentheses
+
 ## [0.1.13] - 2025-04-04
 
 - Go To Definition for action and serializers in routes

data/Gemfile.lock

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

data/README.md

@@ -10,6 +10,8 @@ Ree addon for Ruby LSP
 If everything was installed successfully, you should see Ree in the list of Ruby LSP addons.
 (In VS Code click `{}` brackets in the bottom right corner)
 
+## Formatter
+
 To use ree_formatter, add the following line into your `settings.json` file (e.g. `.vscode/settings.json`)
 ```json
 "rubyLsp.formatter": "ree_formatter"
@@ -20,6 +22,18 @@ To use diagnostics, add the following line into your `settings.json` file (e.g.
 "rubyLsp.linters": ["ree_formatter"]
 ```
 
+To switch off/on formatter features, use Ruby LSP addon settings:
+```json
+"rubyLsp.addonSettings": {
+    "Ree Addon": {
+      "formatter": {
+        "MissingErrorLocalesFormatter": false
+      }
+    }
+  }
+```
+available formatters: `SortLinksFormatter`, `MissingErrorDefinitionsFormatter`, `MissingErrorContractsFormatter`, `MissingErrorLocalesFormatter`, `UnusedLinksFormatter`
+
 ## Functions
 
 - autocomplete for Ree objects
@@ -28,4 +42,5 @@ To use diagnostics, add the following line into your `settings.json` file (e.g.
 - sort links on document save or format (with ree_formatter enabled)
 - missing error locales detection
 - Go To Definition for Ree objects
-- hover information for Ree objects and error locales
+- hover information for Ree objects and error locales
+- Ree templates support

data/lib/ruby_lsp/ruby_lsp_ree/addon.rb

@@ -15,10 +15,17 @@ module RubyLsp
     class Addon < ::RubyLsp::Addon
       def activate(global_state, message_queue)
         @global_state = global_state
+        @settings = global_state.settings_for_addon(name) || {}
+
         @message_queue = message_queue
         @template_applicator = RubyLsp::Ree::ReeTemplateApplicator.new
+        
+        global_state.register_formatter("ree_formatter", RubyLsp::Ree::ReeFormatter.new(
+          @message_queue, 
+          @settings[:formatter], 
+          @global_state.index
+        ))
 
-        global_state.register_formatter("ree_formatter", RubyLsp::Ree::ReeFormatter.new(@message_queue))
         register_additional_file_watchers(global_state, message_queue)
       end
 

data/lib/ruby_lsp/ruby_lsp_ree/completion/completion_items_mapper.rb

@@ -0,0 +1,183 @@
+require_relative 'method_additional_text_edits_creator'
+require_relative 'const_additional_text_edits_creator'
+
+module RubyLsp
+  module Ree
+    class CompletionItemsMapper
+      include Requests::Support::Common
+      include RubyLsp::Ree::ReeLspUtils
+
+      def initialize(index)
+        @index = index
+      end
+
+      def map_ree_object_methods(ree_object_methods, location, node, description)
+        default_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),
+        )
+
+        ree_object_methods.map do |object_method|
+          signature = object_method.signatures&.first
+
+          label_details = Interface::CompletionItemLabelDetails.new(
+            description: description,
+            detail: get_detail_string(signature)
+          )
+
+          if node.arguments && node.name.to_s == object_method.name
+            new_text = object_method.name
+            method_range = range_from_location(node.message_loc)
+          else
+            new_text = get_method_string(object_method.name, signature)
+            method_range = default_range
+          end
+
+          Interface::CompletionItem.new(
+            label: object_method.name,
+            label_details: label_details,
+            filter_text: object_method.name,
+            text_edit: Interface::TextEdit.new(
+              range:  method_range,
+              new_text: new_text
+            ),
+            kind: Constant::CompletionItemKind::METHOD,
+            insert_text_format: Constant::InsertTextFormat::SNIPPET,
+            data: {
+              owner_name: "Object",
+              guessed_type: false,
+            }
+          )
+        end
+      end
+
+      def map_ree_objects(ree_objects, node, parsed_doc)
+        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)
+          )
+
+          if node.arguments && node.name.to_s == ree_object_name
+            new_text = ree_object_name
+            range = range_from_location(node.message_loc)
+          else
+            new_text = get_method_string(ree_object_name, signature)
+            range = range_from_location(node.location)
+          end
+
+          Interface::CompletionItem.new(
+            label: ree_object_name,
+            label_details: label_details,
+            filter_text: ree_object_name,
+            text_edit: Interface::TextEdit.new(
+              range:  range,
+              new_text: new_text
+            ),
+            kind: Constant::CompletionItemKind::METHOD,
+            insert_text_format: Constant::InsertTextFormat::SNIPPET,
+            data: {
+              owner_name: "Object",
+              guessed_type: false,
+            },
+            additional_text_edits: MethodAdditionalTextEditsCreator.call(parsed_doc, ree_object_name, package_name)
+          )
+        end
+      end
+
+      def map_class_name_objects(class_name_objects, node, parsed_doc)
+        imported_consts = []
+        not_imported_consts = []
+
+        class_name_objects.each do |full_class_name|
+          entries = @index[full_class_name]
+
+          entries.each do |entry|
+            class_name = full_class_name.split('::').last
+            package_name = package_name_from_uri(entry.uri)
+            file_name = File.basename(entry.uri.to_s)
+            entry_comment = entry.comments && entry.comments.size > 0 ? " (#{entry.comments})" : ''
+
+            matched_import = parsed_doc.find_import_for_package(class_name, package_name)
+
+            if matched_import   
+              label_details = Interface::CompletionItemLabelDetails.new(
+                description: "imported from: :#{package_name}",
+                detail: entry_comment
+              )
+              
+              imported_consts << 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: []
+              )
+            else
+              label_details = Interface::CompletionItemLabelDetails.new(
+                description: "from: :#{package_name}",
+                detail: entry_comment + " #{file_name}"
+              )
+
+              not_imported_consts << 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: ConstAdditionalTextEditsCreator.call(parsed_doc, class_name, package_name, entry)
+              )
+            end
+          end
+        end
+
+        imported_consts + not_imported_consts
+      end
+
+      private
+
+      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
+    end
+  end
+end

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

@@ -1,12 +1,16 @@
 module RubyLsp
   module Ree
     class BaseFormatter
-      def self.call(source, uri, message_queue)
-        new(message_queue).call(source, uri)
+      def self.call(source, uri, message_queue, index)
+        new(message_queue, index).call(source, uri)
+      rescue => e
+        $stderr.puts("error in #{self.class}: #{e.message} : #{e.backtrace.first}")
+        source
       end
 
-      def initialize(message_queue)
+      def initialize(message_queue, index)
         @message_queue = message_queue
+        @index = index
       end
 
       def call(source, uri)

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

@@ -5,7 +5,7 @@ module RubyLsp
     class MissingErrorContractsFormatter < BaseFormatter
       def call(source, _uri)
         parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_source(source)
-        return source if !parsed_doc || !parsed_doc.class_node
+        return source if !parsed_doc || !parsed_doc.has_root_class?
 
         parsed_doc.parse_error_definitions
         parsed_doc.parse_instance_methods
@@ -40,10 +40,19 @@ module RubyLsp
             source_lines[line] = source_lines[line][0..position] + ", #{missed_errors.join(', ')}\n"
           end
         else
-          position = doc_instance_method.contract_node_end_position
-          line = doc_instance_method.contract_node_end_line
+          if doc_instance_method.contract_in_parentheses?
+            position = doc_instance_method.contract_node_end_position
+            line = doc_instance_method.contract_node_end_line
 
-          source_lines[line] = source_lines[line][0..position] + ".throws(#{missed_errors.join(', ')})\n"
+            source_lines[line] = source_lines[line][0..position] + ".throws(#{missed_errors.join(', ')})\n"
+          else
+            contract_end_position = doc_instance_method.contract_node_contract_end_position
+            start_line = doc_instance_method.contract_node_start_line
+            end_line = doc_instance_method.contract_node_end_line
+
+            source_lines[start_line] = source_lines[start_line][0..contract_end_position] + "(" + source_lines[start_line][contract_end_position+1..-1].lstrip
+            source_lines[end_line] = source_lines[end_line].chomp + ").throws(#{missed_errors.join(', ')})\n"
+          end
         end
 
         source_lines.join

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

@@ -7,13 +7,18 @@ module RubyLsp
 
       def call(source, _uri)
         parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_source(source)
-        return source if !parsed_doc || !parsed_doc.class_node
+        return source if !parsed_doc || !parsed_doc.has_root_class?
 
         parsed_doc.parse_error_definitions
         parsed_doc.parse_instance_methods
         parsed_doc.parse_links
+        parsed_doc.parse_defined_classes
+        parsed_doc.parse_defined_consts
 
-        existing_errors = parsed_doc.error_definition_names + parsed_doc.imported_constants
+        existing_error_classes = parsed_doc.error_definition_names + 
+          parsed_doc.imported_constants + 
+          parsed_doc.defined_classes + 
+          parsed_doc.defined_consts
 
         missed_errors = []
         parsed_doc.doc_instance_methods.each do |doc_instance_method|
@@ -21,7 +26,7 @@ module RubyLsp
 
           raised_errors = doc_instance_method.raised_errors_nested
 
-          missed_errors += raised_errors - existing_errors
+          missed_errors += raised_errors - existing_error_classes
         end
 
         missed_errors = missed_errors.uniq.reject{ Object.const_defined?(_1) }

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

@@ -10,6 +10,7 @@ module RubyLsp
 
       def call(source, uri)
         parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_source(source)
+        return source if !parsed_doc || !parsed_doc.has_root_class?
 
         locales_folder = package_locales_folder_path(get_uri_path(uri))
         return source if !locales_folder || !File.directory?(locales_folder)

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

@@ -0,0 +1,62 @@
+require_relative 'base_formatter'
+require_relative '../ree_source_editor'
+require_relative '../ree_dsl_parser'
+
+module RubyLsp
+  module Ree
+    class UnusedLinksFormatter < BaseFormatter
+      include RubyLsp::Ree::ReeLspUtils
+
+      attr_reader :editor, :dsl_parser
+
+      def call(source, _uri)
+        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_source(source)
+        return source if !parsed_doc
+
+        parsed_doc.parse_links
+
+        @editor = RubyLsp::Ree::ReeSourceEditor.new(source)
+        @dsl_parser = RubyLsp::Ree::ReeDslParser.new(parsed_doc, @index)
+
+        links_count = parsed_doc.link_nodes.size
+
+        removed_links = 0
+
+        parsed_doc.link_nodes.each do |link_node|
+          remove_imports = []
+
+          if link_node.has_import_section?
+            remove_imports = link_node.imports.reject{ |imp| import_is_used?(link_node, imp) }
+            editor.remove_link_imports(link_node, remove_imports)
+
+            if link_node.imports.size == remove_imports.size
+              editor.remove_link_import_arg(link_node)
+            end
+          end
+
+          next if link_is_used?(link_node, remove_imports)
+
+          editor.remove_link(link_node)
+          removed_links += 1
+        end
+
+        if removed_links == links_count
+          parsed_doc.parse_links_container_node
+          editor.remove_link_block(parsed_doc.links_container_node, parsed_doc.links_container_block_node)
+        end
+
+        editor.source
+      end
+
+      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)
+      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)
+      end
+    end
+  end
+end

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

@@ -1,7 +1,6 @@
 require_relative "../utils/ree_lsp_utils"
 require_relative "../ree_object_finder"
-require_relative 'const_additional_text_edits_creator'
-require_relative 'method_additional_text_edits_creator'
+require_relative '../completion/completion_items_mapper'
 
 module RubyLsp
   module Ree
@@ -18,6 +17,7 @@ module RubyLsp
         @node_context = node_context
         @root_node = @node_context.instance_variable_get(:@nesting_nodes).first
         @finder = ReeObjectFinder.new(@index)
+        @mapper = RubyLsp::Ree::CompletionItemsMapper.new(@index)
       end
 
       def get_ree_receiver(receiver_node)
@@ -31,115 +31,30 @@ module RubyLsp
 
         case @finder.object_type(ree_receiver)
         when :enum
-          get_enum_values_completion_items(ree_receiver, location)
+          get_enum_values_completion_items(ree_receiver, location, node)
         when :bean, :async_bean
-          get_bean_methods_completion_items(ree_receiver, location)
+          get_bean_methods_completion_items(ree_receiver, location, node)
         when :dao
-          get_dao_filters_completion_items(ree_receiver, location)
+          get_dao_filters_completion_items(ree_receiver, location, node)
         else
           []
         end
       end
 
-      def get_bean_methods_completion_items(bean_obj, location)
+      def get_bean_methods_completion_items(bean_obj, location, node)
         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
+        @mapper.map_ree_object_methods(bean_node.bean_methods, location, node, "method")
       end
 
-      def get_dao_filters_completion_items(dao_obj, location)
+      def get_dao_filters_completion_items(dao_obj, location, node)
         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
+        @mapper.map_ree_object_methods(dao_node.filters, location, node, "filter")
       end
 
-      def get_enum_values_completion_items(enum_obj, location)
+      def get_enum_values_completion_items(enum_obj, location, node)
         enum_node = RubyLsp::Ree::ParsedDocumentBuilder.build_from_uri(enum_obj.uri, :enum)
-
         class_name = enum_node.full_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
+        @mapper.map_ree_object_methods(enum_node.values, location, node, "from: #{class_name}")
       end
 
       def get_class_name_completion_items(node)
@@ -150,59 +65,7 @@ module RubyLsp
 
         parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_ast(@root_node, @uri)
 
-        imported_consts = []
-        not_imported_consts = []
-
-        class_name_objects.take(CANDIDATES_LIMIT).each do |full_class_name|
-          entries = @index[full_class_name]
-
-          entries.each do |entry|
-            class_name = full_class_name.split('::').last
-            package_name = package_name_from_uri(entry.uri)
-            file_name = File.basename(entry.uri.to_s)
-            entry_comment = entry.comments && entry.comments.size > 0 ? " (#{entry.comments})" : ''
-
-            matched_import = parsed_doc.find_import_for_package(class_name, package_name)
-
-            if matched_import   
-              label_details = Interface::CompletionItemLabelDetails.new(
-                description: "imported from: :#{package_name}",
-                detail: entry_comment
-              )
-              
-              imported_consts << 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: []
-              )
-            else
-              label_details = Interface::CompletionItemLabelDetails.new(
-                description: "from: :#{package_name}",
-                detail: entry_comment + " #{file_name}"
-              )
-
-              not_imported_consts << 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: ConstAdditionalTextEditsCreator.call(parsed_doc, class_name, package_name, entry)
-              )
-            end
-          end
-        end
-
-        imported_consts + not_imported_consts
+        @mapper.map_class_name_objects(class_name_objects.take(CANDIDATES_LIMIT), node, parsed_doc)
       end
 
       def get_ree_objects_completions_items(node)
@@ -212,65 +75,7 @@ module RubyLsp
   
         parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_ast(@root_node, @uri)
 
-        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: MethodAdditionalTextEditsCreator.call(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(', ')
+        @mapper.map_ree_objects(ree_objects, node, parsed_doc)
       end
     end
   end

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

@@ -24,6 +24,10 @@ class RubyLsp::Ree::ParsedBaseDocument
     false
   end
 
+  def includes_ree_dsl?
+    false
+  end
+
   def includes_linked_object?(obj_name)
     @link_nodes.map(&:name).include?(obj_name)
   end

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

@@ -10,7 +10,8 @@ class RubyLsp::Ree::ParsedClassDocument < RubyLsp::Ree::ParsedBaseDocument
 
   attr_reader :class_node, :class_includes, 
     :values, :filters, :bean_methods, :links_container_block_node, :error_definitions, 
-    :error_definition_names, :doc_instance_methods, :links_container_node
+    :error_definition_names, :doc_instance_methods, :links_container_node, 
+    :defined_classes, :defined_consts
 
   def initialize(ast, package_name = nil)
     super
@@ -37,6 +38,10 @@ class RubyLsp::Ree::ParsedClassDocument < RubyLsp::Ree::ParsedBaseDocument
     @class_includes.any?{ node_name(_1) == ROUTES_DSL_MODULE }
   end
 
+  def includes_ree_dsl?
+    ree_dsls.size > 0
+  end
+
   def includes_linked_constant?(const_name)
     @link_nodes.map(&:imports).flatten.include?(const_name)
   end
@@ -106,7 +111,7 @@ class RubyLsp::Ree::ParsedClassDocument < RubyLsp::Ree::ParsedBaseDocument
 
     @link_nodes = nodes.map do |link_node|
       link_node = RubyLsp::Ree::ParsedLinkNode.new(link_node, package_name)
-      link_node.parse_imports
+      link_node.parse_imports # TODO move parse imports inside link_node constructor
       link_node
     end
   end
@@ -179,6 +184,24 @@ class RubyLsp::Ree::ParsedClassDocument < RubyLsp::Ree::ParsedBaseDocument
     @error_definition_names = @error_definitions.map(&:name)
   end
 
+  def parse_defined_classes
+    @defined_classes = []
+    return unless has_body?
+
+    @defined_classes = class_node.body.body
+      .select{ _1.is_a?(Prism::ClassNode) }
+      .map(&:name)
+  end
+    
+  def parse_defined_consts
+    @defined_consts = []
+    return unless has_body?
+
+    @defined_consts += class_node.body.body
+      .select{ _1.is_a?(Prism::ConstantWriteNode) }
+      .map(&:name)
+  end
+
   def class_name
     class_node.constant_path.name.to_s
   end
@@ -199,4 +222,8 @@ class RubyLsp::Ree::ParsedClassDocument < RubyLsp::Ree::ParsedBaseDocument
   def imported_constants
     @link_nodes.map(&:imports).flatten.map(&:to_sym)
   end
+
+  def ree_dsls
+    @class_includes.select{ node_name(_1).downcase.match?(/ree/) && node_name(_1).downcase.match?(/dsl/)}
+  end
 end

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

@@ -1,11 +1,28 @@
 require 'prism'
 
 class RubyLsp::Ree::ParsedLinkNode
-  attr_reader :node, :document_package, :name, :imports
+  attr_reader :node, :document_package, :name, :import_items
 
   FROM_ARG_KEY = 'from'
   IMPORT_ARG_KEY = 'import'
 
+  class ImportItem
+    attr_reader :name, :original_name
+
+    def initialize(name:, original_name: nil)
+      @name = name
+      @original_name = original_name
+    end
+
+    def to_s
+      if @original_name
+        "#{@original_name}.as(#{@name})"
+      else
+        @name
+      end
+    end
+  end
+
   def initialize(node, document_package = nil)
     @node = node
     @document_package = document_package
@@ -72,7 +89,11 @@ class RubyLsp::Ree::ParsedLinkNode
   end
 
   def parse_imports
-    @imports ||= get_imports
+    @import_items ||= get_import_items
+  end
+
+  def imports
+    @import_items.map(&:name)
   end
 
   def has_import_section?
@@ -81,6 +102,27 @@ class RubyLsp::Ree::ParsedLinkNode
     !!import_arg
   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
+  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
+  end
+
   private
 
   def last_arg
@@ -95,14 +137,17 @@ class RubyLsp::Ree::ParsedLinkNode
     end
   end
 
-  def get_imports
+  def get_import_items
     return [] if @node.arguments.arguments.size == 1
     
     if object_name_type?
       return [] unless import_arg
-      [import_arg.value.body.body.first.name.to_s]
+      import_body = import_arg.value.body.body.first
+      parse_object_link_multiple_imports(import_body)
     elsif last_arg.is_a?(Prism::LambdaNode)
-      [last_arg.body.body.first.name.to_s]
+      return [] unless last_arg.body
+      import_body = last_arg.body.body.first
+      parse_object_link_multiple_imports(import_body)
     else
       return []
     end
@@ -110,4 +155,19 @@ class RubyLsp::Ree::ParsedLinkNode
     $stderr.puts("can't parse imports: #{e.message}")
     return []
   end
+
+  def parse_object_link_multiple_imports(import_body)
+    if import_body.is_a?(Prism::CallNode) && import_body.name == :&
+      parse_object_link_multiple_imports(import_body.receiver) + parse_object_link_multiple_imports(import_body.arguments.arguments.first)
+    elsif import_body.is_a?(Prism::CallNode) && import_body.name == :as
+      [
+        ImportItem.new(
+          name: import_body.arguments.arguments.first.name.to_s,
+          original_name: import_body.receiver.name.to_s
+        )
+      ]
+    else 
+      [ ImportItem.new(name: import_body.name.to_s) ]
+    end
+  end
 end

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

@@ -82,6 +82,18 @@ class RubyLsp::Ree::ParsedMethodNode
   def contract_node_end_line
     @contract_node.location.end_line - 1
   end
+
+  def contract_node_start_line
+    @contract_node.location.start_line - 1
+  end
+
+  def contract_node_contract_end_position
+    @contract_node.message_loc.end_column - 1
+  end
+
+  def contract_in_parentheses?
+    @contract_node.opening == '(' && @contract_node.closing == ')'
+  end
   
   def parse_nested_local_methods(local_methods)
     unless @method_node.body
@@ -91,9 +103,9 @@ class RubyLsp::Ree::ParsedMethodNode
 
     method_body = get_method_body(@method_node)
 
-    local_method_names = local_methods.map(&:name)
     call_nodes = parse_body_call_objects(method_body)
-    call_node_names = call_nodes.map(&:name)
+    call_expressions = parse_body_call_expressions(method_body)
+    call_node_names = call_nodes.map(&:name) + call_expressions
    
     @nested_local_methods = local_methods.select{ call_node_names.include?(_1.name) }
     @nested_local_methods.each{ _1.parse_nested_local_methods(local_methods) }
@@ -107,7 +119,7 @@ class RubyLsp::Ree::ParsedMethodNode
         call_nodes << node
       elsif node.respond_to?(:statements)
         call_nodes += parse_body_call_objects(node.statements.body)
-      elsif node.respond_to?(:block) && node.block 
+      elsif node.respond_to?(:block) && node.block && node.block.is_a?(Prism::BlockNode)
         call_nodes += parse_body_call_objects(get_method_body(node.block))
       end
     end
@@ -115,6 +127,18 @@ class RubyLsp::Ree::ParsedMethodNode
     call_nodes
   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 << node.block.expression.unescaped.to_sym
+      end
+    end
+
+    call_expressions
+  end
+
   def get_method_body(node)
     if node.body.is_a?(Prism::BeginNode)
       node.body.statements.body

data/lib/ruby_lsp/ruby_lsp_ree/ree_dsl_parser.rb

@@ -0,0 +1,39 @@
+module RubyLsp
+  module Ree
+    class ReeDslParser
+      include RubyLsp::Ree::ReeLspUtils
+
+      attr_reader :parsed_doc
+
+      def initialize(parsed_doc, index)
+        @parsed_doc = parsed_doc
+        @index = index
+      end
+
+      def contains_object_usage?(obj_name)
+        return false unless @index
+        return false unless parsed_doc.includes_ree_dsl?
+
+        parsed_doc.ree_dsls.any? do |ree_dsl|
+          ree_dsl_contains_object_usage?(ree_dsl.name, obj_name)
+        end
+      end
+
+      private
+
+      def ree_dsl_contains_object_usage?(dsl_name, obj_name)
+        dsl_objects = @index[dsl_name]
+        return unless dsl_objects
+
+        uris = dsl_objects.map(&:uri)
+
+        uris.any?{ file_contains_object_usage?(_1, obj_name) }
+      end
+
+      def file_contains_object_usage?(file_uri, obj_name) 
+        file_content = File.read(file_uri.path.to_s)
+        file_content.match?(/\W#{obj_name}\W/)
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_ree/ree_formatter.rb

@@ -2,6 +2,7 @@ require_relative 'formatters/sort_links_formatter'
 require_relative 'formatters/missing_error_definitions_formatter'
 require_relative 'formatters/missing_error_contracts_formatter'
 require_relative 'formatters/missing_error_locales_formatter'
+require_relative 'formatters/unused_links_formatter'
 
 module RubyLsp
   module Ree
@@ -12,8 +13,10 @@ module RubyLsp
 
       MISSING_LOCALE_PLACEHOLDER = '_MISSING_LOCALE_'
 
-      def initialize(message_queue)
+      def initialize(message_queue, settings, index = nil)
         @message_queue = message_queue
+        @settings = settings || {}
+        @index = index
       end
 
       def run_formatting(uri, document)
@@ -23,10 +26,14 @@ module RubyLsp
           RubyLsp::Ree::SortLinksFormatter,
           RubyLsp::Ree::MissingErrorDefinitionsFormatter,
           RubyLsp::Ree::MissingErrorContractsFormatter,
-          RubyLsp::Ree::MissingErrorLocalesFormatter
-        ]
+          RubyLsp::Ree::MissingErrorLocalesFormatter,
+          RubyLsp::Ree::UnusedLinksFormatter,
+        ].select do |formatter|
+          formatter_name = formatter.name.split('::').last.to_sym
+          @settings[formatter_name] != false
+        end
 
-        formatters.reduce(source){ |s, formatter| formatter.call(s, uri, @message_queue) }
+        formatters.reduce(source){ |s, formatter| formatter.call(s, uri, @message_queue, @index) }
       rescue => e
         $stderr.puts("error in ree_formatter: #{e.message} : #{e.backtrace.first}")
       end

data/lib/ruby_lsp/ruby_lsp_ree/ree_source_editor.rb

@@ -0,0 +1,68 @@
+module RubyLsp
+  module Ree
+    class ReeSourceEditor
+      include RubyLsp::Ree::ReeLspUtils
+
+      attr_reader :source_lines
+
+      def initialize(source)
+        @source_lines = source.lines
+      end
+
+      def source
+        @source_lines.join
+      end
+
+      def contains_link_usage?(link_node)
+        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/)}
+      end
+
+      def contains_link_import_usage?(link_node, link_import)
+        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)
+      end
+
+      def remove_link_imports(link_node, link_imports)
+        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
+
+        source_lines[block_line] = source_lines[block_line][0..block_start_col] + " #{imports_str} }\n"
+        set_empty_lines!(block_line+1, block_end_line)
+      end
+
+      def remove_link_import_arg(link_node)
+        link_line = link_node.location.start_line - 1
+        link_end_line = link_node.location.end_line - 1
+        link_name_end = link_node.first_arg_location.end_column - 1
+
+        source_lines[link_line] = source_lines[link_line][0..link_name_end] + "\n"
+        set_empty_lines!(link_line+1, link_end_line)
+      end
+
+      def remove_link_block(links_container_node, links_container_block_node)
+        return source_lines unless links_container_block_node
+        
+        link_container_start_line = links_container_node.location.start_line-1
+        link_container_end_line = links_container_node.location.end_line-1
+        block_start = links_container_block_node.location.start_column-1
+
+        source_lines[link_container_start_line] = source_lines[link_container_start_line][0..block_start] + "\n"
+        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
+      end
+    end
+  end
+end

data/lib/ruby_lsp_ree/version.rb

@@ -2,6 +2,6 @@
 
 module RubyLsp
   module Ree
-    VERSION = "0.1.13"
+    VERSION = "0.1.15"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-ree
 version: !ruby/object:Gem::Version
-  version: 0.1.13
+  version: 0.1.15
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-04-04 00:00:00.000000000 Z
+date: 2025-04-18 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby LSP addon that adds extra editor functionality for Ree applications
 email:
@@ -26,16 +26,18 @@ files:
 - README.md
 - Rakefile
 - lib/ruby_lsp/ruby_lsp_ree/addon.rb
+- lib/ruby_lsp/ruby_lsp_ree/completion/completion_items_mapper.rb
+- lib/ruby_lsp/ruby_lsp_ree/completion/const_additional_text_edits_creator.rb
+- lib/ruby_lsp/ruby_lsp_ree/completion/method_additional_text_edits_creator.rb
 - lib/ruby_lsp/ruby_lsp_ree/formatters/base_formatter.rb
 - lib/ruby_lsp/ruby_lsp_ree/formatters/missing_error_contracts_formatter.rb
 - lib/ruby_lsp/ruby_lsp_ree/formatters/missing_error_definitions_formatter.rb
 - lib/ruby_lsp/ruby_lsp_ree/formatters/missing_error_locales_formatter.rb
 - lib/ruby_lsp/ruby_lsp_ree/formatters/sort_links_formatter.rb
+- lib/ruby_lsp/ruby_lsp_ree/formatters/unused_links_formatter.rb
 - lib/ruby_lsp/ruby_lsp_ree/handlers/completion_handler.rb
-- lib/ruby_lsp/ruby_lsp_ree/handlers/const_additional_text_edits_creator.rb
 - lib/ruby_lsp/ruby_lsp_ree/handlers/definition_handler.rb
 - lib/ruby_lsp/ruby_lsp_ree/handlers/hover_handler.rb
-- lib/ruby_lsp/ruby_lsp_ree/handlers/method_additional_text_edits_creator.rb
 - 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
@@ -48,10 +50,12 @@ files:
 - lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_rspec_document.rb
 - lib/ruby_lsp/ruby_lsp_ree/ree_constants.rb
 - lib/ruby_lsp/ruby_lsp_ree/ree_context.rb
+- lib/ruby_lsp/ruby_lsp_ree/ree_dsl_parser.rb
 - lib/ruby_lsp/ruby_lsp_ree/ree_formatter.rb
 - lib/ruby_lsp/ruby_lsp_ree/ree_indexing_enhancement.rb
 - lib/ruby_lsp/ruby_lsp_ree/ree_object_finder.rb
 - 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/utils/ree_locale_utils.rb
 - lib/ruby_lsp/ruby_lsp_ree/utils/ree_lsp_utils.rb