ruby-lsp-rails 0.3.25 → 0.3.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03b28222188faf1ac819337e73c244ba0a3cb588acfb286554246151b4beaa1a
-  data.tar.gz: 5558fe8142c90eaa53991f99a54da04b1cf1fe2ded213ae737b55cc9ad8acd78
+  metadata.gz: 2df24f43b3e6666c310cb91e43d3b4311eea8326e27aa7bb4278c9fd03de42d1
+  data.tar.gz: 116f736d81055adf4a287d3d76a4f9e641cf2ac81f2a39b63ccb9603bfbd351e
 SHA512:
-  metadata.gz: fb20529701e3008b9f38ba4840446aed72aad85b9e623bc93f691a7bee1ce0418d0b2bfabef085d5446fced0f645c0f6325dd4e78925f2e3ab20cc43e1d34543
-  data.tar.gz: e8507ef9f18e3987c667f1c45a3419171677f318bfb4ba5572153efea73bf2ec2922a0ec62865d3aabc9e49117af8e86951975a9eadc68d7848ce6d57f75fdb2
+  metadata.gz: c462629b903ebbee663323f52385423fb697bd338bcf7c57574874de21f323230d381c5d6e5eb30602248f33021bc2d0082602fa3b5c0b65d674f9c9c1668ff5
+  data.tar.gz: e909ea43dc3a8012f1de165e1aa4cbf4ad0873134199273103e329fec5ac141792113adb5eb1eb788f065f63e3c2fba299c0501a837719a816b2698e119e50bf

data/lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -56,7 +56,6 @@ module RubyLsp
         @outgoing_queue << Notification.window_log_message("Activating Ruby LSP Rails add-on v#{VERSION}")
 
         register_additional_file_watchers(global_state: global_state, outgoing_queue: outgoing_queue)
-        @global_state.index.register_enhancement(IndexingEnhancement.new(@global_state.index))
 
         # Start booting the real client in a background thread. Until this completes, the client will be a NullClient
         @client_mutex.unlock

data/lib/ruby_lsp/ruby_lsp_rails/indexing_enhancement.rb

@@ -8,25 +8,32 @@ module RubyLsp
 
       sig do
         override.params(
-          owner: T.nilable(RubyIndexer::Entry::Namespace),
-          node: Prism::CallNode,
-          file_path: String,
-          code_units_cache: T.any(
-            T.proc.params(arg0: Integer).returns(Integer),
-            Prism::CodeUnitsCache,
-          ),
+          call_node: Prism::CallNode,
         ).void
       end
-      def on_call_node_enter(owner, node, file_path, code_units_cache)
+      def on_call_node_enter(call_node)
+        owner = @listener.current_owner
         return unless owner
 
-        name = node.name
-
-        case name
+        case call_node.name
         when :extend
-          handle_concern_extend(owner, node)
+          handle_concern_extend(owner, call_node)
         when :has_one, :has_many, :belongs_to, :has_and_belongs_to_many
-          handle_association(owner, node, file_path, code_units_cache)
+          handle_association(owner, call_node)
+        # for `class_methods do` blocks within concerns
+        when :class_methods
+          handle_class_methods(owner, call_node)
+        end
+      end
+
+      sig do
+        override.params(
+          call_node: Prism::CallNode,
+        ).void
+      end
+      def on_call_node_leave(call_node)
+        if call_node.name == :class_methods && call_node.block
+          @listener.pop_namespace_stack
         end
       end
 
@@ -35,16 +42,11 @@ module RubyLsp
       sig do
         params(
           owner: RubyIndexer::Entry::Namespace,
-          node: Prism::CallNode,
-          file_path: String,
-          code_units_cache: T.any(
-            T.proc.params(arg0: Integer).returns(Integer),
-            Prism::CodeUnitsCache,
-          ),
+          call_node: Prism::CallNode,
         ).void
       end
-      def handle_association(owner, node, file_path, code_units_cache)
-        arguments = node.arguments&.arguments
+      def handle_association(owner, call_node)
+        arguments = call_node.arguments&.arguments
         return unless arguments
 
         name_arg = arguments.first
@@ -58,41 +60,22 @@ module RubyLsp
 
         return unless name
 
-        loc = RubyIndexer::Location.from_prism_location(name_arg.location, code_units_cache)
+        loc = name_arg.location
 
         # Reader
-        @index.add(RubyIndexer::Entry::Method.new(
-          name,
-          file_path,
-          loc,
-          loc,
-          nil,
-          [RubyIndexer::Entry::Signature.new([])],
-          RubyIndexer::Entry::Visibility::PUBLIC,
-          owner,
-        ))
+        reader_signatures = [RubyIndexer::Entry::Signature.new([])]
+        @listener.add_method(name, loc, reader_signatures)
 
         # Writer
-        @index.add(RubyIndexer::Entry::Method.new(
-          "#{name}=",
-          file_path,
-          loc,
-          loc,
-          nil,
-          [RubyIndexer::Entry::Signature.new([RubyIndexer::Entry::RequiredParameter.new(name: name.to_sym)])],
-          RubyIndexer::Entry::Visibility::PUBLIC,
-          owner,
-        ))
+        writer_signatures = [
+          RubyIndexer::Entry::Signature.new([RubyIndexer::Entry::RequiredParameter.new(name: name.to_sym)]),
+        ]
+        @listener.add_method("#{name}=", loc, writer_signatures)
       end
 
-      sig do
-        params(
-          owner: RubyIndexer::Entry::Namespace,
-          node: Prism::CallNode,
-        ).void
-      end
-      def handle_concern_extend(owner, node)
-        arguments = node.arguments&.arguments
+      sig { params(owner: RubyIndexer::Entry::Namespace, call_node: Prism::CallNode).void }
+      def handle_concern_extend(owner, call_node)
+        arguments = call_node.arguments&.arguments
         return unless arguments
 
         arguments.each do |node|
@@ -101,7 +84,7 @@ module RubyLsp
           module_name = node.full_name
           next unless module_name == "ActiveSupport::Concern"
 
-          @index.register_included_hook(owner.name) do |index, base|
+          @listener.register_included_hook do |index, base|
             class_methods_name = "#{owner.name}::ClassMethods"
 
             if index.indexed?(class_methods_name)
@@ -114,6 +97,13 @@ module RubyLsp
           # Do nothing
         end
       end
+
+      sig { params(owner: RubyIndexer::Entry::Namespace, call_node: Prism::CallNode).void }
+      def handle_class_methods(owner, call_node)
+        return unless call_node.block
+
+        @listener.add_module("ClassMethods", call_node.location, call_node.location)
+      end
     end
   end
 end

data/lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -27,7 +27,7 @@ module RubyLsp
 
             NullClient.new
           end
-        rescue Errno::ENOENT, StandardError => e # rubocop:disable Lint/ShadowedException
+        rescue StandardError => e
           unless outgoing_queue.closed?
             outgoing_queue << RubyLsp::Notification.window_log_message(
               <<~MESSAGE.chomp,
@@ -44,7 +44,6 @@ module RubyLsp
 
       class InitializationError < StandardError; end
       class MessageError < StandardError; end
-      class IncompleteMessageError < MessageError; end
       class EmptyMessageError < MessageError; end
 
       extend T::Sig
@@ -109,7 +108,7 @@ module RubyLsp
           end,
           Thread,
         )
-      rescue Errno::EPIPE, IncompleteMessageError
+      rescue StandardError
         raise InitializationError, @stderr.read
       end
 

data/lib/ruby_lsp/ruby_lsp_rails/server.rb

@@ -20,6 +20,43 @@ module RubyLsp
       def log_message(message)
         $stderr.puts(message)
       end
+
+      # Sends an error result to a request, if the request failed. DO NOT INVOKE THIS METHOD FOR NOTIFICATIONS! Use
+      # `log_message` instead, otherwise the client/server communication will go out of sync
+      def send_error_response(message)
+        send_message({ error: message })
+      end
+
+      # Sends a result back to the client
+      def send_result(result)
+        send_message({ result: result })
+      end
+
+      # Handle possible errors for a request. This should only be used for requests, which means messages that return a
+      # response back to the client. Errors are returned as an error object back to the client
+      def with_request_error_handling(request_name, &block)
+        block.call
+      rescue ActiveRecord::ConnectionNotEstablished
+        # Since this is a common problem, we show a specific error message to the user, instead of the full stack trace.
+        send_error_response("Request #{request_name} failed because database connection was not established.")
+      rescue ActiveRecord::NoDatabaseError
+        send_error_response("Request #{request_name} failed because the database does not exist.")
+      rescue => e
+        send_error_response("Request #{request_name} failed:\n#{e.full_message(highlight: false)}")
+      end
+
+      # Handle possible errors for a notification. This should only be used for notifications, which means messages that
+      # do not return a response back to the client. Errors are logged to the editor's output panel
+      def with_notification_error_handling(notification_name, &block)
+        block.call
+      rescue ActiveRecord::ConnectionNotEstablished
+        # Since this is a common problem, we show a specific error message to the user, instead of the full stack trace.
+        log_message("Request #{notification_name} failed because database connection was not established.")
+      rescue ActiveRecord::NoDatabaseError
+        log_message("Request #{notification_name} failed because the database does not exist.")
+      rescue => e
+        log_message("Request #{notification_name} failed:\n#{e.full_message(highlight: false)}")
+      end
     end
 
     class ServerAddon
@@ -87,11 +124,8 @@ module RubyLsp
       end
 
       def start
-        # Load routes if they haven't been loaded yet (see https://github.com/rails/rails/pull/51614).
-        routes_reloader = ::Rails.application.routes_reloader
-        routes_reloader.execute_unless_loaded if routes_reloader&.respond_to?(:execute_unless_loaded)
-
-        send_message({ result: { message: "ok", root: ::Rails.root.to_s } })
+        load_routes
+        send_result({ message: "ok", root: ::Rails.root.to_s })
 
         while @running
           headers = @stdin.gets("\r\n\r\n")
@@ -107,34 +141,46 @@ module RubyLsp
         when "shutdown"
           @running = false
         when "model"
-          send_message(resolve_database_info_from_model(params.fetch(:name)))
+          with_request_error_handling(request) do
+            send_result(resolve_database_info_from_model(params.fetch(:name)))
+          end
         when "association_target_location"
-          send_message(resolve_association_target(params))
+          with_request_error_handling(request) do
+            send_result(resolve_association_target(params))
+          end
         when "pending_migrations_message"
-          send_message({ result: { pending_migrations_message: pending_migrations_message } })
+          with_request_error_handling(request) do
+            send_result({ pending_migrations_message: pending_migrations_message })
+          end
         when "run_migrations"
-          send_message({ result: run_migrations })
+          with_request_error_handling(request) do
+            send_result(run_migrations)
+          end
         when "reload"
-          ::Rails.application.reloader.reload!
+          with_notification_error_handling(request) do
+            ::Rails.application.reloader.reload!
+          end
         when "route_location"
-          send_message(route_location(params.fetch(:name)))
+          with_request_error_handling(request) do
+            send_result(route_location(params.fetch(:name)))
+          end
         when "route_info"
-          send_message(resolve_route_info(params))
+          with_request_error_handling(request) do
+            send_result(resolve_route_info(params))
+          end
         when "server_addon/register"
-          require params[:server_addon_path]
-          ServerAddon.finalize_registrations!(@stdout)
+          with_notification_error_handling(request) do
+            require params[:server_addon_path]
+            ServerAddon.finalize_registrations!(@stdout)
+          end
         when "server_addon/delegate"
           server_addon_name = params[:server_addon_name]
           request_name = params[:request_name]
+
+          # Do not wrap this in error handlers. Server add-ons need to have the flexibility to choose if they want to
+          # include a response or not as part of error handling, so a blanket approach is not appropriate.
           ServerAddon.delegate(server_addon_name, request_name, params.except(:request_name, :server_addon_name))
         end
-        request_name = request
-        request_name = "#{params[:server_addon_name]}##{params[:request_name]}" if request == "server_addon/delegate"
-      # Since this is a common problem, we show a specific error message to the user, instead of the full stack trace.
-      rescue ActiveRecord::ConnectionNotEstablished
-        log_message("Request #{request_name} failed because database connection was not established.")
-      rescue => e
-        log_message("Request #{request_name} failed:\n" + e.full_message(highlight: false))
       end
 
       private
@@ -152,19 +198,15 @@ module RubyLsp
         end
 
         source_location = route&.respond_to?(:source_location) && route.source_location
+        return unless source_location
 
-        if source_location
-          file, _, line = source_location.rpartition(":")
-          body = {
-            source_location: [::Rails.root.join(file).to_s, line],
-            verb: route.verb,
-            path: route.path.spec.to_s,
-          }
+        file, _, line = source_location.rpartition(":")
 
-          { result: body }
-        else
-          { result: nil }
-        end
+        {
+          source_location: [::Rails.root.join(file).to_s, line],
+          verb: route.verb,
+          path: route.path.spec.to_s,
+        }
       end
 
       # Older versions of Rails don't support `route_source_locations`.
@@ -178,74 +220,48 @@ module RubyLsp
           end
 
           match_data = name.match(/^(.+)(_path|_url)$/)
-          return { result: nil } unless match_data
+          return unless match_data
 
           key = match_data[1]
 
           # A token could match the _path or _url pattern, but not be an actual route.
           route = ::Rails.application.routes.named_routes.get(key)
-          return { result: nil } unless route&.source_location
-
-          {
-            result: {
-              location: ::Rails.root.join(route.source_location).to_s,
-            },
-          }
-        rescue => e
-          { error: e.full_message(highlight: false) }
+          return unless route&.source_location
+
+          { location: ::Rails.root.join(route.source_location).to_s }
         end
       else
         def route_location(name)
-          { result: nil }
+          nil
         end
       end
 
       def resolve_database_info_from_model(model_name)
         const = ActiveSupport::Inflector.safe_constantize(model_name)
-        unless active_record_model?(const)
-          return {
-            result: nil,
-          }
-        end
+        return unless active_record_model?(const)
 
         info = {
-          result: {
-            columns: const.columns.map { |column| [column.name, column.type, column.default, column.null] },
-            primary_keys: Array(const.primary_key),
-          },
+          columns: const.columns.map { |column| [column.name, column.type, column.default, column.null] },
+          primary_keys: Array(const.primary_key),
         }
 
         if ActiveRecord::Tasks::DatabaseTasks.respond_to?(:schema_dump_path)
-          info[:result][:schema_file] =
-            ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(const.connection.pool.db_config)
-
+          info[:schema_file] = ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(const.connection.pool.db_config)
         end
+
         info
-      rescue => e
-        { error: e.full_message(highlight: false) }
       end
 
       def resolve_association_target(params)
         const = ActiveSupport::Inflector.safe_constantize(params[:model_name])
-        unless active_record_model?(const)
-          return {
-            result: nil,
-          }
-        end
+        return unless active_record_model?(const)
 
         association_klass = const.reflect_on_association(params[:association_name].intern).klass
-
         source_location = Object.const_source_location(association_klass.to_s)
 
-        {
-          result: {
-            location: source_location.first + ":" + source_location.second.to_s,
-          },
-        }
+        { location: source_location.first + ":" + source_location.second.to_s }
       rescue NameError
-        {
-          result: nil,
-        }
+        nil
       end
 
       def active_record_model?(const)
@@ -278,6 +294,14 @@ module RubyLsp
 
         { message: stdout, status: status.exitstatus }
       end
+
+      def load_routes
+        with_notification_error_handling("initial_load_routes") do
+          # Load routes if they haven't been loaded yet (see https://github.com/rails/rails/pull/51614).
+          routes_reloader = ::Rails.application.routes_reloader
+          routes_reloader.execute_unless_loaded if routes_reloader&.respond_to?(:execute_unless_loaded)
+        end
+      end
     end
   end
 end

data/lib/ruby_lsp_rails/version.rb

@@ -3,6 +3,6 @@
 
 module RubyLsp
   module Rails
-    VERSION = "0.3.25"
+    VERSION = "0.3.27"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-rails
 version: !ruby/object:Gem::Version
-  version: 0.3.25
+  version: 0.3.27
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-06 00:00:00.000000000 Z
+date: 2024-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-lsp
@@ -16,20 +16,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.21.2
+        version: 0.22.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.22.0
+        version: 0.23.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.21.2
+        version: 0.22.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.22.0
+        version: 0.23.0
 description: A Ruby LSP addon that adds extra editor functionality for Rails applications
 email:
 - ruby@shopify.com