Add scope to list of symbols

lib/ruby_lsp/ruby_lsp_rails/document_symbol.rb

@@ -21,12 +21,22 @@ class DocumentSymbol
       end
       def initialize(response_builder, dispatcher)
         @response_builder = response_builder
-
-        dispatcher.register(self, :on_call_node_enter)
+        @namespace_stack = T.let([], T::Array[String])
+
+        dispatcher.register(
+          self,
+          :on_call_node_enter,
+          :on_class_node_enter,
+          :on_class_node_leave,
+          :on_module_node_enter,
+          :on_module_node_leave,
+        )
       end
 
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
+        return if @namespace_stack.empty?
+
         content = extract_test_case_name(node)
 
         if content
@@ -45,15 +55,45 @@ def on_call_node_enter(node)
         when *Support::Callbacks::ALL, "validate"
           handle_all_arg_types(node, T.must(message))
         when "validates", "validates!", "validates_each", "belongs_to", "has_one", "has_many",
-          "has_and_belongs_to_many", "attr_readonly"
+          "has_and_belongs_to_many", "attr_readonly", "scope"
           handle_symbol_and_string_arg_types(node, T.must(message))
         when "validates_with"
           handle_class_arg_types(node, T.must(message))
         end
       end
 
+      sig { params(node: Prism::ClassNode).void }
+      def on_class_node_enter(node)
+        add_to_namespace_stack(node)
+      end
+
+      sig { params(node: Prism::ClassNode).void }
+      def on_class_node_leave(node)
+        remove_from_namespace_stack(node)
+      end
+
+      sig { params(node: Prism::ModuleNode).void }
+      def on_module_node_enter(node)
+        add_to_namespace_stack(node)
+      end
+
+      sig { params(node: Prism::ModuleNode).void }
+      def on_module_node_leave(node)
+        remove_from_namespace_stack(node)
+      end
+
       private
 
+      sig { params(node: T.any(Prism::ClassNode, Prism::ModuleNode)).void }
+      def add_to_namespace_stack(node)
+        @namespace_stack << node.constant_path.slice
+      end
+
+      sig { params(node: T.any(Prism::ClassNode, Prism::ModuleNode)).void }
+      def remove_from_namespace_stack(node)
+        @namespace_stack.delete(node.constant_path.slice)
+      end
+
       sig { params(node: Prism::CallNode, message: String).void }
       def handle_all_arg_types(node, message)
         block = node.block

test/dummy/app/models/user.rb

@@ -4,6 +4,9 @@ class User < ApplicationRecord
   before_create :foo, -> () {}
   validates :name, presence: true
   has_one :profile
+  scope :adult, -> { where(age: 18..) }
+
+  attr_readonly :last_name
 
   private
 

test/ruby_lsp_rails/document_symbol_test.rb

@@ -168,6 +168,52 @@ class FooModel < ApplicationRecord
         assert_equal("attr_readonly :foo", response[0].children[0].name)
       end
 
+      test "correctly handles scope in a class" do
+        response = generate_document_symbols_for_source(<<~RUBY)
+          class FooModel < ApplicationRecord
+            scope :bar, ->{ where(b: 2).order(:c) }
+            scope :foo, ->{ where(a: 1).order(:b) }
+          end
+        RUBY
+
+        assert_equal(1, response.size)
+        assert_equal("FooModel", response[0].name)
+        assert_equal(2, response[0].children.size)
+        assert_equal("scope :bar", response[0].children[0].name)
+        assert_equal("scope :foo", response[0].children[1].name)
+      end
+
+      test "correctly handles scope in a concern" do
+        response = generate_document_symbols_for_source(<<~RUBY)
+          module Scopable
+            extend ActiveSupport::Concern
+
+            included do
+              scope :bar, ->{ where(b: 2).order(:c) }
+              scope :foo, ->{ where(a: 1).order(:b) }
+            end
+          end
+        RUBY
+
+        assert_equal(1, response.size)
+        assert_equal("Scopable", response[0].name)
+        assert_equal(2, response[0].children.size)
+        assert_equal("scope :bar", response[0].children[0].name)
+        assert_equal("scope :foo", response[0].children[1].name)
+      end
+
+      test "ignores scope in a routes file" do
+        response = generate_document_symbols_for_source(<<~RUBY)
+          Rails.application.routes.draw do
+            scope '/admin' do
+              resources :users
+            end
+          end
+        RUBY
+
+        assert_equal(0, response.size)
+      end
+
       test "correctly handles model callbacks with multiple string arguments" do
         response = generate_document_symbols_for_source(<<~RUBY)
           class FooModel < ApplicationRecord