ruby-lsp-ree 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3814d8a258c4c291c8c2a858e5bf23094086e25162435b956bae4401bd456109
-  data.tar.gz: a8ae59abe162776aba2356dc2a3c9b607703ac9d5012fac2c843ab84c7e12e96
+  metadata.gz: ccc9c39cc6ca44feeb3c8c5369e259a790dc01c02a0aecf9a14eee2d19e65015
+  data.tar.gz: 61233b0b379f7ab994f102fc748e2ef54eed53e605017bb0d28793ea160a45d7
 SHA512:
-  metadata.gz: 4ab9db29ce9ed0fc7ee54721826ee1933308511c3f07ddce31c53504dde5d422a131dcb6421bb428c9694ddbbc6cdab83b5f96315d9195e97e2bac11a5bad2e2
-  data.tar.gz: f6dcffe5363c8acb0481b9c8adbd1d6a5b6322833dc0fe1d8001188d7daf796aa68008ae648d3b99a4ad7f9f9e281b0fbdab4efec80a88b362cd18865dbd829c
+  metadata.gz: 07cf2e0c6c6670f5405a967e7fffe9af19af8a29dc55d33afef3b9dd0f231df826a0cd11d4e5b91ad23b7348635107c0186a7bb8b878bce00d9a480710267608
+  data.tar.gz: 5a5bcdf420fe934e46ec0b0318c6325cd5c6a0753ca18ea73a8188f54dc19a1c7abd6b3e41a777fb4f0a8b6f6bf83c8fd015226ceb21ee54c8228264874f0aaf

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [0.1.8] - 2025-03-21
+
+- hover: show missing locales
+- formatter: add raised error definition if missing
+- formatter: add placeholder for missing locale
+- formatter: improved adding raised errors into contract throw section
+- Go To Definition: improved location for error locales
+- Go To Definition: got to missing locale placeholder
+
+## [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

data/Gemfile.lock

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

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

