Fix namespace class definition lookup (Foo::Bar) (#128)

* Initial plan

* Add namespace reference detection for class definition lookup

- Modified possible_definitions to detect :: namespace separator
- Added namespace_reference? helper to check if context uses :: notation
- Updated project_definitions_for to search by path for namespaced names
- Added test cases for namespaced class lookup (Foo::Bar pattern)

Co-authored-by: kwerle <23320+kwerle@users.noreply.github.com>

* Improve namespace reference detection logic

- Use exclusive range for line_before_cursor (characters before cursor)
- Check pattern position relative to cursor more precisely
- Handle clicking anywhere in the namespaced class name
- Prevent false positives when pattern appears elsewhere on line

Co-authored-by: kwerle <23320+kwerle@users.noreply.github.com>

* Fix namespace reference detection to handle edge cases

- Search in reasonable range around cursor position
- Correctly handle multiple occurrences of pattern on same line
- Improve code formatting and documentation
- Validate pattern contains cursor position

Co-authored-by: kwerle <23320+kwerle@users.noreply.github.com>

* cops

* Simplify namespace_reference? to check uppercase letters

Instead of parsing line text to find :: separators, simply check if all
context parts start with uppercase letters. Class/module lookups always
start with uppercase, method calls never do.

This is much simpler and more elegant as suggested in code review.

Co-authored-by: kwerle <23320+kwerle@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: kwerle <23320+kwerle@users.noreply.github.com>
Co-authored-by: Kurt Werle <kurt@CircleW.org>

Author: Copilot

Gemfile.lock

@@ -210,6 +210,7 @@ DEPENDENCIES
   rubocop-rspec
   ruby_language_server!
   simplecov
+  simplecov_json_formatter
 
 CHECKSUMS
   activemodel (8.1.1) sha256=8b7e2496b9e333ced06248c16a43217b950192c98e0fe3aa117eee21501c6fbd

lib/ruby_language_server/project_manager.rb

@@ -167,8 +167,15 @@ def possible_definitions(uri, position)
 
       context = context_at_location(uri, position)
 
-      # If context has more than one element it's a method call on a receiver
+      # If context has more than one element it could be a method call or namespace reference
       if context.length > 1
+        # Check if this is a namespace reference (Foo::Bar) vs method call (Foo.bar)
+        if namespace_reference?(uri, position, context)
+          # Join the context with :: to form the full class/module name
+          full_name = context.join('::')
+          return project_definitions_for(full_name)
+        end
+
         receiver = context.first
         # Determine if it's a class method call (Foo.method) or instance method call (foo.method)
         class_method_filter = name != 'initialize'
@@ -206,7 +213,13 @@ def scope_definitions_for(name, scope, uri)
     end
 
     def project_definitions_for(name, class_method_filter = nil)
-      scopes = RubyLanguageServer::ScopeData::Scope.where(name:)
+      # Check if name contains namespace separator (e.g., "Foo::Bar")
+      # If so, search by path instead of name
+      scopes = if name.include?('::')
+                 RubyLanguageServer::ScopeData::Scope.where(path: name)
+               else
+                 RubyLanguageServer::ScopeData::Scope.where(name:)
+               end
 
       # Filter by class_method attribute if specified
       scopes = scopes.where(class_method: class_method_filter) unless class_method_filter.nil?
@@ -219,6 +232,16 @@ def project_definitions_for(name, class_method_filter = nil)
 
     private
 
+    # Check if the context represents a namespace reference (Foo::Bar) rather than a method call (Foo.bar)
+    # Class/module lookups always start with uppercase letters, method calls never do
+    def namespace_reference?(_uri, _position, context)
+      return false if context.length < 2
+
+      # If all parts start with uppercase, it's a namespace reference (Foo::Bar)
+      # If first part is lowercase, it's a method call (foo.bar)
+      context.all? { |part| /\A[A-Z]/.match?(part) }
+    end
+
     # Guess if a receiver name is likely a class name based on idiomatic Ruby conventions.
     # This is a heuristic and not 100% accurate (e.g., FOO could be a constant holding an instance).
     # Returns true for names like "Foo" or "FooBar" (starts with uppercase, has lowercase letters).

spec/lib/ruby_language_server/project_manager_spec.rb

@@ -241,6 +241,54 @@ def other_method
       assert_equal 0, other_class_result[:range][:start][:line]
     end
 
+    describe 'namespaced class lookup' do
+      let(:file_with_namespaced_class) do
+        <<~CODE_FILE
+          module Foo
+            class Bar
+              def import
+                puts "import method"
+              end
+            end
+          end
+
+          # In a spec file:
+          describe Foo::Bar, "#import" do
+            # When clicking on Bar in Foo::Bar
+          end
+        CODE_FILE
+      end
+
+      before(:each) do
+        project_manager.update_document_content('namespace_uri', file_with_namespaced_class)
+        project_manager.tags_for_uri('namespace_uri') # Force load of tags
+      end
+
+      it 'finds namespaced class definition when clicking on the class name' do
+        # Position on "Bar" in "Foo::Bar" (line 9, around character 16-18)
+        # The line is: "describe Foo::Bar, \"#import\" do"
+        # Character 16 is on 'B' of Bar
+        position = OpenStruct.new(line: 9, character: 16)
+        results = project_manager.possible_definitions('namespace_uri', position)
+
+        # Should find the Bar class definition on line 1 (0-indexed)
+        assert_equal 1, results.length
+        assert_equal 'namespace_uri', results.first[:uri]
+        assert_equal 1, results.first[:range][:start][:line]
+      end
+
+      it 'finds namespaced class definition when clicking on the module name' do
+        # Position on "Foo" in "Foo::Bar" (line 9, around character 11)
+        position = OpenStruct.new(line: 9, character: 11)
+        results = project_manager.possible_definitions('namespace_uri', position)
+
+        # Should find the Foo module definition on line 0
+        assert_equal 1, results.length
+        assert_equal 'namespace_uri', results.first[:uri]
+        assert_equal 0, results.first[:range][:start][:line]
+      end
+    end
+
     describe 'parameter vs method name resolution' do
       let(:file_with_param_shadowing) do
         <<~CODE_FILE