ruby-lsp-rails 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5133a59bd3960baa206580c91b1504a91a94089591ea6211123038f28c40eaf7
-  data.tar.gz: 618627944a25edf11210afebc4f45112554125f8021787048a159ac13af0d15f
+  metadata.gz: 79a5ef8571e1fd77b8bbd08a782ef68f1116ce4b71e206eee890d573dd2b90dd
+  data.tar.gz: de8459cb09768c703b0f864f008238a40b78210acdef0e9eba8f4d4fd37c65d7
 SHA512:
-  metadata.gz: 6f3e0395d614c55814e33fd52843e714458d7dd17b1460bb0ee64a796159138e42e6d4455d7a0e9cfb5648ca3b9609df9659f663e0d426aeb18938b62ef16517
-  data.tar.gz: 7f3d0408b2122e4ff0a7f6ac82d4cd5e82e2c7d858f801ea19cac06c4043aca81efe4e2a75de1724d854669d1cd1e9fbe8f6b2e7258cd1e3f442868f48e382e3
+  metadata.gz: f0160d705fba4c081925b29efce3b2d8cc9a8243e8b9e53fa8a7820ffe62b5f0ecf12c73d5546b38f3289d807018f7bc7cbd82acbc296a2151c342ffcbf709be
+  data.tar.gz: 7d033dea267d94c5068bbbf4698e2c5b8bab63708021f78c67a90eed6b2e43c7a48e731a68fa5bd7c8d3a0c49a55eb600b14f1d40001f70fb050cbb5a538a7d4

data/README.md

