ruby-lsp-ree 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c8f904d1cf98e1106296f608f265999c5c606fc83473d3e65a05395dd83ace5
-  data.tar.gz: daba84c44a1bf697f80ec7589ab0a9a436af14aa5d9d8cc6cb12377623de5e8f
+  metadata.gz: 8d8bf3dfcc23d881b4bc1248851b63de1073b810186baeebe6d60894ea6c366a
+  data.tar.gz: fe3e91cb35202109f9884bfb523d473b7d54921ae839299d4201b782ea6ee0ee
 SHA512:
-  metadata.gz: 318c26fe57dcc12ac7a2209c10abd65b5662034e00eb87fea1a2ea58107ccd955db3b1e22a40c80f0a92e1ff10fef0f27c5a1ed3964b7877daa15dd5c64c61d4
-  data.tar.gz: 13c136bd68c1aa9f505a79b94d6f30b713e4e7f24b22a2157c5ccdadc1300d57e27fd7fb4bc5d75f55e7a441125dccf10d6923048948ec416616d7dd723936b1
+  metadata.gz: 9fc76ea86567ce249f96af8a5d50732c9f23b1dd8e0f0a307ce82d7e74234cef0e908d3cd0ad644b6f5617ab4c3f450a26a9dfe707907a46e0009a12b920b206
+  data.tar.gz: 507f4c378489292422e1560cfda1bfe6e3d4fc8cf8642f3f8786e0d75d389b0a9a4881b035da089ede1a8f90377f0016590441b740b5f207eae1c74b143b6f11

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.1.7] - 2025-03-14
+
+- Go To Definition for ree errors into locales
+- hover for ree error locales
+- formatter: add raised ree errors to `throws` section
+
+## [0.1.6] - 2025-03-04
+
+- file rename triggers class name change
+- add documentation string to hover
+- add hover on link section beans
+
 ## [0.1.5] - 2025-02-28
 
 - improved hover format

data/Gemfile.lock

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

data/lib/ruby_lsp/ruby_lsp_ree/addon.rb

@@ -6,6 +6,7 @@ require_relative "ree_indexing_enhancement"
 require_relative "utils/ree_lsp_utils"
 require_relative "ree_formatter"
 require_relative "ree_template_applicator"
+require_relative "ree_rename_handler"
 require_relative "parsing/parsed_document_builder"
 
 module RubyLsp
@@ -46,8 +47,6 @@ module RubyLsp
         # Clients are not required to implement this capability
         return unless global_state.supports_watching_files
         
-        return unless @template_applicator.template_dir_exists?
-
         message_queue << Request.new(
           id: "ruby-lsp-ree-file-create-watcher",
           method: "client/registerCapability",
@@ -60,7 +59,7 @@ module RubyLsp
                   watchers: [
                     Interface::FileSystemWatcher.new(
                       glob_pattern: "**/*.rb",
-                      kind: Constant::WatchKind::CREATE,
+                      kind: Constant::WatchKind::CREATE | Constant::WatchKind::CHANGE,
                     ),
                   ],
                 ),
@@ -71,10 +70,16 @@ module RubyLsp
       end
 
       def workspace_did_change_watched_files(changes)
-        $stderr.puts("workspace_did_change_watched_files #{changes.inspect}")
+        if changes.size == 1 && changes[0][:type] == Constant::FileChangeType::CREATED
+          $stderr.puts("file created #{changes[0][:uri]}")
+
+          return unless @template_applicator.template_dir_exists?
 
-        changes.each do |change_item|
-          @template_applicator.apply(change_item)
+          @template_applicator.apply(changes[0])
+        elsif changes.size == 2 && changes.any?{ _1[:type] == Constant::FileChangeType::CREATED } && changes.any?{ _1[:type] == Constant::FileChangeType::DELETED }
+          $stderr.puts("file renamed #{changes[0][:uri]} #{changes[1][:uri]}")
+  
+          RubyLsp::Ree::ReeRenameHandler.call(changes)
         end
       end
     end

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