@@ -0,0 +1,13 @@
+module RubyLsp
+  module Ree
+    class BaseFormatter
+      def self.call(source, uri)
+        new.call(source, uri)
+      end
+
+      def call(source, uri)
+        raise 'abstract method'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require_relative 'base_formatter'
+
+module RubyLsp
+  module Ree
+    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
+
+        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
+          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
+
+      private
+
+      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
+
+          if source_lines[line].strip.end_with?(")")
+            source_lines[line] = source_lines[line][0..position] + ", #{missed_errors.join(', ')})\n"
+          else
+            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
+
+          source_lines[line] = source_lines[line][0..position] + ".throws(#{missed_errors.join(', ')})\n"
+        end
+
+        source_lines.join
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require_relative 'base_formatter'
+
+module RubyLsp
+  module Ree
+    class MissingErrorDefinitionsFormatter < BaseFormatter
+      include RubyLsp::Ree::ReeLspUtils
+
+      def call(source, _uri)
+        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.parse_links
+
+        existing_errors = parsed_doc.error_definition_names + parsed_doc.imported_constants
+
+        missed_errors = []
+        parsed_doc.doc_instance_methods.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
+
+          missed_errors += raised_errors - existing_errors
+        end
+
+        missed_errors = missed_errors.uniq.reject{ Object.const_defined?(_1) }
+
+        add_missed_error_definitions(source, parsed_doc, missed_errors.uniq)
+      end
+
+      private
+
+      def add_missed_error_definitions(source, parsed_doc, missed_errors)
+        return source if missed_errors.size == 0
+
+        source_lines = source.lines
+
+        if parsed_doc.error_definitions.size > 0
+          change_line = parsed_doc.error_definitions.map{ _1.location.start_line }.max - 1
+        else
+          change_line = parsed_doc.links_container_node.location.end_line - 1 
+          source_lines[change_line] += "\n"
+        end
+
+        missed_errors.each do |err|
+          source_lines[change_line] += "\s\s#{err} = invalid_param_error(:#{underscore(err)})\n"
+        end
+
+        source_lines.join
+      end 
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+require_relative 'base_formatter'
+
+module RubyLsp
+  module Ree
+    class MissingErrorLocalesFormatter < BaseFormatter
+      include RubyLsp::Ree::ReeLspUtils
+      include RubyLsp::Ree::ReeLocaleUtils
+
+      MISSING_LOCALE_PLACEHOLDER = '_MISSING_LOCALE_'
+
+      def call(source, uri)
+        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_source(source)
+
+        locales_folder = package_locales_folder_path(URI.parse(uri.to_s).path)
+        return source if !locales_folder || !File.directory?(locales_folder)
+
+        result = []
+        key_paths = []
+        parsed_doc.parse_error_definitions
+        parsed_doc.error_definitions.each do |error_definition|
+          key_path = if error_definition.value.arguments.arguments.size > 1
+            error_definition.value.arguments.arguments[1].unescaped
+          else
+            mod = underscore(parsed_doc.module_name)
+            "#{mod}.errors.#{error_definition.value.arguments.arguments[0].unescaped}"
+          end
+
+          key_paths << key_path
+        end
+
+        Dir.glob(File.join(locales_folder, '**/*.yml')).each do |locale_file|
+          key_paths.each do |key_path|
+            value = find_locale_value(locale_file, key_path)
+            unless value
+              loc_key = File.basename(locale_file, '.yml')
+
+              add_locale_placeholder(locale_file, key_path)          
+            end
+          end
+        end
+
+        source
+      end
+
+      private 
+      
+      def add_locale_placeholder(file_path, key_path)
+        loc_key = File.basename(file_path, '.yml')
+        key_parts = [loc_key] + key_path.split('.')
+
+        last_found_index = 0
+        last_found_key = nil
+        current_node = YamlFileParser.parse_with_key_coordinates(file_path)
+
+        key_parts.each_with_index do |key_part, index|
+          found_key, next_node = YamlFileParser.find_key_in_node(current_node, key_part)
+
+          break unless found_key
+
+          current_node = next_node
+          last_found_index = index
+          last_found_key = found_key
+        end
+
+        missed_key_parts = key_parts[last_found_index+1..-1]
+
+        identation = last_found_key.column
+        adding_string = ''
+        missed_key_parts.each_with_index do |key_part, index|
+          identation += 2
+          if index == missed_key_parts.size - 1
+            adding_string += "\s" * identation + "#{key_part}: #{MISSING_LOCALE_PLACEHOLDER}\n"
+          else
+            adding_string += "\s" * identation + "#{key_part}:\n"
+          end
+        end
+
+        lines = File.read(file_path).lines
+        lines[last_found_key.line] += adding_string
+        File.write(file_path, lines.join)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require_relative 'base_formatter'
+
+module RubyLsp
+  module Ree
+    class SortLinksFormatter < BaseFormatter
+      def call(source, _uri)
+        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
+        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]
+        end
+
+        source_lines.join()
+      end
+    end
+  end
+end

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,59 @@ 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|
+          location = find_locale_key_location(locale_file, key_path)
+
+          result << Interface::Location.new(
+            uri: locale_file,
+            range: Interface::Range.new(
+              start: Interface::Position.new(line: location.line, character: location.column),
+              end: Interface::Position.new(line: location.line, character: location.column),
+            ),
+          )
+        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|
+          location = find_locale_key_location(locale_file, key_path)
+
+          result << Interface::Location.new(
+            uri: locale_file,
+            range: Interface::Range.new(
+              start: Interface::Position.new(line: location.line, character: location.column),
+              end: Interface::Position.new(line: location.line, character: location.column),
+            ),
+          )
+        end
+
+        result
+      end
     end
   end
 end

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

@@ -2,17 +2,22 @@ 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
+
+      MISSING_LOCALE_PLACEHOLDER = '_MISSING_LOCALE_'
 
       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)
@@ -61,6 +66,84 @@ 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)
+          loc_key = File.basename(locale_file, '.yml')
+
+          if value
+            if value == MISSING_LOCALE_PLACEHOLDER
+              value_location = find_locale_key_location(locale_file, key_path)
+              file_uri = "#{locale_file}" # TODO add line to uri :#{value_location.line+1}:#{value_location.column}"
+              documentation += "#{loc_key}: [#{value}](#{file_uri})\n\n"
+            else
+              documentation += "#{loc_key}: #{value}\n\n"
+            end
+          else
+            documentation += "#{loc_key}: [MISSING TRANSLATION](#{locale_file})\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)
+
+          loc_key = File.basename(locale_file, '.yml')
+
+          if value
+            if value == MISSING_LOCALE_PLACEHOLDER
+              value_location = find_locale_key_location(locale_file, key_path)
+              file_uri = "#{locale_file}" # TODO add line to uri :#{value_location.line+1}:#{value_location.column}"
+              documentation += "#{loc_key}: [#{value}](#{file_uri})\n\n"
+            else
+              documentation += "#{loc_key}: #{value}\n\n"
+            end
+          else
+            documentation += "#{loc_key}: [MISSING TRANSLATION](#{locale_file})\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,11 +8,13 @@ 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,
           :on_symbol_node_enter,
