ruby-lsp-ree 0.1.7 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d8bf3dfcc23d881b4bc1248851b63de1073b810186baeebe6d60894ea6c366a
-  data.tar.gz: fe3e91cb35202109f9884bfb523d473b7d54921ae839299d4201b782ea6ee0ee
+  metadata.gz: e2340c5046b16e260fd66ff9696e36c4e04db071520018f683e59e4ddcaef34f
+  data.tar.gz: b3a89234d7a4627371ec1e8514970ad00ac540b5b4b6b9cdbd046a2729aa9fee
 SHA512:
-  metadata.gz: 9fc76ea86567ce249f96af8a5d50732c9f23b1dd8e0f0a307ce82d7e74234cef0e908d3cd0ad644b6f5617ab4c3f450a26a9dfe707907a46e0009a12b920b206
-  data.tar.gz: 507f4c378489292422e1560cfda1bfe6e3d4fc8cf8642f3f8786e0d75d389b0a9a4881b035da089ede1a8f90377f0016590441b740b5f207eae1c74b143b6f11
+  metadata.gz: c7e8650725c0188ec521e53188cfdd68679d5d73a392ce624b9f89c3f2daf683497e2558e932daed14cf652d25140a4bca891c3c9dbb536cfecae9cb92d72912
+  data.tar.gz: c8e71b80054434730dbc10bdb85cb82e5277f2582a00879688e25e32078e239620f0e481b0eacac4619acca9ef606933a9fd820c87bf7a075619b506b5ef0a1c

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [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

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ruby-lsp-ree (0.1.7)
+    ruby-lsp-ree (0.1.9)
 
 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

@@ -148,13 +148,13 @@ module RubyLsp
         key_path = node.unescaped
 
         Dir.glob(File.join(locales_folder, '**/*.yml')).each do |locale_file|
-          line = find_locale_key_line(locale_file, key_path)
+          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: line, character: 0),
-              end: Interface::Position.new(line: line, character: 0),
+              start: Interface::Position.new(line: location.line, character: location.column),
+              end: Interface::Position.new(line: location.line, character: location.column),
             ),
           )
         end
@@ -164,7 +164,6 @@ module RubyLsp
 
       def get_error_code_definition_items(node)
         locales_folder = package_locales_folder_path(@uri.path)
-
         return [] unless File.directory?(locales_folder)
 
         result = []
@@ -179,13 +178,13 @@ module RubyLsp
         end
 
         Dir.glob(File.join(locales_folder, '**/*.yml')).each do |locale_file|
-          line = find_locale_key_line(locale_file, key_path)
+          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: line, character: 0),
-              end: Interface::Position.new(line: line, character: 0),
+              start: Interface::Position.new(line: location.line, character: location.column),
+              end: Interface::Position.new(line: location.line, character: location.column),
             ),
           )
         end

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

@@ -11,6 +11,8 @@ module RubyLsp
       include RubyLsp::Ree::ReeLspUtils
       include RubyLsp::Ree::ReeLocaleUtils
 
+      MISSING_LOCALE_PLACEHOLDER = '_MISSING_LOCALE_'
+
       def initialize(index, node_context)
         @index = index
         @node_context = node_context
@@ -79,10 +81,18 @@ module RubyLsp
 
         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
-            loc_key = File.basename(locale_file, '.yml')
-            documentation += "#{loc_key}: #{value}\n\n"
+            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
 
@@ -110,9 +120,18 @@ module RubyLsp
         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
-            loc_key = File.basename(locale_file, '.yml')
-            documentation += "#{loc_key}: #{value}\n\n"
+            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
 

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

@@ -26,10 +26,11 @@ class RubyLsp::Ree::ParsedDocument
   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,
-    :error_definitions, :doc_instance_methods
+    :error_definitions, :error_definition_names, :doc_instance_methods
 
-  def initialize(ast)
+  def initialize(ast, package_name = nil)
     @ast = ast
+    set_package_name(package_name) if package_name
   end
 
   def links_container_node
@@ -218,6 +219,8 @@ class RubyLsp::Ree::ParsedDocument
     @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
@@ -242,4 +245,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

@@ -7,20 +7,16 @@ class RubyLsp::Ree::ParsedDocumentBuilder
 
   def self.build_from_uri(uri, type = nil)
     ast = Prism.parse_file(uri.path).value
-    document = build_document(ast, type)
+    document = build_document(ast, type, package_name_from_uri(uri))
     return unless document
 
