ruby-lsp 0.16.5 → 0.16.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bcd4426f17d6d429be733a9adcdf799e23c29689ad5fb69f9b9f7b3cd334bf9b
-  data.tar.gz: 071d5c37e1acf83c07a5b48e85a3bc4a18fb63a20b54ff191158799cf4320803
+  metadata.gz: d725a0a2fbd58820e2a87efae85564498221feb8410292055b0caafd889284e6
+  data.tar.gz: 5376ca8a9d08ca0883fca3aa19a1a178102eb60f49ab3fe5f07bb1a58ba63ddf
 SHA512:
-  metadata.gz: 9edc44ec74f5f5d9b5f15fb7d22501126eb8f6bec3d9a69b3061946b369ecb0e453e45e9a0dc9df1482117dc738f7bd66005e2dcd0cd46e3aaad6f6658283766
-  data.tar.gz: c4f9ddb4da9373544b2456632a0fb76bdbca5e5ddf5e874b0e6ab4f6aae13ad8b17ef9482873b37ae33bc7ec797faebde76bf5a6e9d86e6a4ddf798b4eb9f0df
+  metadata.gz: 81fbb2e5018ad55d8888c98e277e7ac6ed8b45314627b1a3e3dabde2cb8aac0284dc70487a694226e5a08817feb82b64daadfcb955e9642b288e575189a56015
+  data.tar.gz: f32ef084e4412752cc32df55da0dd7b985d3826db110bf91ba3473773043c50345ceb597432483a0a75f1790cabfca796fa9581d3ba86edff96a8642fb2312f2

data/VERSION

@@ -1 +1 @@
-0.16.5
+0.16.6

data/exe/ruby-lsp

@@ -75,14 +75,18 @@ require "ruby_lsp/internal"
 
 if options[:debug]
   if ["x64-mingw-ucrt", "x64-mingw32"].include?(RUBY_PLATFORM)
-    puts "Debugging is not supported on Windows"
+    $stderr.puts "Debugging is not supported on Windows"
     exit 1
   end
 
   begin
+    original_stdout = $stdout
+    $stdout = $stderr
     require "debug/open_nonstop"
   rescue LoadError
-    warn("You need to install the debug gem to use the --debug flag")
+    $stderr.puts("You need to install the debug gem to use the --debug flag")
+  ensure
+    $stdout = original_stdout
   end
 end
 

data/lib/ruby_indexer/lib/ruby_indexer/configuration.rb

@@ -56,6 +56,7 @@ module RubyIndexer
         load_path_entry = T.let(nil, T.nilable(String))
 
         Dir.glob(pattern, File::FNM_PATHNAME | File::FNM_EXTGLOB).map! do |path|
+          path = File.expand_path(path)
           # All entries for the same pattern match the same $LOAD_PATH entry. Since searching the $LOAD_PATH for every
           # entry is expensive, we memoize it until we find a path that doesn't belong to that $LOAD_PATH. This happens
           # on repositories that define multiple gems, like Rails. All frameworks are defined inside the Dir.pwd, but

data/lib/ruby_indexer/lib/ruby_indexer/entry.rb

@@ -61,28 +61,13 @@ module RubyIndexer
       abstract!
 
       sig { returns(T::Array[String]) }
-      attr_accessor :included_modules
-
-      sig { returns(T::Array[String]) }
-      attr_accessor :prepended_modules
-
-      sig do
-        params(
-          name: String,
-          file_path: String,
-          location: T.any(Prism::Location, RubyIndexer::Location),
-          comments: T::Array[String],
-        ).void
-      end
-      def initialize(name, file_path, location, comments)
-        super(name, file_path, location, comments)
-        @included_modules = T.let([], T::Array[String])
-        @prepended_modules = T.let([], T::Array[String])
+      def included_modules
+        @included_modules ||= T.let([], T.nilable(T::Array[String]))
       end
 
-      sig { returns(String) }
-      def short_name
-        T.must(@name.split("::").last)
+      sig { returns(T::Array[String]) }
+      def prepended_modules
+        @prepended_modules ||= T.let([], T.nilable(T::Array[String]))
       end
     end
 

data/lib/ruby_indexer/test/configuration_test.rb

@@ -20,6 +20,14 @@ module RubyIndexer
       assert(indexables.none? { |indexable| indexable.full_path == __FILE__ })
     end
 