@@ -45,7 +45,7 @@ See the [documentation](https://shopify.github.io/ruby-lsp-rails) for more in-de
 
 ### Running Tests
 
-1. Open a test which inherits from `ActiveSupport::TestCase` or one if its descendants, such as `ActionDispatch::IntegrationTest`.
+1. Open a test which inherits from `ActiveSupport::TestCase` or one of its descendants, such as `ActionDispatch::IntegrationTest`.
 2. Click on the "Run", "Run in Terminal" or "Debug" code lens which appears above the test class, or an individual test.
 
 Note: When using the Test Explorer view, if your code contains a statement to pause execution (e.g. `debugger`) it will

data/lib/ruby_lsp/ruby_lsp_rails/code_lens.rb

@@ -39,15 +39,13 @@ module RubyLsp
       ResponseType = type_member { { fixed: T::Array[::RubyLsp::Interface::CodeLens] } }
       BASE_COMMAND = "bin/rails test"
 
-      ::RubyLsp::Requests::CodeLens.add_listener(self)
-
       sig { override.returns(ResponseType) }
       attr_reader :response
 
-      sig { params(uri: String, emitter: EventEmitter, message_queue: Thread::Queue).void }
+      sig { params(uri: URI::Generic, emitter: EventEmitter, message_queue: Thread::Queue).void }
       def initialize(uri, emitter, message_queue)
         @response = T.let([], ResponseType)
-        @path = T.let(URI(uri).path, T.nilable(String))
+        @path = T.let(uri.to_standardized_path, T.nilable(String))
         emitter.register(self, :on_command, :on_class, :on_def)
 
         super(emitter, message_queue)
@@ -59,16 +57,26 @@ module RubyLsp
         return unless message_value == "test" && node.arguments.parts.any?
 
         first_argument = node.arguments.parts.first
-        return unless first_argument.is_a?(SyntaxTree::StringLiteral)
+
+        parts = case first_argument
+        when SyntaxTree::StringConcat
+          # We only support two lines of concatenation on test names
+          if first_argument.left.is_a?(SyntaxTree::StringLiteral) &&
+              first_argument.right.is_a?(SyntaxTree::StringLiteral)
+            [*first_argument.left.parts, *first_argument.right.parts]
+          end
+        when SyntaxTree::StringLiteral
+          first_argument.parts
+        end
 
         # The test name may be a blank string while the code is being typed
-        return if first_argument.parts.empty?
+        return if parts.nil? || parts.empty?
 
         # We can't handle interpolation yet
-        return unless first_argument.parts.all? { |part| part.is_a?(SyntaxTree::TStringContent) }
+        return unless parts.all? { |part| part.is_a?(SyntaxTree::TStringContent) }
 
-        test_name = first_argument.parts.first.value
-        return unless test_name
+        test_name = parts.map(&:value).join
+        return if test_name.empty?
 
         line_number = node.location.start_line
         command = "#{BASE_COMMAND} #{@path}:#{line_number}"
@@ -99,6 +107,8 @@ module RubyLsp
 
       sig { params(node: SyntaxTree::Node, name: String, command: String, kind: Symbol).void }
       def add_test_code_lens(node, name:, command:, kind:)
+        return unless @path
+
         arguments = [
           @path,
           name,

data/lib/ruby_lsp/ruby_lsp_rails/extension.rb

@@ -12,9 +12,39 @@ module RubyLsp
     class Extension < ::RubyLsp::Extension
       extend T::Sig
 
+      sig { returns(RailsClient) }
+      def client
+        @client ||= T.let(RailsClient.new, T.nilable(RailsClient))
+      end
+
       sig { override.void }
       def activate
-        RubyLsp::Rails::RailsClient.instance.check_if_server_is_running!
+        client.check_if_server_is_running!
+      end
+
+      sig { override.void }
+      def deactivate; end
+
+      # Creates a new CodeLens listener. This method is invoked on every CodeLens request
+      sig do
+        override.params(
+          uri: URI::Generic,
+          emitter: EventEmitter,
+          message_queue: Thread::Queue,
+        ).returns(T.nilable(Listener[T::Array[Interface::CodeLens]]))
+      end
+      def create_code_lens_listener(uri, emitter, message_queue)
+        CodeLens.new(uri, emitter, message_queue)
+      end
+
+      sig do
+        override.params(
+          emitter: EventEmitter,
+          message_queue: Thread::Queue,
+        ).returns(T.nilable(Listener[T.nilable(Interface::Hover)]))
+      end
+      def create_hover_listener(emitter, message_queue)
+        Hover.new(client, emitter, message_queue)
       end
 
       sig { override.returns(String) }

data/lib/ruby_lsp/ruby_lsp_rails/hover.rb

@@ -1,6 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
+require_relative "support/rails_document_client"
+
 module RubyLsp
   module Rails
     # ![Hover demo](../../hover.gif)
@@ -20,33 +22,62 @@ module RubyLsp
 
       ResponseType = type_member { { fixed: T.nilable(::RubyLsp::Interface::Hover) } }
 
-      ::RubyLsp::Requests::Hover.add_listener(self)
-
       sig { override.returns(ResponseType) }
       attr_reader :response
 
-      sig { params(emitter: RubyLsp::EventEmitter, message_queue: Thread::Queue).void }
-      def initialize(emitter, message_queue)
-        super
+      sig { params(client: RailsClient, emitter: RubyLsp::EventEmitter, message_queue: Thread::Queue).void }
+      def initialize(client, emitter, message_queue)
+        super(emitter, message_queue)
 
         @response = T.let(nil, ResponseType)
-        emitter.register(self, :on_const)
+        @client = client
+        emitter.register(self, :on_const, :on_command, :on_const_path_ref, :on_call)
       end
 
       sig { params(node: SyntaxTree::Const).void }
       def on_const(node)
-        model = RailsClient.instance.model(node.value)
+        model = @client.model(node.value)
         return if model.nil?
 
         schema_file = model[:schema_file]
         content = +""
         if schema_file
-          content << "[Schema](file://#{schema_file})\n\n"
+          content << "[Schema](#{URI::Generic.build(scheme: "file", path: schema_file)})\n\n"
         end
         content << model[:columns].map { |name, type| "**#{name}**: #{type}\n" }.join("\n")
         contents = RubyLsp::Interface::MarkupContent.new(kind: "markdown", value: content)
         @response = RubyLsp::Interface::Hover.new(range: range_from_syntax_tree_node(node), contents: contents)
       end
+
+      sig { params(node: SyntaxTree::Command).void }
+      def on_command(node)
+        message = node.message
+        @response = generate_rails_document_link_hover(message.value, message)
+      end
+
+      sig { params(node: SyntaxTree::ConstPathRef).void }
+      def on_const_path_ref(node)
+        @response = generate_rails_document_link_hover(full_constant_name(node), node)
+      end
+
+      sig { params(node: SyntaxTree::CallNode).void }
+      def on_call(node)
+        message = node.message
+        return if message.is_a?(Symbol)
+
+        @response = generate_rails_document_link_hover(message.value, message)
+      end
+
+      private
+
+      sig { params(name: String, node: SyntaxTree::Node).returns(T.nilable(Interface::Hover)) }
+      def generate_rails_document_link_hover(name, node)
+        urls = Support::RailsDocumentClient.generate_rails_document_urls(name)
+        return if urls.empty?
+
+        contents = RubyLsp::Interface::MarkupContent.new(kind: "markdown", value: urls.join("\n\n"))
+        RubyLsp::Interface::Hover.new(range: range_from_syntax_tree_node(node), contents: contents)
+      end
     end
   end
 end

data/lib/ruby_lsp/ruby_lsp_rails/rails_client.rb

@@ -1,7 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "singleton"
 require "net/http"
 
 module RubyLsp
@@ -10,35 +9,30 @@ module RubyLsp
       class ServerAddressUnknown < StandardError; end
 
       extend T::Sig
-      include Singleton
 
       SERVER_NOT_RUNNING_MESSAGE = "Rails server is not running. " \
         "To get Rails features in the editor, boot the Rails server"
 
-      sig { returns(String) }
+      sig { returns(Pathname) }
       attr_reader :root
 
       sig { void }
       def initialize
-        project_root = Pathname.new(ENV["BUNDLE_GEMFILE"]).dirname
+        project_root = T.let(Bundler.with_unbundled_env { Bundler.default_gemfile }.dirname, Pathname)
+        dummy_path = project_root.join("test", "dummy")
 
-        if project_root.basename.to_s == ".ruby-lsp"
-          project_root = project_root.join("../")
-        end
-
-        dummy_path = File.join(project_root, "test", "dummy")
-        @root = T.let(Dir.exist?(dummy_path) ? dummy_path : project_root.to_s, String)
-        app_uri_path = "#{@root}/tmp/app_uri.txt"
-
-        if File.exist?(app_uri_path)
-          url = File.read(app_uri_path).chomp
+        @root = T.let(dummy_path.exist? ? dummy_path : project_root, Pathname)
+        app_uri_path = @root.join("tmp", "app_uri.txt")
 
-          scheme, rest = url.split("://")
-          uri, port = T.must(rest).split(":")
+        if app_uri_path.exist?
+          url = URI(app_uri_path.read.chomp)
 
-          @ssl = T.let(scheme == "https", T::Boolean)
-          @uri = T.let(T.must(uri), T.nilable(String))
-          @port = T.let(T.must(port).to_i, Integer)
+          @ssl = T.let(url.scheme == "https", T::Boolean)
+          @address = T.let(
+            [url.host, url.path].reject { |component| component.nil? || component.empty? }.join("/"),
+            T.nilable(String),
+          )
+          @port = T.let(T.must(url.port).to_i, Integer)
         end
       end
 
@@ -48,16 +42,21 @@ module RubyLsp
         return unless response.code == "200"
 
         JSON.parse(response.body.chomp, symbolize_names: true)
-      rescue Errno::ECONNREFUSED, Errno::EADDRNOTAVAIL, Net::ReadTimeout, ServerAddressUnknown
+      rescue Errno::ECONNREFUSED,
+             Errno::EADDRNOTAVAIL,
+             Errno::ECONNRESET,
+             Net::ReadTimeout,
+             Net::OpenTimeout,
+             ServerAddressUnknown
         nil
       end
 
       sig { void }
       def check_if_server_is_running!
         request("activate", 0.2)
-      rescue Errno::ECONNREFUSED, Errno::EADDRNOTAVAIL, ServerAddressUnknown
+      rescue Errno::ECONNREFUSED, Errno::EADDRNOTAVAIL, Errno::ECONNRESET, ServerAddressUnknown
         warn(SERVER_NOT_RUNNING_MESSAGE)
-      rescue Net::ReadTimeout
+      rescue Net::ReadTimeout, Net::OpenTimeout
         # If the server is running, but the initial request is taking too long, we don't want to block the
         # initialization of the Ruby LSP
       end
@@ -66,9 +65,9 @@ module RubyLsp
 
       sig { params(path: String, timeout: T.nilable(Float)).returns(Net::HTTPResponse) }
       def request(path, timeout = nil)
-        raise ServerAddressUnknown unless @uri
+        raise ServerAddressUnknown unless @address
 
-        http = Net::HTTP.new(@uri, @port)
+        http = Net::HTTP.new(@address, @port)
         http.use_ssl = @ssl
         http.read_timeout = timeout if timeout
         http.get("/ruby_lsp_rails/#{path}")

data/lib/ruby_lsp/ruby_lsp_rails/support/rails_document_client.rb

@@ -0,0 +1,124 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "net/http"
+
+module RubyLsp
+  module Rails
+    module Support
+      class RailsDocumentClient
+        RAILS_DOC_HOST = "https://api.rubyonrails.org"
+
+        SUPPORTED_RAILS_DOC_NAMESPACES = T.let(
+          Regexp.union(
+            /ActionDispatch/,
+            /ActionController/,
+            /AbstractController/,
+            /ActiveRecord/,
+            /ActiveModel/,
+            /ActiveStorage/,
+            /ActionText/,
+            /ActiveJob/,
+          ).freeze,
+          Regexp,
+        )
+
+        RAILTIES_VERSION = T.let(
+          [*::Gem::Specification.default_stubs, *::Gem::Specification.stubs].find do |s|
+            s.name == "railties"
+          end&.version&.to_s,
+          T.nilable(String),
+        )
+
+        class << self
+          extend T::Sig
+
+          sig { params(name: String).returns(T::Array[String]) }
+          def generate_rails_document_urls(name)
+            docs = search_index&.fetch(name, nil)
+
+            return [] unless docs
+
+            docs.map do |doc|
+              owner = doc[:owner]
+
+              link_name =
+                # class/module name
+                if owner == name
+                  name
+                else
+                  "#{owner}##{name}"
+                end
+
+              "[Rails Document: `#{link_name}`](#{doc[:url]})"
+            end
+          end
+
+          sig { returns(T.nilable(T::Hash[String, T::Array[T::Hash[Symbol, String]]])) }
+          private def search_index
+            @rails_documents ||= T.let(
+              build_search_index,
+              T.nilable(T::Hash[String, T::Array[T::Hash[Symbol, String]]]),
+            )
+          end
+
+          sig { returns(T.nilable(T::Hash[String, T::Array[T::Hash[Symbol, String]]])) }
+          private def build_search_index
+            return unless RAILTIES_VERSION
+
+            warn("Fetching Rails Documents...")
+
+            response = Net::HTTP.get_response(URI("#{RAILS_DOC_HOST}/v#{RAILTIES_VERSION}/js/search_index.js"))
+
+            body = case response
+            when Net::HTTPSuccess
+              response.body
+            when Net::HTTPRedirection
+              # If the version's doc is not found, e.g. Rails main, it'll be redirected
+              # In this case, we just fetch the latest doc
+              response = Net::HTTP.get_response(URI("#{RAILS_DOC_HOST}/js/search_index.js"))
+              response.body if response.is_a?(Net::HTTPSuccess)
+            else
+              warn("Response failed: #{response.inspect}")
+              nil
+            end
+
+            process_search_index(body) if body
+          rescue StandardError => e
+            warn("Exception occurred when fetching Rails document index: #{e.inspect}")
+          end
+
+          sig { params(js: String).returns(T::Hash[String, T::Array[T::Hash[Symbol, String]]]) }
+          private def process_search_index(js)
+            raw_data = js.sub("var search_data = ", "")
+            info = JSON.parse(raw_data).dig("index", "info")
+
+            # An entry looks like this:
+            #
+            # ["belongs_to",                                                              # method or module/class
+            #  "ActiveRecord::Associations::ClassMethods",                                # method owner
+            #  "classes/ActiveRecord/Associations/ClassMethods.html#method-i-belongs_to", # path to the document
+            #  "(name, scope = nil, **options)",                                          # method's parameters
+            #  "<p>Specifies a one-to-one association with another class..."]             # document preview
+            #
+            info.each_with_object({}) do |(method_or_class, method_owner, doc_path, _, doc_preview), table|
+              # If a method doesn't have documentation, there's no need to generate the link to it.
+              next if doc_preview.nil? || doc_preview.empty?
+
+              # If the method or class/module is not from the supported namespace, reject it
+              next unless [method_or_class, method_owner].any? do |elem|
+                            elem.match?(SUPPORTED_RAILS_DOC_NAMESPACES)
+                          end
+
+              owner = method_owner.empty? ? method_or_class : method_owner
+              table[method_or_class] ||= []
+              # It's possible to have multiple modules defining the same method name. For example,
+              # both `ActiveRecord::FinderMethods` and `ActiveRecord::Associations::CollectionProxy` defines `#find`
+              table[method_or_class] << { owner: owner, url: "#{RAILS_DOC_HOST}/v#{RAILTIES_VERSION}/#{doc_path}" }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp_rails/railtie.rb

@@ -23,8 +23,8 @@ module RubyLsp
           if defined?(::Rails::Server)
             ssl_enable, host, port = ::Rails::Server::Options.new.parse!(ARGV).values_at(:SSLEnable, :Host, :Port)
             app_uri = "#{ssl_enable ? "https" : "http"}://#{host}:#{port}"
-            app_uri_path = "#{::Rails.root}/tmp/app_uri.txt"
-            File.write(app_uri_path, app_uri)
+            app_uri_path = ::Rails.root.join("tmp", "app_uri.txt")
+            app_uri_path.write(app_uri)
 
             at_exit do
               # The app_uri.txt file should only exist when the server is running. The extension uses its presence to

data/lib/ruby_lsp_rails/version.rb

@@ -3,6 +3,6 @@
 
 module RubyLsp
   module Rails
-    VERSION = "0.2.2"
+    VERSION = "0.2.4"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.4
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-07-06 00:00:00.000000000 Z
+date: 2023-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -30,20 +30,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.2
+        version: 0.9.1
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.10.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.2
+        version: 0.9.1
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.10.0
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -73,6 +73,7 @@ files:
 - lib/ruby_lsp/ruby_lsp_rails/extension.rb
 - lib/ruby_lsp/ruby_lsp_rails/hover.rb
 - lib/ruby_lsp/ruby_lsp_rails/rails_client.rb
+- lib/ruby_lsp/ruby_lsp_rails/support/rails_document_client.rb
 - lib/ruby_lsp_rails/rack_app.rb
 - lib/ruby_lsp_rails/railtie.rb
 - lib/ruby_lsp_rails/version.rb
@@ -100,7 +101,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.14
+rubygems_version: 3.4.18
 signing_key: 
 specification_version: 4
 summary: A Ruby LSP extension for Rails