@@ -110,7 +110,7 @@ module RubyLsp
       def get_enum_values_completion_items(enum_obj, location)
         enum_node = RubyLsp::Ree::ParsedDocumentBuilder.build_from_uri(enum_obj.uri, :enum)
 
-        class_name = enum_node.get_class_name
+        class_name = enum_node.full_class_name
 
         label_details = Interface::CompletionItemLabelDetails.new(
           description: "from: #{class_name}",

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

@@ -2,17 +2,20 @@ require_relative "../utils/ree_lsp_utils"
 require_relative "../ree_object_finder"
 require_relative "../parsing/parsed_link_node"
 require_relative "../parsing/parsed_document_builder"
+require_relative "../utils/ree_locale_utils"
 
 module RubyLsp
   module Ree
     class DefinitionHandler
       include Requests::Support::Common
       include RubyLsp::Ree::ReeLspUtils
+      include RubyLsp::Ree::ReeLocaleUtils
 
       def initialize(index, uri, node_context)
         @index = index
         @uri = uri
         @node_context = node_context
+        @root_node = @node_context.instance_variable_get(:@nesting_nodes).first
         @finder = ReeObjectFinder.new(@index)
       end
 
@@ -71,7 +74,15 @@ module RubyLsp
         message = node.message
         result = []
         
-        definition_item = ReeObjectFinder.new(@index).find_object(message)
+        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_ast(@root_node, @uri)
+        link_node = parsed_doc.find_link_node(message)
+
+        definition_item = if link_node
+          @finder.find_object_for_package(message, link_node.link_package_name)
+        else
+          @finder.find_object(message)
+        end
+
         return [] unless definition_item
 
         definition_uri = definition_item.uri.to_s
@@ -127,6 +138,60 @@ module RubyLsp
           ),
         )
       end
+
+      def get_error_locales_definition_items(node)
+        locales_folder = package_locales_folder_path(@uri.path)
+
+        return [] unless File.directory?(locales_folder)
+
+        result = []
+        key_path = node.unescaped
+
+        Dir.glob(File.join(locales_folder, '**/*.yml')).each do |locale_file|
+          line = find_locale_key_line(locale_file, key_path)
+
+          result << Interface::Location.new(
+            uri: locale_file,
+            range: Interface::Range.new(
+              start: Interface::Position.new(line: line, character: 0),
+              end: Interface::Position.new(line: line, character: 0),
+            ),
+          )
+        end
+
+        result
+      end
+
+      def get_error_code_definition_items(node)
+        locales_folder = package_locales_folder_path(@uri.path)
+
+        return [] unless File.directory?(locales_folder)
+
+        result = []
+
+        key_path = if @node_context.parent.arguments.arguments.size > 1
+          @node_context.parent.arguments.arguments[1].unescaped
+        else
+          parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_ast(@root_node, @uri)
+
+          mod = underscore(parsed_doc.module_name)
+          "#{mod}.errors.#{node.unescaped}"
+        end
+
+        Dir.glob(File.join(locales_folder, '**/*.yml')).each do |locale_file|
+          line = find_locale_key_line(locale_file, key_path)
+
+          result << Interface::Location.new(
+            uri: locale_file,
+            range: Interface::Range.new(
+              start: Interface::Position.new(line: line, character: 0),
+              end: Interface::Position.new(line: line, character: 0),
+            ),
+          )
+        end
+
+        result
+      end
     end
   end
 end

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

@@ -2,17 +2,20 @@ require_relative "../ree_object_finder"
 require_relative "../parsing/parsed_document_builder"
 require_relative "../parsing/parsed_link_node"
 require_relative "../utils/ree_lsp_utils"
+require_relative "../utils/ree_locale_utils"
 
 module RubyLsp
   module Ree
     class HoverHandler
       include Requests::Support::Common
       include RubyLsp::Ree::ReeLspUtils
+      include RubyLsp::Ree::ReeLocaleUtils
 
       def initialize(index, node_context)
         @index = index
         @node_context = node_context
         @finder = ReeObjectFinder.new(@index)
