ruby-lsp-rails 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0cdbd01ae2a03195931208bf88504c5e06ae95b321e32e1c07a5fcef993817dc
-  data.tar.gz: 8ee3dbd7f7b0bc4851e98a51e624700526f0fbbd7535495e52bd7f9fe43d581a
+  metadata.gz: 641af662aeb7df4487d90ec7ffe3c1f26b7f8a936700a3b8dc5ec77d38eb65ba
+  data.tar.gz: 52d1989ad1288d0e3a0d0d478cdd9a79cb0ff33a3ddf25e2757a80e6822be7d3
 SHA512:
-  metadata.gz: c2adee12e7cf92359ee6b26b64ade207c3507e2f881d0b2d00ee6b30e45e3bff1025735e616d1da062d6bde2d70bbd72ae73114f1cc13f17a30f47e48171b6a7
-  data.tar.gz: 67307e0b0388f38e254f1fbc1822b8814075cd5ded94b73e674b1ef35cc1c989dfd2286bac4eaa901e45caa6335e024d80480470c30d08c74a2a812bf377e365
+  metadata.gz: f3b5ab9bad1cd657d5f79f0ef467435f6840ee720cf5b7b332e42fed3b050170521fcd0bbc590f72d0d865fb8f73daa2b0d16b16e11e61d8e2416f1963b51f83
+  data.tar.gz: d9f1be241d9ab18e8cfb44c62b52b09634a598bb02420dcf55a2f0de6cb8185a4aa05d41cc5d9011a5fcdbe268cf8c1178ff8d24c42b8c52abcd7d2ce225a6d4

data/README.md