+    def test_indexables_have_expanded_full_paths
+      @config.apply_config({ "included_patterns" => ["**/*.rb"] })
+      indexables = @config.indexables
+
+      # All paths should be expanded
+      assert(indexables.none? { |indexable| indexable.full_path.start_with?("lib/") })
+    end
+
     def test_indexables_only_includes_gem_require_paths
       indexables = @config.indexables
 

data/lib/ruby_lsp/requests/definition.rb

@@ -43,6 +43,7 @@ module RubyLsp
           ResponseBuilders::CollectionResponseBuilder[Interface::Location].new,
           ResponseBuilders::CollectionResponseBuilder[Interface::Location],
         )
+        @dispatcher = dispatcher
 
         target, parent, nesting = document.locate_node(
           position,
@@ -50,33 +51,41 @@ module RubyLsp
         )
 
         if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)
+          # If the target is part of a constant path node, we need to find the exact portion of the constant that the
+          # user is requesting to go to definition for
           target = determine_target(
             target,
             parent,
             position,
           )
+        elsif target.is_a?(Prism::CallNode) && target.name != :require && target.name != :require_relative &&
+            !covers_position?(target.message_loc, position)
+          # If the target is a method call, we need to ensure that the requested position is exactly on top of the
+          # method identifier. Otherwise, we risk showing definitions for unrelated things
+          target = nil
         end
 
-        Listeners::Definition.new(
-          @response_builder,
-          global_state,
-          document.uri,
-          nesting,
-          dispatcher,
-          typechecker_enabled,
-        )
+        if target
+          Listeners::Definition.new(
+            @response_builder,
+            global_state,
+            document.uri,
+            nesting,
+            dispatcher,
+            typechecker_enabled,
+          )
 
-        Addon.addons.each do |addon|
-          addon.create_definition_listener(@response_builder, document.uri, nesting, dispatcher)
+          Addon.addons.each do |addon|
+            addon.create_definition_listener(@response_builder, document.uri, nesting, dispatcher)
+          end
         end
 
         @target = T.let(target, T.nilable(Prism::Node))
-        @dispatcher = dispatcher
       end
 
       sig { override.returns(T::Array[Interface::Location]) }
       def perform
-        @dispatcher.dispatch_once(@target)
+        @dispatcher.dispatch_once(@target) if @target
         @response_builder.response
       end
     end

data/lib/ruby_lsp/requests/hover.rb

@@ -41,25 +41,29 @@ module RubyLsp
       end
       def initialize(document, global_state, position, dispatcher, typechecker_enabled)
         super()
-        @target = T.let(nil, T.nilable(Prism::Node))
-        @target, parent, nesting = document.locate_node(
+        target, parent, nesting = document.locate_node(
           position,
           node_types: Listeners::Hover::ALLOWED_TARGETS,
         )
 
         if (Listeners::Hover::ALLOWED_TARGETS.include?(parent.class) &&
-            !Listeners::Hover::ALLOWED_TARGETS.include?(@target.class)) ||
-            (parent.is_a?(Prism::ConstantPathNode) && @target.is_a?(Prism::ConstantReadNode))
-          @target = determine_target(
-            T.must(@target),
+            !Listeners::Hover::ALLOWED_TARGETS.include?(target.class)) ||
+            (parent.is_a?(Prism::ConstantPathNode) && target.is_a?(Prism::ConstantReadNode))
+          target = determine_target(
+            T.must(target),
             T.must(parent),
             position,
           )
+        elsif target.is_a?(Prism::CallNode) && target.name != :require && target.name != :require_relative &&
+            !covers_position?(target.message_loc, position)
+
+          target = nil
         end
 
         # Don't need to instantiate any listeners if there's no target
-        return unless @target
+        return unless target
 
+        @target = T.let(target, T.nilable(Prism::Node))
         uri = document.uri
         @response_builder = T.let(ResponseBuilders::Hover.new, ResponseBuilders::Hover)
         Listeners::Hover.new(@response_builder, global_state, uri, nesting, dispatcher, typechecker_enabled)

data/lib/ruby_lsp/requests/request.rb

@@ -65,6 +65,20 @@ module RubyLsp
 
         target
       end
+
+      # Checks if a given location covers the position requested
+      sig { params(location: T.nilable(Prism::Location), position: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+      def covers_position?(location, position)
+        return false unless location
+
+        start_line = location.start_line - 1
+        end_line = location.end_line - 1
+        line = position[:line]
+        character = position[:character]
+
+        (start_line < line || (start_line == line && location.start_column <= character)) &&
+          (end_line > line || (end_line == line && location.end_column >= character))
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.16.5
+  version: 0.16.6
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-04-24 00:00:00.000000000 Z
+date: 2024-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol