ruby-lsp-rails 0.3.8 → 0.3.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: accc5f9539ddceaa7fde3dfdb64fcc74f697e9d17178c45e9271df463cad4f18
-  data.tar.gz: d594ee73741270b0d6837680a5bacc6e912c1ca856aeaa5806e7d1ad9e96aeb8
+  metadata.gz: 2499b5ff0e291d166c0fe823ccd3c34d3c60606500a7f9db6a152508cb6f1346
+  data.tar.gz: 7ef48a79261a23f531f0b86ca18f7cec27c9a75490b4b111a495badcdf267fa5
 SHA512:
-  metadata.gz: 955347d73c343311571e62d7c0bb656a3cc9176f8e6ff87ab010287345d754b49f1889c436c716ce0a40c2aa45938f094124cd18315f787c854db7aed2172ee1
-  data.tar.gz: 65731a4414f5b68884ea6003097b5b1e67caaaaf2a954b0d25de0ed937cc7600d1b1e4e8d2c25a28b25f526c72fc05e6f9a1996874f95584c4450a4212ef9269
+  metadata.gz: ee15545d1a6e8dd9221b06f403af4219e59a0b823b527d92edce63539ca11b7fa01faeea1a7c2d8f91933686c8b92884a961698075d7c8826ba24e27619cd509
+  data.tar.gz: dbee9b4f8dc8658254ec9db2d2e585a0fa6a78545a8e296d3b3f4d5881a53cb642475cf92c0915ddfaeeede2306d925957bb75e0d0c52029d3bca4ba39195061

data/README.md

