ruby-lsp-i18n 0.3.0

data/lib/ruby_lsp/ruby_lsp_i18n/listeners/inlay_hints.rb

@@ -0,0 +1,118 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module RubyLspI18n
+    class InlayHints
+      extend T::Sig
+      include Requests::Support::Common
+
+      sig do
+        params(
+          i18n_index: I18nIndex,
+          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint],
+          dispatcher: Prism::Dispatcher,
+          document: T.any(RubyDocument, ERBDocument),
+        ).void
+      end
+      def initialize(i18n_index, response_builder, dispatcher, document)
+        absolute_path = T.must(document.uri.path)
+        @absolute_path = T.let(absolute_path, String)
+        @path = T.let(Pathname(absolute_path).relative_path_from(Dir.pwd), Pathname)
+        @i18n_index = i18n_index
+        @response_builder = response_builder
+
+        dispatcher.register(
+          self,
+          :on_call_node_enter,
+        )
+      end
+
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_enter(node)
+        return unless node.name == :t
+
+        receiver = node.receiver
+        return unless receiver.is_a?(Prism::ConstantReadNode)
+
+        return unless receiver.name == :I18n
+
+        arguments = node.arguments
+        return unless arguments
+        return if arguments.arguments.empty?
+
+        return if i18n_arguments_has_scope_argument(arguments)
+
+        key_node = arguments.arguments.first
+        return unless key_node.is_a?(Prism::StringNode)
+
+        key = key_node.unescaped
+
+        matches = @i18n_index.find(key)
+
+        tooltip_content = <<~MARKDOWN
+          **Translations (es)**
+          #{matches.map { |match| "- [#{match.file}](#{create_file_uri(match.file)}): #{match.value}" }.join("\n")}
+        MARKDOWN
+
+        suggested_path = @path.to_s.gsub("app", "config/locales").gsub(@path.basename.to_s, "es.yml")
+        suggested_path_link = create_file_uri(suggested_path)
+        if matches.empty?
+          tooltip_content += <<~MARKDOWN
+            ⚠️ Translation missing\n
+            suggested file: [#{suggested_path}](#{suggested_path_link})
+          MARKDOWN
+        end
+
+        if matches.size > 1
+          tooltip_content += <<~MARKDOWN
+            \n ⚠️ There are more than one translation for this key
+          MARKDOWN
+        end
+
+        tooltip = Interface::MarkupContent.new(
+          kind: "markdown",
+          value: tooltip_content,
+        )
+
+        value = matches.first&.value || "⚠️ Translation missing"
+
+        @response_builder << Interface::InlayHint.new(
+          position: { line: node.location.start_line - 1, character: node.location.end_column },
+          label: value,
+          padding_left: true,
+          tooltip: tooltip,
+        )
+      end
+
+      private
+
+      sig { params(path: String).returns(String) }
+      def create_file_uri(path)
+        base_uri = "file://#{Dir.pwd}/"
+        URI.join(base_uri, path).to_s
+      end
+
+      sig { params(arguments: Prism::ArgumentsNode).returns(T::Boolean) }
+      def i18n_arguments_has_scope_argument(arguments)
+        arguments = arguments.arguments
+        return false if arguments.size <= 1
+
+        # Check if the key is scoped, and if it is, ignore it
+        keyword_arguments = arguments[1]
+        if keyword_arguments.is_a?(Prism::KeywordHashNode)
+          keyword_argument_nodes = keyword_arguments.elements.grep(Prism::AssocNode)
+          keyword_argument_nodes.each do |arg|
+            key = arg.key
+            next unless key.is_a?(Prism::SymbolNode)
+
+            if key.value == "scope"
+              return true
+            end
+          end
+        end
+        false
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_i18n/prefix_tree.rb

@@ -0,0 +1,158 @@
+# typed: true
+# frozen_string_literal: true
+
+module RubyLsp
+  module RubyLspI18n
+    # Copy from: https://github.com/Shopify/ruby-lsp/blob/main/lib/ruby_indexer/lib/ruby_indexer/prefix_tree.rb
+    # A PrefixTree is a data structure that allows searching for partial strings fast. The tree is similar to a nested
+    # hash structure, where the keys are the characters of the inserted strings.
+    #
+    # ## Example
+    # ```ruby
+    # tree = PrefixTree[String].new
+    # # Insert entries using the same key and value
+    # tree.insert("bar", "bar")
+    # tree.insert("baz", "baz")
+    # # Internally, the structure is analogous to this, but using nodes:
+    # # {
+    # #   "b" => {
+    # #     "a" => {
+    # #       "r" => "bar",
+    # #       "z" => "baz"
+    # #     }
+    # #   }
+    # # }
+    # # When we search it, it finds all possible values based on partial (or complete matches):
+    # tree.search("") # => ["bar", "baz"]
+    # tree.search("b") # => ["bar", "baz"]
+    # tree.search("ba") # => ["bar", "baz"]
+    # tree.search("bar") # => ["bar"]
+    # ```
+    #
+    # A PrefixTree is useful for autocomplete, since we always want to find all alternatives while the developer hasn't
+    # finished typing yet. This PrefixTree implementation allows for string keys and any arbitrary value using the
+    # generic
+    # `Value` type.
+    #
+    # See https://en.wikipedia.org/wiki/Trie for more information
+    class PrefixTree
+      extend T::Sig
+      extend T::Generic
+
+      Value = type_member
+
+      sig { void }
+      def initialize
+        @root = T.let(Node.new("", ""), Node[Value])
+      end
+
+      # Search the PrefixTree based on a given `prefix`. If `foo` is an entry in the tree, then searching for `fo` will
+      # return it as a result. The result is always an array of the type of value attribute to the generic `Value` type.
+      # Notice that if the `Value` is an array, this method will return an array of arrays, where each entry is
+      # the array
+      # of values for a given match
+      sig { params(prefix: String).returns(T::Array[Value]) }
+      def search(prefix)
+        node = find_node(prefix)
+        return [] unless node
+
+        node.collect
+      end
+
+      # Inserts a `value` using the given `key`
+      sig { params(key: String, value: Value).void }
+      def insert(key, value)
+        node = @root
+
+        key.each_char do |char|
+          node = node.children[char] ||= Node.new(char, value, node)
+        end
+
+        # This line is to allow a value to be overridden. When we are indexing files, we want to be able to update
+        # entries for a given fully qualified name if we find more occurrences of it. Without being able to override,
+        # that would not be possible
+        node.value = value
+        node.leaf = true
+      end
+
+      # Deletes the entry identified by `key` from the tree. Notice that a partial match will still delete all entries
+      # that match it. For example, if the tree contains `foo` and we ask to delete `fo`, then `foo` will be deleted
+      sig { params(key: String).void }
+      def delete(key)
+        node = find_node(key)
+        return unless node
+
+        # Remove the node from the tree and then go up the parents to remove any of them with empty children
+        parent = T.let(T.must(node.parent), T.nilable(Node[Value]))
+
+        while parent
+          parent.children.delete(node.key)
+          return if parent.children.any? || parent.leaf
+
+          node = parent
+          parent = parent.parent
+        end
+      end
+
+      private
+
+      # Find a node that matches the given `key`
+      sig { params(key: String).returns(T.nilable(Node[Value])) }
+      def find_node(key)
+        node = @root
+
+        key.each_char do |char|
+          snode = node.children[char]
+          return nil unless snode
+
+          node = snode
+        end
+
+        node
+      end
+
+      class Node
+        extend T::Sig
+        extend T::Generic
+
+        Value = type_member
+
+        sig { returns(T::Hash[String, Node[Value]]) }
+        attr_reader :children
+
+        sig { returns(String) }
+        attr_reader :key
+
+        sig { returns(Value) }
+        attr_accessor :value
+
+        sig { returns(T::Boolean) }
+        attr_accessor :leaf
+
+        sig { returns(T.nilable(Node[Value])) }
+        attr_reader :parent
+
+        sig { params(key: String, value: Value, parent: T.nilable(Node[Value])).void }
+        def initialize(key, value, parent = nil)
+          @key = key
+          @value = value
+          @parent = parent
+          @children = {}
+          @leaf = false
+        end
+
+        sig { returns(T::Array[Value]) }
+        def collect
+          result = []
+          result << @value if @leaf
+
+          @children.each_value do |node|
+            result.concat(node.collect)
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_i18n/requests/inlay_hints.rb

@@ -0,0 +1,36 @@
+# typed: true
+# frozen_string_literal: true
+
+# Moneky patch overrifing the InlayHints Initializer
+# to support addons for InlayHints in the ruby lsp.
+module RubyLsp
+  module Requests
+    module InlayHintsPatch
+      extend T::Sig
+      extend T::Helpers
+
+      requires_ancestor { InlayHints }
+
+      sig do
+        params(
+          document: T.any(RubyDocument, ERBDocument),
+          hints_configuration: RequestConfig,
+          dispatcher: Prism::Dispatcher,
+        ).void
+      end
+      def initialize(document, hints_configuration, dispatcher)
+        super
+
+        Addon.addons.each do |addon|
+          next unless addon.respond_to?(:create_inlay_hints_listener)
+
+          addon.create_inlay_hints_listener(@response_builder, dispatcher, document)
+        end
+      end
+    end
+
+    class InlayHints
+      prepend InlayHintsPatch
+    end
+  end
+end

data/lib/ruby_lsp_i18n/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module RubyLspI18n
+    VERSION = "0.3.0"
+  end
+end

data/lib/ruby_lsp_i18n.rb

@@ -0,0 +1,9 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "ruby_lsp_i18n/version"
+
+module RubyLsp
+  module RubyLspI18n
+  end
+end

data/ruby-lsp-i18n.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "lib/ruby_lsp_i18n/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "ruby-lsp-i18n"
+  spec.version = RubyLsp::RubyLspI18n::VERSION
+  spec.authors = ["domingo2000"]
+  spec.email = ["dedwards@buk.cl"]
+
+  spec.summary = "Gives support for i18n in Ruby LSP"
+  spec.description = "Gives support for i18n in Ruby LSP"
+  spec.homepage = "https://github.com/bukhr/ruby-lsp-i18n"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/bukhr/ruby-lsp-i18n"
+  spec.metadata["changelog_uri"] = "https://github.com/bukhr/ruby-lsp-i18n/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    %x(git ls-files -z).split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?("bin/", "test/", "spec/", "features/", ".git", ".github", "appveyor", "Gemfile")
+    end
+  end
+
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end

data/sorbet/config

@@ -0,0 +1,4 @@
+--dir
+.
+--ignore=tmp/
+--ignore=vendor/

data/sorbet/rbi/annotations/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-vendored=true

data/sorbet/rbi/annotations/minitest.rbi

@@ -0,0 +1,119 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Minitest::Assertions
+  sig { params(test: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert(test, msg = nil); end
+
+  sig { params(obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_empty(obj, msg = nil); end
+
+  sig { params(exp: T.anything, act: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_equal(exp, act, msg = nil); end
+
+  sig { params(exp: T.anything, act: T.anything, delta: Numeric, msg: T.anything).returns(TrueClass) }
+  def assert_in_delta(exp, act, delta = T.unsafe(nil), msg = nil); end
+
+  sig { params(a: T.anything, b: T.anything, epsilon: Numeric, msg: T.anything).returns(TrueClass) }
+  def assert_in_epsilon(a, b, epsilon = T.unsafe(nil), msg = nil); end
+
+  sig { params(collection: T.anything, obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_includes(collection, obj, msg = nil); end
+
+  sig { params(cls: T.anything, obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_instance_of(cls, obj, msg = nil); end
+
+  sig { params(cls: T.anything, obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_kind_of(cls, obj, msg = nil); end
+
+  sig { params(matcher: T.any(String, Regexp), obj: T.anything, msg: T.anything).returns(MatchData) }
+  def assert_match(matcher, obj, msg = nil); end
+
+  sig { params(obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_nil(obj, msg = nil); end
+
+  sig { params(o1: T.anything, op: T.any(Symbol, String), o2: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_operator(o1, op, o2 = T.unsafe(nil), msg = nil); end
+
+  sig { params(stdout: T.nilable(T.any(String, Regexp)), stderr: T.nilable(T.any(String, Regexp)), block: T.proc.void).returns(T::Boolean) }
+  def assert_output(stdout = nil, stderr = nil, &block); end
+
+  sig { params(path: T.any(String, Pathname), msg: T.anything).returns(TrueClass) }
+  def assert_path_exists(path, msg = nil); end
+
+  sig { params(block: T.proc.void).returns(TrueClass) }
+  def assert_pattern(&block); end
+
+  sig { params(o1: T.anything, op: T.any(String, Symbol), msg: T.anything).returns(TrueClass) }
+  def assert_predicate(o1, op, msg = nil); end
+
+  sig { params(exp: NilClass, block: T.proc.void).returns(StandardError) }
+  sig { type_parameters(:T).params(exp: T.any(T::Class[T.type_parameter(:T)], Regexp, String), block: T.proc.void).returns(T.type_parameter(:T)) }
+  def assert_raises(*exp, &block); end
+
+  sig { params(obj: T.anything, meth: T.any(String, Symbol), msg: T.anything, include_all: T::Boolean).returns(TrueClass) }
+  def assert_respond_to(obj, meth, msg = nil, include_all: false); end
+
+  sig { params(exp: T.anything, act: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_same(exp, act, msg = nil); end
+
+  sig { params(send_ary: T::Array[T.anything], m: T.anything).returns(T::Boolean) }
+  def assert_send(send_ary, m = nil); end
+
+  sig { params(block: T.proc.void).returns(T::Boolean) }
+  def assert_silent(&block); end
+
+  sig { params(sym: Symbol, msg: T.anything, block: T.proc.void).returns(T.anything) }
+  def assert_throws(sym, msg = nil, &block); end
+
+  sig { params(test: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute(test, msg = nil); end
+
+  sig { params(obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_empty(obj, msg = nil); end
+
+  sig { params(exp: T.anything, act: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_equal(exp, act, msg = nil); end
+
+  sig { params(exp: T.anything, act: T.anything, delta: Numeric, msg: T.anything).returns(TrueClass) }
+  def refute_in_delta(exp, act, delta = T.unsafe(nil), msg = nil); end
+
+  sig { params(a: T.anything, b: T.anything, epsilon: Numeric, msg: T.anything).returns(TrueClass) }
+  def refute_in_epsilon(a, b, epsilon = T.unsafe(nil), msg = nil); end
+
+  sig { params(collection: T.anything, obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_includes(collection, obj, msg = nil); end
+
+  sig { params(cls: T.anything, obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_instance_of(cls, obj, msg = nil); end
+
+  sig { params(cls: T.anything, obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_kind_of(cls, obj, msg = nil); end
+
+  sig { params(matcher: T.any(String, Regexp), obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_match(matcher, obj, msg = nil); end
+
+  sig { params(obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_nil(obj, msg = nil); end
+
+  sig { params(block: T.proc.void).returns(TrueClass) }
+  def refute_pattern(&block); end
+
+  sig { params(o1: T.anything, op: T.any(Symbol, String), o2: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_operator(o1, op, o2 = T.unsafe(nil), msg = nil); end
+
+  sig { params(path: T.any(String, Pathname), msg: T.anything).returns(TrueClass) }
+  def refute_path_exists(path, msg = nil); end
+
+  sig { params(o1: T.anything, op: T.any(String, Symbol), msg: T.anything).returns(TrueClass) }
+  def refute_predicate(o1, op, msg = nil); end
+
+  sig { params(obj: T.anything, meth: T.any(String, Symbol), msg: T.anything, include_all: T::Boolean).returns(TrueClass) }
+  def refute_respond_to(obj, meth, msg = nil, include_all: false); end
+
+  sig { params(exp: T.anything, act: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_same(exp, act, msg = nil); end
+end