-    document.set_package_name(package_name_from_uri(uri))
-
     document
   end
 
   def self.build_from_ast(ast, uri, type = nil)
-    document = build_document(ast, type)
+    document = build_document(ast, type, package_name_from_uri(uri))
     return unless document
 
-    document.set_package_name(package_name_from_uri(uri))
-
     document
   end
 
@@ -29,7 +25,7 @@ class RubyLsp::Ree::ParsedDocumentBuilder
     build_document(ast, type)
   end
 
-  def self.build_document(ast, type)
+  def self.build_document(ast, type, package_name = nil)
     case type
     when :enum
       build_enum_document(ast)
@@ -38,13 +34,13 @@ class RubyLsp::Ree::ParsedDocumentBuilder
     when :bean
       build_bean_document(ast)
     else
-      build_detected_document_type(ast)
+      build_detected_document_type(ast, package_name)
     end
   end
 
-  def self.build_detected_document_type(ast)
+  def self.build_detected_document_type(ast, package_name = nil)
     if has_root_class?(ast)
-      build_regular_document(ast)
+      build_regular_document(ast, package_name)
     elsif has_root_rspec_call?(ast)
       build_rspec_document(ast)
     else 
@@ -69,8 +65,8 @@ class RubyLsp::Ree::ParsedDocumentBuilder
     document
   end
 
-  def self.build_regular_document(ast)
-    document = RubyLsp::Ree::ParsedDocument.new(ast)
+  def self.build_regular_document(ast, package_name)
+    document = RubyLsp::Ree::ParsedDocument.new(ast, package_name)
     
     document.parse_class_node
     document.parse_fn_node

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

@@ -24,42 +24,43 @@ class RubyLsp::Ree::ParsedMethodNode
     @method_node.location.end_line - 1
   end
 
-  def raised_errors_nested(source, error_definitions)
-    return [] if error_definitions.size == 0
+  def raised_errors_nested
+    return @raised_errors_nested if @raised_errors_nested
+    raised = raised_errors
     
-    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) }
+      raised += nested_method.raised_errors_nested
     end
 
-    raised
+    @raised_errors_nested = raised
   end
 
-  def raised_errors(source, error_definitions)
-    raised = []
-    error_names = error_definitions.map(&:name).map(&:to_s)
+  def raised_errors
+    return @raised_errors if @raised_errors
+    return [] unless @method_node.body
 
-    source.lines[start_line+1 .. end_line-1].each do |line|
-      error_names.each do |error_name|
-        regex = /\braise #{Regexp.escape(error_name)}\b/
+    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
 
-        if line.match?(regex)
-          raised << error_name
-        end
-      end
-    end
+  def parse_raised_class_name(raise_node)
+    return unless raise_node.arguments
 
-    raised.uniq
+    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.to_s }
+    @contract_node.arguments.arguments.map{ _1.name }
   end
 
   def has_throw_section?
@@ -83,6 +84,11 @@ class RubyLsp::Ree::ParsedMethodNode
   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)

data/lib/ruby_lsp/ruby_lsp_ree/ree_formatter.rb

@@ -1,106 +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
-        
-        sorted_source = sort_links(source)
-        add_missing_error_contracts(sorted_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
 
+      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
+
       private
 
-      def sort_links(source)
-        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_source(source)
-        return source if !parsed_doc.link_nodes&.any?
+      def detect_missing_error_locales(uri, document)
+        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_source(document.source)
 
-        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
+        locales_folder = package_locales_folder_path(uri.path)
+        return [] unless File.directory?(locales_folder)
 
-        # 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
+        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
-        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]
+          key_paths << key_path
         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"
+        $stderr.puts("ree_formatter_diagnostic #{key_paths}")
+
+        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')
+
+              $stderr.puts("ree_formatter_diagnostic add diagnostic")
+
+              # 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/utils/ree_locale_utils.rb

@@ -1,4 +1,5 @@
 require 'yaml'
+require_relative 'yaml_file_parser'
 
 module RubyLsp
   module Ree
@@ -21,27 +22,19 @@ module RubyLsp
         loc_yaml.dig(*key_parts)
       end
 
-      def find_locale_key_line(file_path, key_path)
+      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)
 
-        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
+        if key_location
+          OpenStruct.new(line: key_location.line, column: key_location.column)
+        else
+          OpenStruct.new(line: 0, column: 0)
         end
-
-        0
       end
     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.7"
+    VERSION = "0.1.9"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-ree
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.9
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-03-20 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
@@ -45,6 +50,7 @@ files:
 - 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