Merge branch 'develop' into copilot/update-to-ruby-4

Author: kwerle

CHANGELOG.txt

@@ -1,8 +1,12 @@
 # Changelog
 
-#### Unreleased
+#### 0.9.3 Mon Jan 12 18:12:05 PST 2026
 
-* Update to Ruby 4.0 - resolves gem build issues mentioned in 0.9.0
+* Fix sibling module/class nesting in scope parser
+
+#### 0.9.2 Sun Jan 11 10:50:34 PST 2026
+
+* Fix namespace class definition lookup (Foo::Bar)
 
 #### 0.9.1 Tue Jan  6 19:32:44 PST 2026
 

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ruby_language_server (0.9.1)
+    ruby_language_server (0.9.3)
       activerecord (~> 8.1)
       amatch
       bundler
@@ -278,7 +278,7 @@ CHECKSUMS
   rubocop-rake (0.7.1) sha256=3797f2b6810c3e9df7376c26d5f44f3475eda59eb1adc38e6f62ecf027cbae4d
   rubocop-rspec (3.8.0) sha256=28440dccb3f223a9938ca1f946bd3438275b8c6c156dab909e2cb8bc424cab33
   ruby-progressbar (1.13.0) sha256=80fc9c47a9b640d6834e0dc7b3c94c9df37f08cb072b7761e4a71e22cff29b33
-  ruby_language_server (0.9.1)
+  ruby_language_server (0.9.3)
   securerandom (0.4.1) sha256=cc5193d414a4341b6e225f0cb4446aceca8e50d5e1888743fac16987638ea0b1
   shellany (0.0.1) sha256=0e127a9132698766d7e752e82cdac8250b6adbd09e6c0a7fbbb6f61964fedee7
   simplecov (0.22.0) sha256=fe2622c7834ff23b98066bb0a854284b2729a569ac659f82621fc22ef36213a5

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).

lib/ruby_language_server/scope_data/base.rb

@@ -25,7 +25,10 @@ class Base < ActiveRecord::Base
         TYPE_VARIABLE => '^'
       }.freeze
 
-      attr_accessor :type # Type of this scope (module, class, block)
+      # Return the class_type as a symbol for easier testing
+      def type
+        class_type&.to_sym
+      end
 
       # bar should be closer to Bar than Far.  Adding the UPPER version accomplishes this.
       scope :with_distance_from, lambda { |word|

lib/ruby_language_server/scope_parser.rb

@@ -41,7 +41,7 @@ def visit_class_node(node)
       end_line = node.location.end_line
       column = node.location.start_column
 
-      scope = push_scope(ScopeData::Scope::TYPE_CLASS, name, line, column, end_line)
+      scope = push_scope(ScopeData::Scope::TYPE_CLASS, name, line, column, end_line, false)
 
       # Handle superclass
       if node.superclass
@@ -60,7 +60,7 @@ def visit_module_node(node)
       end_line = node.location.end_line
       column = node.location.start_column
 
-      push_scope(ScopeData::Scope::TYPE_MODULE, name, line, column, end_line)
+      push_scope(ScopeData::Scope::TYPE_MODULE, name, line, column, end_line, false)
       super
       pop_scope
     end

lib/ruby_language_server/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyLanguageServer
-  VERSION = '0.9.1'
+  VERSION = '0.9.3'
 end

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

spec/lib/ruby_language_server/scope_parser_spec.rb

@@ -167,5 +167,91 @@ def some_method
         assert_equal('item', scope_parser.root_scope.self_and_descendants.last.variables.first.name)
       end
     end
+
+    describe 'sibling modules' do
+      before do
+        @parser = RubyLanguageServer::ScopeParser.new(<<-RUBY)
+          module Foo
+            module Bar
+            end
+            module Baz
+            end
+          end
+        RUBY
+      end
+
+      it 'places sibling modules at the same level' do
+        foo = @parser.root_scope.children.first
+        assert_equal('Foo', foo.name)
+
+        children = foo.children
+        assert_equal(2, children.size, "Foo should have 2 children, but has #{children.size}")
+
+        bar = children.detect { |c| c.name == 'Bar' }
+        baz = children.detect { |c| c.name == 'Baz' }
+
+        refute_nil(bar, "Bar should be a child of Foo")
+        refute_nil(baz, "Baz should be a child of Foo")
+        assert_equal(0, bar.children.size, "Bar should have no children")
+      end
+    end
+
+    describe 'sibling classes' do
+      before do
+        @parser = RubyLanguageServer::ScopeParser.new(<<-RUBY)
+          module Foo
+            class Bar
+            end
+            class Baz
+            end
+          end
+        RUBY
+      end
+
+      it 'places sibling classes at the same level' do
+        foo = @parser.root_scope.children.first
+        assert_equal('Foo', foo.name)
+
+        children = foo.children
+        assert_equal(2, children.size, "Foo should have 2 children, but has #{children.size}")
+
+        bar = children.detect { |c| c.name == 'Bar' }
+        baz = children.detect { |c| c.name == 'Baz' }
+
+        refute_nil(bar, "Bar should be a child of Foo")
+        refute_nil(baz, "Baz should be a child of Foo")
+        assert_equal(0, bar.children.size, "Bar should have no children")
+      end
+    end
+
+    describe 'mixed siblings' do
+      before do
+        @parser = RubyLanguageServer::ScopeParser.new(<<-RUBY)
+          module Foo
+            class Bar
+            end
+            module Baz
+            end
+          end
+        RUBY
+      end
+
+      it 'places sibling class and module at the same level' do
+        foo = @parser.root_scope.children.first
+        assert_equal('Foo', foo.name)
+
+        children = foo.children
+        assert_equal(2, children.size, "Foo should have 2 children, but has #{children.size}")
+
+        bar = children.detect { |c| c.name == 'Bar' }
+        baz = children.detect { |c| c.name == 'Baz' }
+
+        refute_nil(bar, "Bar should be a child of Foo")
+        refute_nil(baz, "Baz should be a child of Foo")
+        assert_equal(:class, bar.type, "Bar should be a class")
+        assert_equal(:module, baz.type, "Baz should be a module")
+        assert_equal(0, bar.children.size, "Bar should have no children")
+      end
+    end
   end
 end