@@ -3,39 +3,68 @@
 Ruby LSP Rails is a [Ruby LSP](https://github.com/Shopify/ruby-lsp) extension for extra Rails editor features, such as:
 
 - Displaying an ActiveRecord model's database columns and types when hovering over it
-- (More to come!)
-
+- Running tests and debugging tests through the terminal or the editor's UI
 
 ## Installation
 
 To install, add the following line to your application's Gemfile:
 
 ```ruby
+# Gemfile
 group :development do
   gem "ruby-lsp-rails"
 end
 ```
+Some features rely on server introspection, and use a Rack server which is automatically mounted by using a Railtie.
+
+For applications with specialized routing requirements, such as custom sharding, this may not be compatible. It can
+be disabled with:
+
+```ruby
+# config/environments/development.rb
+Rails.application.configure do
+  # ...
+  config.ruby_lsp_rails.server = false
+  # ...
+end
+```
 
 ## Usage
 
+### Hover to reveal ActiveRecord schema
+
 1. Start your Rails server
 1. Hover over an ActiveRecord model to see its details
 
+Nested models (e.g. `Admin::User`) are not yet supported.
+
+### Documentation
+
+See the [documentation](https://shopify.github.io/ruby-lsp-rails) for more in-depth details about the
+[supported features](https://shopify.github.io/ruby-lsp-rails/RubyLsp/Rails.html).
+
+### Running Tests
+
+1. Open a test which inherits from `ActiveSupport::TestCase` or one if 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
+cause the test runner to hang.
+
 ## How It Works
 
 This gem consists of two components that enable enhanced Rails functionality in the editor:
 
-1. A Rails engine that automatically exposes APIs when Rails server is running
+1. A Rack app that automatically exposes APIs when Rails server is running
 1. A Ruby LSP extension that connects to the exposed APIs to fetch runtime information from the Rails server
 
-This is why the Rails server needs to be running for features to work.
+This is why the Rails server needs to be running for some features to work.
 
 > **Note**
 >
 > There is no need to restart the Ruby LSP every time the Rails server is booted.
 > If the server is shut down, the extra features will temporarily disappear and reappear once the server is running again.
 
-
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/Shopify/ruby-lsp-rails. This project is

data/Rakefile

@@ -9,6 +9,8 @@ load "rails/tasks/statistics.rake"
 
 require "bundler/gem_tasks"
 require "rake/testtask"
+require "ruby_lsp/check_docs"
+require "rdoc/task"
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
@@ -16,4 +18,15 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList["test/**/*_test.rb"]
 end
 
+RDoc::Task.new do |rdoc|
+  rdoc.main = "README.md"
+  rdoc.rdoc_files.include("*.md", "lib/**/*.rb")
+  rdoc.rdoc_dir = "docs"
+  rdoc.markup = "markdown"
+  rdoc.options.push("--copy-files", "misc")
+  rdoc.options.push("--copy-files", "LICENSE.txt")
+end
+
+RubyLsp::CheckDocs.new(FileList["#{__dir__}/lib/ruby_lsp/**/*.rb"], FileList["#{__dir__}/misc/**/*.gif"])
+
 task default: :test

data/lib/ruby-lsp-rails.rb

@@ -7,7 +7,11 @@ require "pathname"
 require "ruby_lsp_rails/version"
 require "ruby_lsp_rails/railtie"
 
-module RubyLSP
+module RubyLsp
+  # # Supported features
+  #
+  # - [Hover](rdoc-ref:RubyLsp::Rails::Hover)
+  # - [CodeLens](rdoc-ref:RubyLsp::Rails::CodeLens)
   module Rails
   end
 end

data/lib/ruby_lsp/ruby_lsp_rails/code_lens.rb

@@ -0,0 +1,134 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Rails
+    # ![CodeLens demo](../../code_lens.gif)
+    #
+    # This feature adds several CodeLens features for Rails applications using Active Support test cases:
+    # - Run tests in the VS Terminal
+    # - Run tests in the VS Code Test Explorer
+    # - Debug tests
+    #
+    # The
+    # [code lens](https://microsoft.github.io/language-server-protocol/specification#textDocument_codeLens)
+    # request informs the editor of runnable commands such as tests
+    #
+    # # Example:
+    #
+    # For the following code, Code Lenses will be added above the class definition above each test method.
+    #
+    # ```ruby
+    # Run
+    # class HelloTest < ActiveSupport::TestCase # <- Will show code lenses above for running or debugging the whole test
+    #   test "outputs hello" do # <- Will show code lenses above for running or debugging this test
+    #     # ...
+    #   end
+    #
+    #   test "outputs goodbye" do # <- Will show code lenses above for running or debugging this test
+    #     # ...
+    #   end
+    # end
+    # ````
+    #
+    # The code lenses will be displayed above the class and above each test method.
+    class CodeLens < ::RubyLsp::Listener
+      extend T::Sig
+      extend T::Generic
+
+      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 }
+      def initialize(uri, emitter, message_queue)
+        @response = T.let([], ResponseType)
+        @path = T.let(URI(uri).path, T.nilable(String))
+        emitter.register(self, :on_command, :on_class, :on_def)
+
+        super(emitter, message_queue)
+      end
+
+      sig { params(node: SyntaxTree::Command).void }
+      def on_command(node)
+        message_value = node.message.value
+        return unless message_value == "test" && node.arguments.parts.any?
+
+        first_argument = node.arguments.parts.first
+        return unless first_argument.is_a?(SyntaxTree::StringLiteral)
+
+        test_name = first_argument.parts.first.value
+        return unless test_name
+
+        line_number = node.location.start_line
+        command = "#{BASE_COMMAND} #{@path}:#{line_number}"
+        add_test_code_lens(node, name: test_name, command: command, kind: :example)
+      end
+
+      # Although uncommon, Rails tests can be written with the classic "def test_name" syntax.
+      sig { params(node: SyntaxTree::DefNode).void }
+      def on_def(node)
+        method_name = node.name.value
+        if method_name.start_with?("test_")
+          line_number = node.location.start_line
+          command = "#{BASE_COMMAND} #{@path}:#{line_number}"
+          add_test_code_lens(node, name: method_name, command: command, kind: :example)
+        end
+      end
+
+      sig { params(node: SyntaxTree::ClassDeclaration).void }
+      def on_class(node)
+        class_name = node.constant.constant.value
+        if class_name.end_with?("Test")
+          command = "#{BASE_COMMAND} #{@path}"
+          add_test_code_lens(node, name: class_name, command: command, kind: :group)
+        end
+      end
+
+      private
+
+      sig { params(node: SyntaxTree::Node, name: String, command: String, kind: Symbol).void }
+      def add_test_code_lens(node, name:, command:, kind:)
+        arguments = [
+          @path,
+          name,
+          command,
+          {
+            start_line: node.location.start_line - 1,
+            start_column: node.location.start_column,
+            end_line: node.location.end_line - 1,
+            end_column: node.location.end_column,
+          },
+        ]
+
+        @response << create_code_lens(
+          node,
+          title: "Run",
+          command_name: "rubyLsp.runTest",
+          arguments: arguments,
+          data: { type: "test", kind: kind },
+        )
+
+        @response << create_code_lens(
+          node,
+          title: "Run In Terminal",
+          command_name: "rubyLsp.runTestInTerminal",
+          arguments: arguments,
+          data: { type: "test_in_terminal", kind: kind },
+        )
+
+        @response << create_code_lens(
+          node,
+          title: "Debug",
+          command_name: "rubyLsp.debugTest",
+          arguments: arguments,
+          data: { type: "debug", kind: kind },
+        )
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_rails/extension.rb

@@ -5,6 +5,7 @@ require "ruby_lsp/extension"
 
 require_relative "rails_client"
 require_relative "hover"
+require_relative "code_lens"
 
 module RubyLsp
   module Rails
@@ -13,7 +14,6 @@ module RubyLsp
 
       sig { override.void }
       def activate
-        # Must be the last statement in activate since it raises to display a notification for the user
         RubyLsp::Rails::RailsClient.instance.check_if_server_is_running!
       end
 

data/lib/ruby_lsp/ruby_lsp_rails/hover.rb

@@ -3,6 +3,17 @@
 
 module RubyLsp
   module Rails
+    # ![Hover demo](../../hover.gif)
+    #
+    # Augment [hover](https://microsoft.github.io/language-server-protocol/specification#textDocument_hover) with
+    # information about a model.
+    #
+    # # Example
+    #
+    # ```ruby
+    # User.all
+    # # ^ hovering here will show information about the User model
+    # ```
     class Hover < ::RubyLsp::Listener
       extend T::Sig
       extend T::Generic
@@ -14,27 +25,27 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :response
 
-      sig { void }
-      def initialize
-        @response = T.let(nil, ResponseType)
+      sig { params(emitter: RubyLsp::EventEmitter, message_queue: Thread::Queue).void }
+      def initialize(emitter, message_queue)
         super
+
+        @response = T.let(nil, ResponseType)
+        emitter.register(self, :on_const)
       end
 
-      listener_events do
-        sig { params(node: SyntaxTree::Const).void }
-        def on_const(node)
-          model = RailsClient.instance.model(node.value)
-          return if model.nil?
-
-          schema_file = model[:schema_file]
-          content = +""
-          if schema_file
-            content << "[Schema](file://#{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)
+      sig { params(node: SyntaxTree::Const).void }
+      def on_const(node)
+        model = RailsClient.instance.model(node.value)
+        return if model.nil?
+
+        schema_file = model[:schema_file]
+        content = +""
+        if schema_file
+          content << "[Schema](file://#{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
     end
   end

data/lib/ruby_lsp/ruby_lsp_rails/rails_client.rb

@@ -7,8 +7,7 @@ require "net/http"
 module RubyLsp
   module Rails
     class RailsClient
-      class ServerNotRunningError < StandardError; end
-      class NeedsRestartError < StandardError; end
+      class ServerAddressUnknown < StandardError; end
 
       extend T::Sig
       include Singleton
@@ -31,15 +30,16 @@ module RubyLsp
         @root = T.let(Dir.exist?(dummy_path) ? dummy_path : project_root.to_s, String)
         app_uri_path = "#{@root}/tmp/app_uri.txt"
 
-        unless File.exist?(app_uri_path)
-          raise NeedsRestartError, <<~MESSAGE
-            The Ruby LSP Rails extension needs to be initialized. Please restart the Rails server and the Ruby LSP
-            to get Rails features in the editor
-          MESSAGE
-        end
+        if File.exist?(app_uri_path)
+          url = File.read(app_uri_path).chomp
+
+          scheme, rest = url.split("://")
+          uri, port = T.must(rest).split(":")
 
-        base_uri = File.read(app_uri_path).chomp
-        @uri = T.let("#{base_uri}/ruby_lsp_rails", String)
+          @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)
+        end
       end
 
       sig { params(name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
@@ -48,34 +48,30 @@ module RubyLsp
         return unless response.code == "200"
 
         JSON.parse(response.body.chomp, symbolize_names: true)
-      rescue Errno::ECONNREFUSED
-        raise ServerNotRunningError, SERVER_NOT_RUNNING_MESSAGE
+      rescue Errno::ECONNREFUSED, ServerAddressUnknown
+        nil
       end
 
       sig { void }
       def check_if_server_is_running!
-        # Check if the Rails server is running. Warn the user to boot it for Rails features
-        pid_file = ENV.fetch("PIDFILE") { File.join(@root, "tmp", "pids", "server.pid") }
-
-        # If the PID file doesn't exist, then the server hasn't been booted
-        raise ServerNotRunningError, SERVER_NOT_RUNNING_MESSAGE unless File.exist?(pid_file)
-
-        pid = File.read(pid_file).to_i
-
-        begin
-          # Issuing an EXIT signal to an existing process actually doesn't make the server shutdown. But if this
-          # call succeeds, then the server is running. If the PID doesn't exist, Errno::ESRCH is raised
-          Process.kill(T.must(Signal.list["EXIT"]), pid)
-        rescue Errno::ESRCH
-          raise ServerNotRunningError, SERVER_NOT_RUNNING_MESSAGE
-        end
+        request("activate", 0.2)
+      rescue Errno::ECONNREFUSED, ServerAddressUnknown
+        warn(SERVER_NOT_RUNNING_MESSAGE)
+      rescue Net::ReadTimeout
+        # 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
 
       private
 
-      sig { params(path: String).returns(Net::HTTPResponse) }
-      def request(path)
-        Net::HTTP.get_response(URI("#{@uri}/#{path}"))
+      sig { params(path: String, timeout: T.nilable(Float)).returns(Net::HTTPResponse) }
+      def request(path, timeout = nil)
+        raise ServerAddressUnknown unless @uri
+
+        http = Net::HTTP.new(@uri, @port)
+        http.use_ssl = @ssl
+        http.read_timeout = timeout if timeout
+        http.get("/ruby_lsp_rails/#{path}")
       end
     end
   end

data/lib/ruby_lsp_rails/{middleware.rb → rack_app.rb}

@@ -3,29 +3,26 @@
 
 module RubyLsp
   module Rails
-    class Middleware
+    class RackApp
       extend T::Sig
 
-      PATH_REGEXP = %r{/ruby_lsp_rails/models/(?<model_name>.+)}
-
-      sig { params(app: T.untyped).void }
-      def initialize(app)
-        @app = app
-      end
+      BASE_PATH = "/ruby_lsp_rails/"
 
       sig { params(env: T::Hash[T.untyped, T.untyped]).returns(T::Array[T.untyped]) }
       def call(env)
         request = ActionDispatch::Request.new(env)
-        # TODO: improve the model name regex
-        match = request.path.match(PATH_REGEXP)
+        path = request.path
 
-        if match
-          resolve_database_info_from_model(match[:model_name])
+        route, argument = path.delete_prefix(BASE_PATH).split("/")
+
+        case route
+        when "activate"
+          [200, { "Content-Type" => "application/json" }, []]
+        when "models"
+          resolve_database_info_from_model(argument)
         else
-          @app.call(env)
+          not_found
         end
-      rescue
-        @app.call(env)
       end
 
       private

data/lib/ruby_lsp_rails/railtie.rb

@@ -1,19 +1,37 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "ruby_lsp_rails/middleware"
+require "rails/railtie"
+require "ruby_lsp_rails/rack_app"
 
 module RubyLsp
   module Rails
     class Railtie < ::Rails::Railtie
-      initializer "ruby_lsp_rails.setup" do |app|
-        app.config.middleware.insert_after(ActionDispatch::ShowExceptions, RubyLsp::Rails::Middleware)
+      config.ruby_lsp_rails = ActiveSupport::OrderedOptions.new
+      config.ruby_lsp_rails.server = true
 
-        config.after_initialize do |_app|
+      initializer "ruby_lsp_rails.setup" do |_app|
+        config.after_initialize do |app|
+          unless config.ruby_lsp_rails.server == false
+            app.routes.prepend do
+              T.bind(self, ActionDispatch::Routing::Mapper)
+              mount(RackApp.new => RackApp::BASE_PATH)
+            end
+          end
+
+          # If we start the app with `bin/rails console` then `Rails::Server` is not defined.
           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}"
-            File.write("#{::Rails.root}/tmp/app_uri.txt", app_uri)
+            app_uri_path = "#{::Rails.root}/tmp/app_uri.txt"
+            File.write(app_uri_path, app_uri)
+
+            at_exit do
+              # The app_uri.txt file should only exist when the server is running. The extension uses its presence to
+              # report if the server is running or not. If the server is not running, some of the extension features
+              # will not be available.
+              File.delete(app_uri_path) if File.exist?(app_uri_path)
+            end
           end
         end
       end

data/lib/ruby_lsp_rails/version.rb

@@ -3,6 +3,6 @@
 
 module RubyLsp
   module Rails
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-21 00:00:00.000000000 Z
+date: 2023-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -28,16 +28,22 @@ dependencies:
   name: ruby-lsp
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.2
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.4.5
+        version: 0.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.2
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.4.5
+        version: 0.8.0
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -63,10 +69,11 @@ files:
 - README.md
 - Rakefile
 - lib/ruby-lsp-rails.rb
+- lib/ruby_lsp/ruby_lsp_rails/code_lens.rb
 - 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_rails/middleware.rb
+- lib/ruby_lsp_rails/rack_app.rb
 - lib/ruby_lsp_rails/railtie.rb
 - lib/ruby_lsp_rails/version.rb
 - lib/tasks/ruby_lsp_rails_tasks.rake
@@ -93,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.12
+rubygems_version: 3.4.14
 signing_key: 
 specification_version: 4
 summary: A Ruby LSP extension for Rails