+        @root_node = @node_context.instance_variable_get(:@nesting_nodes).first
       end
 
       def get_ree_object_hover_items(node)
@@ -20,17 +23,34 @@ module RubyLsp
 
         return [] unless ree_object
 
-        documentation =  <<~DOC
+        documentation = get_object_documentation(ree_object)
+
+        [documentation]
+      end
+
+      def get_linked_object_hover_items(node)
+        parent_node = @node_context.parent
+        return [] unless parent_node.name == :link
+
+        ree_object = @finder.find_object(node.unescaped)
+
+        return [] unless ree_object
+
+        documentation = get_object_documentation(ree_object)
+
+        [documentation]
+      end
+
+      def get_object_documentation(ree_object)
+        <<~DOC
         \`\`\`ruby
-        #{node.name.to_s}#{get_detail_string(ree_object)}
+        #{ree_object.name}#{get_detail_string(ree_object)}
         \`\`\`
         ---
-        ree type: :#{@finder.object_type(ree_object)} package: #{package_name_from_uri(ree_object.uri)}
+        #{@finder.object_documentation(ree_object)}
 
         [#{path_from_package_folder(ree_object.uri)}](#{ree_object.uri})
         DOC
-
-        [documentation]
       end
 
       def get_detail_string(ree_object)
@@ -44,6 +64,67 @@ module RubyLsp
 
         signature.parameters.map(&:decorated_name).join(', ')
       end
+
+      def get_error_locales_hover_items(node)
+        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_ast(@root_node, nil)
+        uri = get_uri_from_object(parsed_doc)
+
+        locales_folder = package_locales_folder_path(uri.path)
+        return [] unless File.directory?(locales_folder)
+
+        result = []
+        key_path = node.unescaped
+
+        documentation = ''
+
+        Dir.glob(File.join(locales_folder, '**/*.yml')).each do |locale_file|
+          value = find_locale_value(locale_file, key_path)
+
+          if value
+            loc_key = File.basename(locale_file, '.yml')
+            documentation += "#{loc_key}: #{value}\n\n"
+          end
+        end
+
+        [documentation]
+      end
+
+      def get_error_code_hover_items(node)
+        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_ast(@root_node, nil)
+        uri = get_uri_from_object(parsed_doc)
+
+        locales_folder = package_locales_folder_path(uri.path)
+        return [] unless File.directory?(locales_folder)
+
+        result = []
+
+        key_path = if @node_context.parent.arguments.arguments.size > 1
+          @node_context.parent.arguments.arguments[1].unescaped
+        else
+          mod = underscore(parsed_doc.module_name)
+          "#{mod}.errors.#{node.unescaped}"
+        end
+
+        documentation = ''
+
+        Dir.glob(File.join(locales_folder, '**/*.yml')).each do |locale_file|
+          value = find_locale_value(locale_file, key_path)
+
+          if value
+            loc_key = File.basename(locale_file, '.yml')
+            documentation += "#{loc_key}: #{value}\n\n"
+          end
+        end
+
+        [documentation]
+      end
+
+      def get_uri_from_object(parsed_doc)
+        obj = parsed_doc.links_container_node_name
+
+        ree_obj = @finder.find_object(obj)
+        ree_obj.uri
+      end
     end
   end
 end

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

@@ -1,4 +1,5 @@
 require_relative "../handlers/definition_handler"
+require_relative "../ree_context"
 
 module RubyLsp
   module Ree
@@ -8,6 +9,7 @@ module RubyLsp
       def initialize(response_builder, node_context, index, dispatcher, uri)
         @response_builder = response_builder
         @handler = RubyLsp::Ree::DefinitionHandler.new(index, uri, node_context)
+        @ree_context = RubyLsp::Ree::ReeContext.new(node_context)
 
         dispatcher.register(
           self, 
@@ -40,14 +42,24 @@ module RubyLsp
       end
 
       def on_symbol_node_enter(node)
-        definition_items = @handler.get_linked_object_definition_items(node)
+        definition_items = if @ree_context.is_error_definition?
+          @handler.get_error_code_definition_items(node)
+        else
+          @handler.get_linked_object_definition_items(node)
+        end
+        
         put_items_into_response(definition_items)
       rescue => e
         $stderr.puts("error in definition listener(on_symbol_node_enter): #{e.message} : #{e.backtrace.first}")
       end
 
       def on_string_node_enter(node)
-        definition_items = @handler.get_linked_filepath_definition_items(node)
+        definition_items = if @ree_context.is_error_definition?
+          @handler.get_error_locales_definition_items(node)
+        else
+          @handler.get_linked_filepath_definition_items(node)
+        end
+
         put_items_into_response(definition_items)
       rescue => e
         $stderr.puts("error in definition listener(on_string_node_enter): #{e.message} : #{e.backtrace.first}")

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

@@ -8,9 +8,15 @@ module RubyLsp
       def initialize(response_builder, node_context, index, dispatcher)
         @response_builder = response_builder
         @handler = RubyLsp::Ree::HoverHandler.new(index, node_context)
+        @ree_context = RubyLsp::Ree::ReeContext.new(node_context)
 
-        dispatcher.register(self, :on_call_node_enter)
-        dispatcher.register(self, :on_constant_read_node_enter)
+        dispatcher.register(
+          self, 
+          :on_call_node_enter,
+          :on_symbol_node_enter,
+          :on_string_node_enter, 
+          :on_constant_read_node_enter
+        )
       end
 
       def on_constant_read_node_enter(node)
@@ -32,6 +38,28 @@ module RubyLsp
         $stderr.puts("error in hover listener(on_call_node_enter): #{e.message} : #{e.backtrace.first}")
       end
 
+      def on_string_node_enter(node)
+        return unless @ree_context.is_error_definition?
+        
+        hover_items = @handler.get_error_locales_hover_items(node)
+        
+        put_items_into_response(hover_items)
+      rescue => e
+        $stderr.puts("error in hover listener(on_string_node_enter): #{e.message} : #{e.backtrace.first}")
+      end
+
+      def on_symbol_node_enter(node)
+        hover_items = if @ree_context.is_error_definition?
+          @handler.get_error_code_hover_items(node)
+        else
+          @handler.get_linked_object_hover_items(node)
+        end
+
+        put_items_into_response(hover_items)
+      rescue => e
+        $stderr.puts("error in hover listener(on_symbol_node_enter): #{e.message} : #{e.backtrace.first}")
+      end
+
       def put_items_into_response(items)
         items.each do |item|
           @response_builder.push(item, category: :documentation)

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

@@ -1,4 +1,5 @@
 require_relative 'parsed_link_node'
+require_relative 'parsed_method_node'
 require 'ostruct'
 
 class RubyLsp::Ree::ParsedDocument
@@ -6,9 +7,26 @@ class RubyLsp::Ree::ParsedDocument
 
   LINK_DSL_MODULE = 'Ree::LinkDSL'
 
+  ERROR_DEFINITION_NAMES = [
+    :auth_error,
+    :build_error,
+    :conflict_error,
+    :invalid_param_error,
+    :not_found_error,
+    :payment_required_error,
+    :permission_error,
+    :validation_error
+  ]
+
+  CONTRACT_CALL_NODE_NAMES = [
+    :contract,
+    :throws
+  ]
+
   attr_reader :ast, :package_name, :class_node, :fn_node, :class_includes,
     :link_nodes, :values, :action_node, :dao_node, :filters,
-    :bean_node, :bean_methods, :mapper_node, :links_container_block_node, :aggregate_node
+    :bean_node, :bean_methods, :mapper_node, :links_container_block_node, :aggregate_node,
+    :error_definitions, :doc_instance_methods
 
   def initialize(ast)
     @ast = ast
@@ -161,6 +179,25 @@ class RubyLsp::Ree::ParsedDocument
       .map{ OpenStruct.new(name: node_name(_1).to_s, signatures: parse_signatures_from_params(_1.parameters)) }
   end
 
+  def parse_instance_methods
+    @doc_instance_methods = []
+
+    current_contract_node = nil
+    class_node.body.body.each do |node|
+      if node.is_a?(Prism::CallNode) && CONTRACT_CALL_NODE_NAMES.include?(node_name(node))
+        current_contract_node = node
+      else
+        if node.is_a?(Prism::DefNode)
+          @doc_instance_methods << RubyLsp::Ree::ParsedMethodNode.new(node, current_contract_node)
+        end
+
+        current_contract_node = nil
+      end
+    end
+
+    @doc_instance_methods
+  end
+
   def parse_filter_signature(filter_node)
     return [] unless filter_node
 
@@ -175,11 +212,31 @@ class RubyLsp::Ree::ParsedDocument
     [RubyIndexer::Entry::Signature.new(signature_params)]
   end
 
-  def get_class_name
+  def parse_error_definitions
+    return unless class_node
+
+    @error_definitions = class_node.body.body
+      .select{ _1.is_a?(Prism::ConstantWriteNode) }
+      .select{ ERROR_DEFINITION_NAMES.include?(node_name(_1.value)) }
+  end
+
+  def class_name
+    class_node.constant_path.name.to_s
+  end
+
+  def module_name
+    class_node.constant_path&.parent&.name.to_s
+  end
+
+  def full_class_name
     name_parts = [class_node.constant_path&.parent&.name, class_node.constant_path.name]
     name_parts.compact.map(&:to_s).join('::')
   end
 
+  def links_container_node_name
+    links_container_node.arguments.arguments.first.unescaped
+  end
+
   def node_name(node)
     return nil unless node.respond_to?(:name)
 

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

@@ -38,11 +38,11 @@ class RubyLsp::Ree::ParsedDocumentBuilder
     when :bean
       build_bean_document(ast)
     else
-      build_detected_doument_type(ast)
+      build_detected_document_type(ast)
     end
   end
 
-  def self.build_detected_doument_type(ast)
+  def self.build_detected_document_type(ast)
     if has_root_class?(ast)
       build_regular_document(ast)
     elsif has_root_rspec_call?(ast)
@@ -53,7 +53,7 @@ class RubyLsp::Ree::ParsedDocumentBuilder
   end
 
   def self.has_root_class?(ast)
-    ast.statements.body.detect{ |node| node.is_a?(Prism::ClassNode) }
+    !!ast.statements.body.detect{ |node| node.is_a?(Prism::ClassNode) }
   end
 
   def self.has_root_rspec_call?(ast)

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

@@ -0,0 +1,109 @@
+require 'prism'
+
+class RubyLsp::Ree::ParsedMethodNode
+  attr_reader :method_node, :contract_node
+
+  def initialize(method_node, contract_node)
+    @method_node = method_node
+    @contract_node = contract_node
+  end
+
+  def name
+    @method_node.name
+  end
+
+  def has_contract?
+    !!@contract_node
+  end
+
+  def start_line
+    @method_node.location.start_line - 1
+  end
+
+  def end_line
+    @method_node.location.end_line - 1
+  end
+
+  def raised_errors_nested(source, error_definitions)
+    return [] if error_definitions.size == 0
+    
+    raised = raised_errors(source, error_definitions)
+    
+    not_detected_errors = error_definitions.select{ !raised.include?(_1.name.to_s) }
+    @nested_local_methods.each do |nested_method|
+      raised += nested_method.raised_errors_nested(source, not_detected_errors)
+      not_detected_errors = error_definitions.select{ !raised.include?(_1.name.to_s) }
+    end
+
+    raised
+  end
+
+  def raised_errors(source, error_definitions)
+    raised = []
+    error_names = error_definitions.map(&:name).map(&:to_s)
+
+    source.lines[start_line+1 .. end_line-1].each do |line|
+      error_names.each do |error_name|
+        regex = /\braise #{Regexp.escape(error_name)}\b/
+
+        if line.match?(regex)
+          raised << error_name
+        end
+      end
+    end
+
+    raised.uniq
+  end
+
+  def throws_errors
+    return [] unless has_contract?
+    return [] unless has_throw_section?
+
+    @contract_node.arguments.arguments.map{ _1.name.to_s }
+  end
+
+  def has_throw_section?
+    @contract_node && @contract_node.name == :throws
+  end
+
+  def throw_arguments_end_position
+    @contract_node.arguments.arguments.last.location.end_column - 1
+  end
+
+  def throw_arguments_end_line
+    @contract_node.arguments.arguments.last.location.end_line - 1
+  end
+
+  def contract_node_end_position
+    @contract_node.location.end_column - 1
+  end
+
+  def contract_node_end_line
+    @contract_node.location.end_line - 1
+  end
+  
+  def parse_nested_local_methods(local_methods)
+    local_method_names = local_methods.map(&:name)
+    call_nodes = parse_body_call_objects(@method_node.body.body)
+    call_node_names = call_nodes.map(&:name)
+   
+    @nested_local_methods = local_methods.select{ call_node_names.include?(_1.name) }
+    @nested_local_methods.each{ _1.parse_nested_local_methods(local_methods) }
+  end
+
+  def parse_body_call_objects(node_body)
+    call_nodes = []
+    
+    node_body.each do |node|
+      if node.is_a?(Prism::CallNode) && !node.receiver
+        call_nodes << node
+      elsif node.respond_to?(:statements)
+        call_nodes += parse_body_call_objects(node.statements.body)
+      elsif node.respond_to?(:block) && node.block 
+        call_nodes += parse_body_call_objects(node.block.body.body)
+      end
+    end
+
+    call_nodes
+  end
+end

data/lib/ruby_lsp/ruby_lsp_ree/ree_context.rb

@@ -0,0 +1,28 @@
+require 'prism'
+
+module RubyLsp
+  module Ree
+    class ReeContext
+      ERROR_DEFINITION_NAMES = [
+        :auth_error,
+        :build_error,
+        :conflict_error,
+        :invalid_param_error,
+        :not_found_error,
+        :payment_required_error,
+        :permission_error,
+        :validation_error
+      ]
+
+      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)
+        
+        ERROR_DEFINITION_NAMES.include?(@node_context.parent.name)
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_ree/ree_formatter.rb

@@ -9,7 +9,9 @@ module RubyLsp
 
       def run_formatting(uri, document)
         source = document.source
-        sort_links(source)
+        
+        sorted_source = sort_links(source)
+        add_missing_error_contracts(sorted_source)
       rescue => e
         $stderr.puts("error in ree_formatter: #{e.message} : #{e.backtrace.first}")
       end
@@ -57,6 +59,47 @@ module RubyLsp
           source_lines[link_line - 1] = sorted_lines[index]
         end
 
+        source_lines.join()
+      end
+
+      def add_missing_error_contracts(source)
+        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_source(source)
+        return source if !parsed_doc || !parsed_doc.class_node
+
+        parsed_doc.parse_error_definitions
+        parsed_doc.parse_instance_methods
+
+        parsed_doc.doc_instance_methods.select(&:has_contract?).each do |doc_instance_method|
+          doc_instance_method.parse_nested_local_methods(parsed_doc.doc_instance_methods)
+
+          raised_errors = doc_instance_method.raised_errors_nested(source, parsed_doc.error_definitions)
+          throws_errors = doc_instance_method.throws_errors
+
+          missed_errors = raised_errors - throws_errors
+          source = add_missed_errors(source, doc_instance_method, missed_errors)
+        end
+
+        source
+      end
+
+      def add_missed_errors(source, doc_instance_method, missed_errors)
+        return source if missed_errors.size == 0
+
+        source_lines = source.lines
+
+        if doc_instance_method.has_throw_section?
+          position = doc_instance_method.throw_arguments_end_position
+          line = doc_instance_method.throw_arguments_end_line
+
+          source_lines[line] = source_lines[line][0..position] + ", #{missed_errors.join(', ')})\n"
+        else
+          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"
+        end
+
+
         source_lines.join()
       end
     end

data/lib/ruby_lsp/ruby_lsp_ree/ree_indexing_enhancement.rb

@@ -18,9 +18,14 @@ module RubyLsp
         obj_name = node.arguments.child_nodes.first.unescaped
         return unless current_filename == obj_name
 
+        source = @listener.instance_variable_get(:@source_lines).join
+        ast = Prism.parse(source).value # TODO use doc builder
+
         location = node.location
-        signatures = parse_signatures(obj_name)
-        comments = "ree_object\ntype: :#{node.name}"
+        signatures = parse_signatures(obj_name, ast)
+        documentation = parse_documentation(obj_name, ast)
+
+        comments = "ree_object\ntype: :#{node.name}\n#{documentation}"
 
         @listener.add_method(
           obj_name,
@@ -32,10 +37,7 @@ module RubyLsp
 
       private
 
-      def parse_signatures(fn_name)
-        source = @listener.instance_variable_get(:@source_lines).join
-        ast = Prism.parse(source).value
-
+      def parse_signatures(fn_name, ast)
         class_node = ast.statements.body.detect{ |node| node.is_a?(Prism::ClassNode) }
         return [] unless class_node
 
@@ -47,6 +49,28 @@ module RubyLsp
         [RubyIndexer::Entry::Signature.new(signature_params)]
       end
 
+      def parse_documentation(fn_name, ast)
+        class_node = ast.statements.body.detect{ |node| node.is_a?(Prism::ClassNode) }
+        return '' unless class_node
+
+        doc_node = class_node.body.body.detect{ |node| node.respond_to?(:name) && node.name == :doc }
+        return '' unless doc_node
+
+        str_node = doc_node.arguments.arguments.first
+
+        case str_node
+        when Prism::StringNode
+          str_node.unescaped
+        when Prism::InterpolatedStringNode
+          str_node.parts.map(&:unescaped).join
+        else
+          ''
+        end
+      rescue => e
+        $stderr.puts("error parsing documentation for #{fn_name}: #{e.message} : #{e.backtrace.first}")
+        return ''
+      end
+
       def current_filename
         uri = @listener.instance_variable_get(:@uri)
         File.basename(uri.path, '.rb')  

data/lib/ruby_lsp/ruby_lsp_ree/ree_object_finder.rb

@@ -1,6 +1,10 @@
+require_relative "utils/ree_lsp_utils"
+
 module RubyLsp
   module Ree
     class ReeObjectFinder
+      include RubyLsp::Ree::ReeLspUtils
+
       MAX_LIMIT = 1000
 
       REE_OBJECT_STRING = 'ree_object'
@@ -42,6 +46,13 @@ module RubyLsp
         objects_by_name.detect{ _1.comments.to_s.lines.first&.chomp == REE_OBJECT_STRING }
       end
 
+      def find_object_for_package(name, package_name)
+        objects_by_name = @index[name]
+        return unless objects_by_name
+
+        objects_by_name.detect{ _1.comments.to_s.lines.first&.chomp == REE_OBJECT_STRING && package_name_from_uri(_1.uri) == package_name }
+      end
+
       def find_objects_by_types(name, types)
         objects_by_name = @index[name]
         return [] unless objects_by_name
@@ -76,6 +87,10 @@ module RubyLsp
           
         type_str.split(' ').last[1..-1].to_sym
       end
+
+      def object_documentation(ree_object)
+        ree_object.comments.lines[2..-1].join("\n").chomp
+      end
     end
   end
 end

data/lib/ruby_lsp/ruby_lsp_ree/ree_rename_handler.rb

@@ -0,0 +1,39 @@
+module RubyLsp
+  module Ree
+    class ReeRenameHandler
+      include RubyLsp::Ree::ReeLspUtils
+
+      def self.call(changes)
+        old_uri = URI.parse(changes.detect{ _1[:type] == Constant::FileChangeType::DELETED }[:uri])
+        new_uri = URI.parse(changes.detect{ _1[:type] == Constant::FileChangeType::CREATED }[:uri])
+
+        old_file_name = File.basename(old_uri, '.rb')
+        new_file_name = File.basename(new_uri, '.rb')
+
+        return if old_file_name == new_file_name
+
+        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_uri(new_uri)
+        return if !parsed_doc || !parsed_doc.class_node
+
+        old_class_name = old_file_name.split('_').collect(&:capitalize).join
+        new_class_name = new_file_name.split('_').collect(&:capitalize).join
+
+        return unless parsed_doc.class_name == old_class_name
+
+        file_content_lines = File.read(new_uri.path).lines
+        
+        class_line = parsed_doc.class_node.location.start_line - 1
+
+        file_content_lines[class_line].gsub!(/\b#{old_class_name}\b/, new_class_name)
+
+        if parsed_doc.links_container_node
+          links_container_node_line = parsed_doc.links_container_node.location.start_line - 1
+
+          file_content_lines[links_container_node_line].gsub!(/\b#{old_file_name}\b/, new_file_name)
+        end
+
+        File.write(new_uri.path, file_content_lines.join)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'yaml'
+
+module RubyLsp
+  module Ree
+    module ReeLocaleUtils
+      def package_locales_folder_path(uri)
+        uri_parts = uri.to_s.chomp(File.extname(uri.to_s)).split('/')
+
+        package_folder_index = uri_parts.index('package')
+        return unless package_folder_index
+
+        path_parts = uri_parts.take(package_folder_index+2) + ['locales']
+        path_parts.join('/')
+      end
+      
+      def find_locale_value(file_path, key_path)
+        loc_yaml = YAML.load_file(file_path)
+        loc_key = File.basename(file_path, '.yml')
+        key_parts = [loc_key] + key_path.split('.')
+
+        loc_yaml.dig(*key_parts)
+      end
+
+      def find_locale_key_line(file_path, key_path)
+        loc_key = File.basename(file_path, '.yml')
+
+        key_parts = [loc_key] + key_path.split('.')
+
+        current_key_index = 0
+        current_key = key_parts[current_key_index]
+        regex = /^\s*#{Regexp.escape(current_key)}:/
+
+        File.open(file_path, 'r:UTF-8').each_with_index do |line, line_index|
+          if line.match?(regex)
+            current_key_index += 1
+            current_key = key_parts[current_key_index]
+            return line_index unless current_key
+
+            regex = /^\s*#{Regexp.escape(current_key)}:/
+          end
+        end
+
+        0
+      end
+    end
+  end
+end

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

@@ -7,7 +7,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('/')
         
@@ -170,6 +170,17 @@ module RubyLsp
           :"(#{names_with_commas})"
         end
       end
+
+      # copied from ree string_utils
+      def underscore(camel_cased_word)
+        return camel_cased_word unless /[A-Z-]|::/.match?(camel_cased_word)
+        word = camel_cased_word.to_s.gsub("::".freeze, "/".freeze)
+        word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze)
+        word.gsub!(/([a-z\d])([A-Z])/, '\1_\2'.freeze)
+        word.tr!("-".freeze, "_".freeze)
+        word.downcase!
+        word
+      end
     end
   end
 end

data/lib/ruby_lsp_ree/version.rb

@@ -2,6 +2,6 @@
 
 module RubyLsp
   module Ree
-    VERSION = "0.1.5"
+    VERSION = "0.1.7"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-ree
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-02-28 00:00:00.000000000 Z
+date: 2025-03-20 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby LSP addon that adds extra editor functionality for Ree applications
 email:
@@ -35,11 +35,15 @@ files:
 - lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_document.rb
 - lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_document_builder.rb
 - lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_link_node.rb
+- lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_method_node.rb
 - lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_rspec_document.rb
+- lib/ruby_lsp/ruby_lsp_ree/ree_context.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_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
 - lib/ruby_lsp_ree.rb
 - lib/ruby_lsp_ree/version.rb