ruby-lsp-rails 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5133a59bd3960baa206580c91b1504a91a94089591ea6211123038f28c40eaf7
-  data.tar.gz: 618627944a25edf11210afebc4f45112554125f8021787048a159ac13af0d15f
+  metadata.gz: 23121486fc120767731f9aa1e710d7e6a80ffa6a3832ea87cf3d142e6a3adb59
+  data.tar.gz: 75d08ce0a40859d1d45a6244ba5efc4d582eef554df5ea36332d486190ec5e71
 SHA512:
-  metadata.gz: 6f3e0395d614c55814e33fd52843e714458d7dd17b1460bb0ee64a796159138e42e6d4455d7a0e9cfb5648ca3b9609df9659f663e0d426aeb18938b62ef16517
-  data.tar.gz: 7f3d0408b2122e4ff0a7f6ac82d4cd5e82e2c7d858f801ea19cac06c4043aca81efe4e2a75de1724d854669d1cd1e9fbe8f6b2e7258cd1e3f442868f48e382e3
+  metadata.gz: 1b1ffcb3291ab359dbd37218902feb2294e4092f4380111ded16824deab8980f77ce86e87525d34f4debcf7daceca73bac4d655ad52f7668265df943e821d0f5
+  data.tar.gz: 7c6d601aa7170cfa330079b1edae2c9d99bd70761c85b09eabdc0232b1789be88abe1451000bf308f57f2216ef6d8c57c29e8662d16b0b40b264952e60208ac3

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

@@ -20,28 +20,27 @@ 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)
+        @client = client
         emitter.register(self, :on_const)
       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)

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,27 @@ 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)
+          @uri = T.let(T.must(url.path), T.nilable(String))
+          @port = T.let(T.must(url.port).to_i, Integer)
         end
       end
 
@@ -48,16 +39,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

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.3"
   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.3
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-07-06 00:00:00.000000000 Z
+date: 2023-08-09 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.8.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.9.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.2
+        version: 0.8.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.9.0
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -100,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.14
+rubygems_version: 3.4.17
 signing_key: 
 specification_version: 4
 summary: A Ruby LSP extension for Rails