@@ -9,6 +9,8 @@ Ruby LSP Rails is a [Ruby LSP](https://github.com/Shopify/ruby-lsp) addon for ex
 * Navigate to associations, validations, callbacks and test cases using your editor's "Go to Symbol" feature, or outline view.
 * Jump to the definition of callbacks using your editor's "Go to Definition" feature.
 * Jump to the declaration of a route.
+* Code Lens allowing fast-forwarding or rewinding of migrations.
+* Code Lens showing the path that a route action corresponds to.
 
 ## Installation
 

data/lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -53,7 +53,7 @@ module RubyLsp
       def create_code_lens_listener(response_builder, uri, dispatcher)
         return unless T.must(@global_state).test_library == "rails"
 
-        CodeLens.new(response_builder, uri, dispatcher)
+        CodeLens.new(@client, response_builder, uri, dispatcher)
       end
 
       sig do

data/lib/ruby_lsp/ruby_lsp_rails/code_lens.rb

@@ -5,11 +5,22 @@ module RubyLsp
   module Rails
     # ![CodeLens demo](../../code_lens.gif)
     #
-    # This feature adds several CodeLens features for Rails applications using Active Support test cases:
+    # This feature adds Code Lens features for Rails applications.
+    #
+    # For Active Support test cases:
     #
     # - Run tests in the VS Terminal
     # - Run tests in the VS Code Test Explorer
     # - Debug tests
+    # - Run migrations in the VS Terminal
+    #
+    # For Rails controllers:
+    #
+    # - See the path corresponding to an action
+    # - Click on the action's Code Lens to jump to its declaration in the routes.
+    #
+    # Note: This depends on a support for the `rubyLsp.openFile` command.
+    # For the VS Code extension this is built-in, but for other editors this may require some custom configuration.
     #
     # The
     # [code lens](https://microsoft.github.io/language-server-protocol/specification#textDocument_codeLens)
@@ -32,12 +43,34 @@ module RubyLsp
     #     # ...
     #   end
     # end
+    # ```
+    #
+    # # Example:
+    # ```ruby
+    # Run
+    # class AddFirstNameToUsers < ActiveRecord::Migration[7.1]
+    #   # ...
+    # end
     # ````
     #
     # The code lenses will be displayed above the class and above each test method.
     #
     # 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.
+    #
+    # For the following code, assuming the routing contains `resources :users`, a Code Lens will be seen above each
+    # action.
+    #
+    # ```ruby
+    # class UsersController < ApplicationController
+    #   GET /users(.:format)
+    #   def index # <- Will show code lens above for the path
+    #   end
+    # end
+    # ```
+    #
+    # Note: Complex routing configurations may not be supported.
+    #
     class CodeLens
       extend T::Sig
       include Requests::Support::Common
@@ -45,16 +78,19 @@ module RubyLsp
 
       sig do
         params(
+          client: RunnerClient,
           response_builder:  ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
           uri: URI::Generic,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(response_builder, uri, dispatcher)
+      def initialize(client, response_builder, uri, dispatcher)
+        @client = client
         @response_builder = response_builder
         @path = T.let(uri.to_standardized_path, T.nilable(String))
         @group_id = T.let(1, Integer)
         @group_id_stack = T.let([], T::Array[Integer])
+        @constant_name_stack = T.let([], T::Array[[String, T.nilable(String)]])
 
         dispatcher.register(self, :on_call_node_enter, :on_class_node_enter, :on_def_node_enter, :on_class_node_leave)
       end
@@ -74,41 +110,119 @@ module RubyLsp
       sig { params(node: Prism::DefNode).void }
       def on_def_node_enter(node)
         method_name = node.name.to_s
+
         if method_name.start_with?("test_")
           line_number = node.location.start_line
           command = "#{test_command} #{@path}:#{line_number}"
           add_test_code_lens(node, name: method_name, command: command, kind: :example)
         end
+
+        if controller?
+          add_route_code_lens_to_action(node)
+        end
       end
 
       sig { params(node: Prism::ClassNode).void }
       def on_class_node_enter(node)
         class_name = node.constant_path.slice
+        superclass_name = node.superclass&.slice
+
         if class_name.end_with?("Test")
           command = "#{test_command} #{@path}"
           add_test_code_lens(node, name: class_name, command: command, kind: :group)
           @group_id_stack.push(@group_id)
           @group_id += 1
         end
+
+        if superclass_name&.start_with?("ActiveRecord::Migration")
+          command = "#{migrate_command} VERSION=#{migration_version}"
+          add_migrate_code_lens(node, name: class_name, command: command)
+        end
+
+        # We need to use a stack because someone could define a nested class
+        # inside a controller. When we exit that nested class declaration, we are
+        # back in a controller context. This part is used in other places in the LSP
+        @constant_name_stack << [class_name, superclass_name]
       end
 
       sig { params(node: Prism::ClassNode).void }
       def on_class_node_leave(node)
         class_name = node.constant_path.slice
+
         if class_name.end_with?("Test")
           @group_id_stack.pop
         end
+
+        @constant_name_stack.pop
       end
 
       private
 
+      sig { returns(T.nilable(T::Boolean)) }
+      def controller?
+        class_name, superclass_name = T.must(@constant_name_stack.last)
+        class_name.end_with?("Controller") && superclass_name&.end_with?("Controller")
+      end
+
+      sig { params(node: Prism::DefNode).void }
+      def add_route_code_lens_to_action(node)
+        class_name, _ = T.must(@constant_name_stack.last)
+        route = @client.route(
+          controller: class_name,
+          action: node.name.to_s,
+        )
+
+        return unless route
+
+        path = route[:path]
+        verb = route[:verb]
+        source_location = route[:source_location]
+
+        arguments = [
+          source_location,
+          {
+            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_builder << create_code_lens(
+          node,
+          title: [verb, path].join(" "),
+          command_name: "rubyLsp.openFile",
+          arguments: arguments,
+          data: { type: "file" },
+        )
+      end
+
       sig { returns(String) }
       def test_command
-        if Gem.win_platform?
-          "ruby bin/rails test"
-        else
-          "bin/rails test"
-        end
+        "#{RbConfig.ruby} bin/rails test"
+      end
+
+      sig { returns(String) }
+      def migrate_command
+        "#{RbConfig.ruby} bin/rails db:migrate"
+      end
+
+      sig { returns(T.nilable(String)) }
+      def migration_version
+        File.basename(T.must(@path)).split("_").first
+      end
+
+      sig { params(node: Prism::Node, name: String, command: String).void }
+      def add_migrate_code_lens(node, name:, command:)
+        return unless @path
+
+        @response_builder << create_code_lens(
+          node,
+          title: "Run",
+          command_name: "rubyLsp.runTask",
+          arguments: [command],
+          data: { type: "migrate" },
+        )
       end
 
       sig { params(node: Prism::Node, name: String, command: String, kind: Symbol).void }

data/lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -122,6 +122,14 @@ module RubyLsp
         nil
       end
 
+      sig { params(controller: String, action: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      def route(controller:, action:)
+        make_request("route_info", controller: controller, action: action)
+      rescue IncompleteMessageError
+        $stderr.puts("Ruby LSP Rails failed to get route information: #{@stderr.read}")
+        nil
+      end
+
       sig { void }
       def trigger_reload
         $stderr.puts("Reloading Rails application")
@@ -164,6 +172,8 @@ module RubyLsp
         json = message.to_json
 
         @stdin.write("Content-Length: #{json.length}\r\n\r\n", json)
+      rescue Errno::EPIPE
+        # The server connection died
       end
 
       alias_method :send_notification, :send_message
@@ -185,6 +195,9 @@ module RubyLsp
         end
 
         response.fetch(:result)
+      rescue Errno::EPIPE
+        # The server connection died
+        nil
       end
     end
 

data/lib/ruby_lsp/ruby_lsp_rails/server.rb

@@ -54,6 +54,8 @@ module RubyLsp
           VOID
         when "route_location"
           route_location(params.fetch(:name))
+        when "route_info"
+          resolve_route_info(params)
         else
           VOID
         end
@@ -63,6 +65,32 @@ module RubyLsp
 
       private
 
+      def resolve_route_info(requirements)
+        if requirements[:controller]
+          requirements[:controller] = requirements.fetch(:controller).underscore.delete_suffix("_controller")
+        end
+
+        # In Rails 7.2 we can use `from_requirements, otherwise we fall back to a private API
+        route = if ::Rails.application.routes.respond_to?(:from_requirements)
+          ::Rails.application.routes.from_requirements(requirements)
+        else
+          ::Rails.application.routes.routes.find { |route| route.requirements == requirements }
+        end
+
+        if route&.source_location
+          file, _, line = route.source_location.rpartition(":")
+          body = {
+            source_location: [::Rails.root.join(file).to_s, line],
+            verb: route.verb,
+            path: route.path.spec.to_s,
+          }
+
+          { result: body }
+        else
+          { result: nil }
+        end
+      end
+
       # Older versions of Rails don't support `route_source_locations`.
       # We also check that it's enabled.
       if ActionDispatch::Routing::Mapper.respond_to?(:route_source_locations) &&

data/lib/ruby_lsp_rails/version.rb

@@ -3,6 +3,6 @@
 
 module RubyLsp
   module Rails
-    VERSION = "0.3.8"
+    VERSION = "0.3.9"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-rails
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.3.9
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-02 00:00:00.000000000 Z
+date: 2024-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-lsp