+          :on_string_node_enter, 
           :on_constant_read_node_enter
         )
       end
@@ -36,8 +38,23 @@ 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 = @handler.get_linked_object_hover_items(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}")

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, :error_definition_names, :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,10 +212,24 @@ class RubyLsp::Ree::ParsedDocument
     [RubyIndexer::Entry::Signature.new(signature_params)]
   end
 
+  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)) }
+
+    @error_definition_names = @error_definitions.map(&:name)
+  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('::')
@@ -193,4 +244,8 @@ class RubyLsp::Ree::ParsedDocument
 
     node.name
   end
+
+  def imported_constants
+    @link_nodes.map(&:imports).flatten.map(&:to_sym)
+  end
 end

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,115 @@
+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
+    return @raised_errors_nested if @raised_errors_nested
+    raised = raised_errors
+    
+    @nested_local_methods.each do |nested_method|
+      raised += nested_method.raised_errors_nested
+    end
+
+    @raised_errors_nested = raised
+  end
+
+  def raised_errors
+    return @raised_errors if @raised_errors
+    return [] unless @method_node.body
+
+    call_objects = parse_body_call_objects(@method_node.body.body)
+    raise_objects = call_objects.select{ _1.name == :raise }
+    @raised_errors = raise_objects.map{ parse_raised_class_name(_1) }.compact
+  end
+
+  def parse_raised_class_name(raise_node)
+    return unless raise_node.arguments
+
+    if raise_node.arguments.arguments.first.is_a?(Prism::ConstantReadNode)
+      raise_node.arguments.arguments.first.name
+    elsif raise_node.arguments.arguments.first.is_a?(Prism::CallNode)
+      raise_node.arguments.arguments.first.receiver.name
+    else
+      nil
+    end
+  end
+
+  def throws_errors
+    return [] unless has_contract?
+    return [] unless has_throw_section?
+
+    @contract_node.arguments.arguments.map{ _1.name }
+  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)
+    unless @method_node.body
+      @nested_local_methods = []
+      return
+    end
+
+    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

@@ -1,63 +1,84 @@
+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'
+
 module RubyLsp
   module Ree
     class ReeFormatter
       include RubyLsp::Requests::Support::Formatter
       include RubyLsp::Ree::ReeLspUtils
-
-      def initialize
-      end
+      include RubyLsp::Ree::ReeLocaleUtils
 
       def run_formatting(uri, document)
         source = document.source
-        sort_links(source)
+
+        formatters = [
+          RubyLsp::Ree::SortLinksFormatter,
+          RubyLsp::Ree::MissingErrorDefinitionsFormatter,
+          RubyLsp::Ree::MissingErrorContractsFormatter,
+          RubyLsp::Ree::MissingErrorLocalesFormatter
+        ]
+
+        formatters.reduce(source){ |s, formatter| formatter.call(s, uri) }
       rescue => e
         $stderr.puts("error in ree_formatter: #{e.message} : #{e.backtrace.first}")
       end
 
-      private
+      def run_diagnostic(uri, document)
+        $stderr.puts("ree_formatter_diagnostic")
+        detect_missing_error_locales(uri, document)
+      rescue => e
+        $stderr.puts("error in ree_formatter_diagnostic: #{e.message} : #{e.backtrace.first}")
+      end
 
-      def sort_links(source)
-        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_source(source)
-        return source if !parsed_doc.link_nodes&.any?
+      private
 
-        if parsed_doc.link_nodes.any?{ _1.location.start_line != _1.location.end_line }
-          $stderr.puts("multiline link definitions, don't sort")
-          return source
-        end
+      def detect_missing_error_locales(uri, document)
+        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_source(document.source)
 
-        # 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
+        locales_folder = package_locales_folder_path(uri.path)
+        return [] unless File.directory?(locales_folder)
 
-          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
+        result = []
+        key_paths = []
+        parsed_doc.parse_error_definitions
+        parsed_doc.error_definitions.each do |error_definition|
+          key_path = if error_definition.value.arguments.arguments.size > 1
+            error_definition.value.arguments.arguments[1].unescaped
           else
-            a_name.unescaped <=> b_name.unescaped
+            mod = underscore(parsed_doc.module_name)
+            "#{mod}.errors.#{error_definition.value.arguments.arguments[0].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
+          key_paths << key_path
         end
 
-        # insert nodes to source
-        link_lines = parsed_doc.link_nodes.map{ _1.location.start_line }
+        $stderr.puts("ree_formatter_diagnostic #{key_paths}")
 
-        source_lines = source.lines
+        Dir.glob(File.join(locales_folder, '**/*.yml')).each do |locale_file|
+          key_paths.each do |key_path|
+            value = find_locale_value(locale_file, key_path)
+            unless value
+              loc_key = File.basename(locale_file, '.yml')
 
-        sorted_lines = sorted_link_nodes.map do |sorted_link|
-          source_lines[sorted_link.location.start_line - 1]
-        end
+              $stderr.puts("ree_formatter_diagnostic add diagnostic")
 
-        link_lines.each_with_index do |link_line, index|
-          source_lines[link_line - 1] = sorted_lines[index]
+              # TODO correct error range
+              result << RubyLsp::Interface::Diagnostic.new(
+                message: "Missing locale #{loc_key}: #{key_path}",
+                source: "Ree formatter",
+                severity: RubyLsp::Constant::DiagnosticSeverity::ERROR,
+                range: RubyLsp::Interface::Range.new( 
+                  start: RubyLsp::Interface::Position.new(line: 0, character: 0),
+                  end: RubyLsp::Interface::Position.new(line: 0, character: 0),
+                ),
+              )
+            end
+          end
         end
 
-        source_lines.join()
+        result
       end
     end
   end

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

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

@@ -0,0 +1,40 @@
+require 'yaml'
+require_relative 'yaml_file_parser'
+
+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_location(file_path, key_path)
+        loc_key = File.basename(file_path, '.yml')
+
+        key_parts = [loc_key] + key_path.split('.')
+        parsed_yaml = RubyLsp::Ree::YamlFileParser.parse(file_path)
+        key_location = parsed_yaml.dig(*key_parts)
+
+        if key_location
+          OpenStruct.new(line: key_location.line, column: key_location.column)
+        else
+          OpenStruct.new(line: 0, column: 0)
+        end
+      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/ruby_lsp_ree/utils/yaml_file_parser.rb

@@ -0,0 +1,53 @@
+require 'psych'
+
+module RubyLsp
+  module Ree
+    class NodeVisitor < Psych::Visitors::ToRuby
+      def visit_Psych_Nodes_Scalar(o)
+        register(o, OpenStruct.new(value: deserialize(o), line: o.start_line, column: o.start_column))
+      end
+    end
+    
+    class YamlFileParser
+      def self.parse(file_path)
+        parser = Psych::Parser.new(Psych::TreeBuilder.new)
+        parser.parse(File.read(file_path))
+
+        parse_result = NodeVisitor.create.accept(parser.handler.root)
+        normalize_hash_keys(parse_result.first)
+      end
+
+      def self.parse_with_key_coordinates(file_path)
+        parser = Psych::Parser.new(Psych::TreeBuilder.new)
+        parser.parse(File.read(file_path))
+
+        NodeVisitor.create.accept(parser.handler.root).first
+      end
+
+      def self.find_key_in_node(current_node, key)
+        matched_key_el = current_node.detect{ _1[0].value == key }
+        return [nil, nil] unless matched_key_el
+        matched_key_el
+      end
+
+      def self.normalize_hash_keys(res)
+        deep_transform_keys_in_object!(res){ |k| k.value }
+      end
+
+      def self.deep_transform_keys_in_object!(object, &block)
+        case object
+        when Hash
+          object.keys.each do |key|
+            value = object.delete(key)
+            object[yield(key)] = deep_transform_keys_in_object!(value, &block)
+          end
+          object
+        when Array
+          object.map! { |e| deep_transform_keys_in_object!(e, &block) }
+        else
+          object
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp_ree/version.rb

@@ -2,6 +2,6 @@
 
 module RubyLsp
   module Ree
-    VERSION = "0.1.6"
+    VERSION = "0.1.8"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-ree
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-03-05 00:00:00.000000000 Z
+date: 2025-03-21 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby LSP addon that adds extra editor functionality for Ree applications
 email:
@@ -26,6 +26,11 @@ files:
 - README.md
 - Rakefile
 - lib/ruby_lsp/ruby_lsp_ree/addon.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/handlers/completion_handler.rb
 - lib/ruby_lsp/ruby_lsp_ree/handlers/definition_handler.rb
 - lib/ruby_lsp/ruby_lsp_ree/handlers/hover_handler.rb
@@ -35,13 +40,17 @@ 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/ruby_lsp_ree/utils/yaml_file_parser.rb
 - lib/ruby_lsp_ree.rb
 - lib/ruby_lsp_ree/version.rb
 - ruby-lsp-ree.gemspec