ruby-lsp 0.14.4 → 0.14.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fc74feb692f2c2e902e213dc61a4b3d58f14bcc4520fc7db60bdae022484e6f
-  data.tar.gz: 98f6d5b939bb945119169e2ca3ce060f275b961d421e752774ebea1c25b74c2d
+  metadata.gz: 7c364aee0d80e6187f66e8eb6d50d7cdd21ffb129e0a0b17c9dc7bd5d8a18cad
+  data.tar.gz: 65964ec1d89f10adf9bcbf113efed6d43a977b669abe51182e90dd9870032623
 SHA512:
-  metadata.gz: 8c33776eb483463d1052cdd5a82d1f66d5d507325b09848d0c5d78cea310c218b056bef834f6f6f03e17d87088b65c8cd77f7c214735390e8b5d244a059ea9e7
-  data.tar.gz: 7e57548a8dede5695774c27137b6ab23c8029f8ff8c0551bef8b1cf8f6dd920e9bdb423d4905c6a7f9ac360433da99cdec31efc885a120f4c1684acbd3da9582
+  metadata.gz: 971af8a3c02903597143a8ec49915eead6bc0f65a0175e4a443e381d671dd4a88f776a26f62af1bd69ee7dc3f478b36bef122febbfaed7656907eb1a6a7a3354
+  data.tar.gz: 15148c1c3765390f9bb92dbafe7043ac15b22de6b5c415c424a063f4742026d92831d84bcde2013ab742c4a889dc16d666d4ec5d18863d0db8acf793ce87f0a6

data/VERSION

@@ -1 +1 @@
-0.14.4
+0.14.6

data/lib/ruby_indexer/lib/ruby_indexer/collector.rb

@@ -152,6 +152,8 @@ module RubyIndexer
         handle_attribute(node, reader: false, writer: true)
       when :attr_accessor
         handle_attribute(node, reader: true, writer: true)
+      when :include
+        handle_include(node)
       end
     end
 
@@ -350,5 +352,24 @@ module RubyIndexer
         @index << Entry::Accessor.new("#{name}=", @file_path, loc, comments, @current_owner) if writer
       end
     end
+
+    sig { params(node: Prism::CallNode).void }
+    def handle_include(node)
+      return unless @current_owner
+
+      arguments = node.arguments&.arguments
+      return unless arguments
+
+      names = arguments.filter_map do |node|
+        if node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
+          node.full_name
+        end
+      rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError
+        # TO DO: add MissingNodesInConstantPathError when released in Prism
+        # If a constant path reference is dynamic or missing parts, we can't
+        # index it
+      end
+      @current_owner.included_modules.concat(names)
+    end
   end
 end

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

@@ -20,7 +20,7 @@ module RubyIndexer
     def initialize
       @excluded_gems = T.let(initial_excluded_gems, T::Array[String])
       @included_gems = T.let([], T::Array[String])
-      @excluded_patterns = T.let([File.join("**", "*_test.rb")], T::Array[String])
+      @excluded_patterns = T.let([File.join("**", "*_test.rb"), File.join("**", "tmp", "**", "*")], T::Array[String])
       path = Bundler.settings["path"]
       @excluded_patterns << File.join(File.expand_path(path, Dir.pwd), "**", "*.rb") if path
 

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

@@ -40,6 +40,22 @@ module RubyIndexer
 
       abstract!
 
+      sig { returns(T::Array[String]) }
+      attr_accessor :included_modules
+
+      sig do
+        params(
+          name: String,
+          file_path: String,
+          location: Prism::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])
+      end
+
       sig { returns(String) }
       def short_name
         T.must(@name.split("::").last)

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -191,8 +191,9 @@ module RubyIndexer
 
       require_path = indexable_path.require_path
       @require_paths_tree.insert(require_path, indexable_path) if require_path
-    rescue Errno::EISDIR
-      # If `path` is a directory, just ignore it and continue indexing
+    rescue Errno::EISDIR, Errno::ENOENT
+      # If `path` is a directory, just ignore it and continue indexing. If the file doesn't exist, then we also ignore
+      # it
     end
 
     # Follows aliases in a namespace. The algorithm keeps checking if the name is an alias and then recursively follows

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -281,5 +281,51 @@ module RubyIndexer
       final_thing = T.must(@index["FinalThing"].first)
       assert_equal("Something::Baz", final_thing.parent_class)
     end
+
+    def test_keeping_track_of_included_modules
+      index(<<~RUBY)
+        class Foo
+          # valid syntaxes that we can index
+          include A1
+          self.include A2
+          include A3, A4
+          self.include A5, A6
+
+          # valid syntaxes that we cannot index because of their dynamic nature
+          include some_variable_or_method_call
+          self.include some_variable_or_method_call
+
+          def something
+            include A7 # We should not index this because of this dynamic nature
+          end
+
+          # Valid inner class syntax definition with its own modules included
+          class Qux
+            include Corge
+            self.include Corge
+            include Baz
+
+            include some_variable_or_method_call
+          end
+        end
+
+        class ConstantPathReferences
+          include Foo::Bar
+          self.include Foo::Bar2
+
+          include dynamic::Bar
+          include Foo::
+        end
+      RUBY
+
+      foo = T.must(@index["Foo"][0])
+      assert_equal(["A1", "A2", "A3", "A4", "A5", "A6"], foo.included_modules)
+
+      qux = T.must(@index["Foo::Qux"][0])
+      assert_equal(["Corge", "Corge", "Baz"], qux.included_modules)
+
+      constant_path_references = T.must(@index["ConstantPathReferences"][0])
+      assert_equal(["Foo::Bar", "Foo::Bar2"], constant_path_references.included_modules)
+    end
   end
 end

data/lib/ruby_indexer/test/index_test.rb

@@ -308,5 +308,10 @@ module RubyIndexer
 
       refute_empty(@index.instance_variable_get(:@entries))
     end
+
+    def test_index_single_does_not_fail_for_non_existing_file
+      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"))
+      assert_empty(@index.instance_variable_get(:@entries))
+    end
   end
 end

data/lib/ruby_lsp/addon.rb

@@ -27,6 +27,8 @@ module RubyLsp
 
     @addons = T.let([], T::Array[Addon])
     @addon_classes = T.let([], T::Array[T.class_of(Addon)])
+    # Addon instances that have declared a handler to accept file watcher events
+    @file_watcher_addons = T.let([], T::Array[Addon])
 
     class << self
       extend T::Sig
@@ -34,6 +36,9 @@ module RubyLsp
       sig { returns(T::Array[Addon]) }
       attr_accessor :addons
 
+      sig { returns(T::Array[Addon]) }
+      attr_accessor :file_watcher_addons
+
       sig { returns(T::Array[T.class_of(Addon)]) }
       attr_reader :addon_classes
 
@@ -57,6 +62,7 @@ module RubyLsp
 
         # Instantiate all discovered addon classes
         self.addons = addon_classes.map(&:new)
+        self.file_watcher_addons = addons.select { |addon| addon.respond_to?(:workspace_did_change_watched_files) }
 
         # Activate each one of the discovered addons. If any problems occur in the addons, we don't want to
         # fail to boot the server

data/lib/ruby_lsp/executor.rb

@@ -229,20 +229,23 @@ module RubyLsp
         end
       end
 
+      Addon.file_watcher_addons.each { |addon| T.unsafe(addon).workspace_did_change_watched_files(changes) }
       VOID
     end
 
     sig { returns(T::Array[T::Hash[Symbol, T.untyped]]) }
     def workspace_dependencies
-      definition = Bundler.definition
-      dep_keys = definition.locked_deps.keys.to_set
-      definition.specs.map do |spec|
-        {
-          name: spec.name,
-          version: spec.version,
-          path: spec.full_gem_path,
-          dependency: dep_keys.include?(spec.name),
-        }
+      Bundler.with_original_env do
+        definition = Bundler.definition
+        dep_keys = definition.locked_deps.keys.to_set
+        definition.specs.map do |spec|
+          {
+            name: spec.name,
+            version: spec.version,
+            path: spec.full_gem_path,
+            dependency: dep_keys.include?(spec.name),
+          }
+        end
       end
     rescue Bundler::GemfileNotFound
       []

data/lib/ruby_lsp/listeners/code_lens.rb

@@ -22,6 +22,7 @@ module RubyLsp
       SUPPORTED_TEST_LIBRARIES = T.let(["minitest", "test-unit"], T::Array[String])
       DESCRIBE_KEYWORD = T.let(:describe, Symbol)
       IT_KEYWORD = T.let(:it, Symbol)
+      DYNAMIC_REFERENCE_MARKER = T.let("<dynamic_reference>", String)
 
       sig do
         params(
@@ -44,6 +45,8 @@ module RubyLsp
           self,
           :on_class_node_enter,
           :on_class_node_leave,
+          :on_module_node_enter,
+          :on_module_node_leave,
           :on_def_node_enter,
           :on_call_node_enter,
           :on_call_node_leave,
@@ -60,7 +63,7 @@ module RubyLsp
           add_test_code_lens(
             node,
             name: class_name,
-            command: generate_test_command(group_name: class_name),
+            command: generate_test_command(group_stack: @group_stack),
             kind: :group,
           )
         end
@@ -88,13 +91,27 @@ module RubyLsp
             add_test_code_lens(
               node,
               name: method_name,
-              command: generate_test_command(method_name: method_name, group_name: class_name),
+              command: generate_test_command(method_name: method_name, group_stack: @group_stack),
               kind: :example,
             )
           end
         end
       end
 
+      sig { params(node: Prism::ModuleNode).void }
+      def on_module_node_enter(node)
+        if (path = namespace_constant_name(node))
+          @group_stack.push(path)
+        else
+          @group_stack.push(DYNAMIC_REFERENCE_MARKER)
+        end
+      end
+
+      sig { params(node: Prism::ModuleNode).void }
+      def on_module_node_leave(node)
+        @group_stack.pop
+      end
+
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
         name = node.name
@@ -181,18 +198,45 @@ module RubyLsp
         )
       end
 
-      sig { params(group_name: String, method_name: T.nilable(String)).returns(String) }
-      def generate_test_command(group_name:, method_name: nil)
+      sig do
+        params(
+          group_stack: T::Array[String],
+          spec_name: T.nilable(String),
+          method_name: T.nilable(String),
+        ).returns(String)
+      end
+      def generate_test_command(group_stack: [], spec_name: nil, method_name: nil)
         command = BASE_COMMAND + T.must(@path)
 
         case DependencyDetector.instance.detected_test_library
         when "minitest"
-          command += if method_name
-            " --name " + "/#{Shellwords.escape(group_name + "#" + method_name)}/"
+          last_dynamic_reference_index = group_stack.rindex(DYNAMIC_REFERENCE_MARKER)
+          command += if last_dynamic_reference_index
+            # In cases where the test path looks like `foo::Bar`
+            # the best we can do is match everything to the right of it.
+            # Tests are classes, dynamic references are only a thing for modules,
+            # so there must be something to the left of the available path.
+            group_stack = T.must(group_stack[last_dynamic_reference_index + 1..])
+            if method_name
+              " --name " + "/::#{Shellwords.escape(group_stack.join("::") + "#" + method_name)}$/"
+            else
+              # When clicking on a CodeLens for `Test`, `(#|::)` will match all tests
+              # that are registered on the class itself (matches after `#`) and all tests
+              # that are nested inside of that class in other modules/classes (matches after `::`)
+              " --name " + "\"/::#{Shellwords.escape(group_stack.join("::"))}(#|::)/\""
+            end
+          elsif method_name
+            # We know the entire path, do an exact match
+            " --name " + Shellwords.escape(group_stack.join("::") + "#" + method_name)
+          elsif spec_name
+            " --name " + "/#{Shellwords.escape(spec_name)}/"
           else
-            " --name " + "/#{Shellwords.escape(group_name)}/"
+            # Execute all tests of the selected class and tests in
+            # modules/classes nested inside of that class
+            " --name " + "\"/^#{Shellwords.escape(group_stack.join("::"))}(#|::)/\""
           end
         when "test-unit"
+          group_name = T.must(group_stack.last)
           command += " --testcase " + "/#{Shellwords.escape(group_name)}/"
 
           if method_name
@@ -214,8 +258,8 @@ module RubyLsp
         name = case first_argument
         when Prism::StringNode
           first_argument.content
-        when Prism::ConstantReadNode
-          first_argument.full_name
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          constant_name(first_argument)
         end
 
         return unless name
@@ -223,7 +267,7 @@ module RubyLsp
         add_test_code_lens(
           node,
           name: name,
-          command: generate_test_command(group_name: name),
+          command: generate_test_command(spec_name: name),
           kind: kind,
         )
       end

data/lib/ruby_lsp/listeners/completion.rb

@@ -100,8 +100,6 @@ module RubyLsp
 
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
-        return if @typechecker_enabled
-
         name = node.message
         return unless name
 
@@ -111,7 +109,7 @@ module RubyLsp
         when "require_relative"
           complete_require_relative(node)
         else
-          complete_self_receiver_method(node, name) if self_receiver?(node)
+          complete_self_receiver_method(node, name) if !@typechecker_enabled && self_receiver?(node)
         end
       end
 
@@ -142,14 +140,17 @@ module RubyLsp
 
         origin_dir = Pathname.new(@uri.to_standardized_path).dirname
 
-        path_query = path_node_to_complete.content
+        content = path_node_to_complete.content
         # if the path is not a directory, glob all possible next characters
         # for example ../somethi| (where | is the cursor position)
         # should find files for ../somethi*/
-        path_query += "*/" unless path_query.end_with?("/")
-        path_query += "**/*.rb"
+        path_query = if content.end_with?("/") || content.empty?
+          "#{content}**/*.rb"
+        else
+          "{#{content}*/**/*.rb,**/#{content}*.rb}"
+        end
 
-        Dir.glob(path_query, base: origin_dir).sort!.each do |path|
+        Dir.glob(path_query, File::FNM_PATHNAME | File::FNM_EXTGLOB, base: origin_dir).sort!.each do |path|
           @response_builder << build_completion(
             path.delete_suffix(".rb"),
             path_node_to_complete,

data/lib/ruby_lsp/requests/completion.rb

@@ -34,7 +34,7 @@ module RubyLsp
         def provider
           Interface::CompletionOptions.new(
             resolve_provider: false,
-            trigger_characters: ["/"],
+            trigger_characters: ["/", "\"", "'"],
             completion_item: {
               labelDetailsSupport: true,
             },

data/lib/ruby_lsp/requests/definition.rb

@@ -49,7 +49,13 @@ module RubyLsp
           node_types: [Prism::CallNode, Prism::ConstantReadNode, Prism::ConstantPathNode],
         )
 
-        target = parent if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)
+        if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)
+          target = determine_target(
+            target,
+            parent,
+            position,
+          )
+        end
 
         Listeners::Definition.new(@response_builder, document.uri, nesting, index, dispatcher, typechecker_enabled)
 

data/lib/ruby_lsp/requests/hover.rb

@@ -50,7 +50,11 @@ module RubyLsp
         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 = parent
+          @target = determine_target(
+            T.must(@target),
+            T.must(parent),
+            position,
+          )
         end
 
         # Don't need to instantiate any listeners if there's no target

data/lib/ruby_lsp/requests/request.rb

@@ -12,6 +12,57 @@ module RubyLsp
 
       sig { abstract.returns(T.anything) }
       def perform; end
+
+      private
+
+      # Checks if a location covers a position
+      sig { params(location: Prism::Location, position: T.untyped).returns(T::Boolean) }
+      def cover?(location, position)
+        start_covered =
+          location.start_line - 1 < position[:line] ||
+          (
+            location.start_line - 1 == position[:line] &&
+              location.start_column <= position[:character]
+          )
+        end_covered =
+          location.end_line - 1 > position[:line] ||
+          (
+            location.end_line - 1 == position[:line] &&
+              location.end_column >= position[:character]
+          )
+        start_covered && end_covered
+      end
+
+      # Based on a constant node target, a constant path node parent and a position, this method will find the exact
+      # portion of the constant path that matches the requested position, for higher precision in hover and
+      # definition. For example:
+      #
+      # ```ruby
+      # Foo::Bar::Baz
+      #  #        ^ Going to definition here should go to Foo::Bar::Baz
+      #  #   ^ Going to definition here should go to Foo::Bar
+      # #^ Going to definition here should go to Foo
+      # ```
+      sig do
+        params(
+          target: Prism::Node,
+          parent: Prism::Node,
+          position: T::Hash[Symbol, Integer],
+        ).returns(Prism::Node)
+      end
+      def determine_target(target, parent, position)
+        return target unless parent.is_a?(Prism::ConstantPathNode)
+
+        target = T.let(parent, Prism::Node)
+        parent = T.let(T.cast(target, Prism::ConstantPathNode).parent, T.nilable(Prism::Node))
+
+        while parent && cover?(parent.location, position)
+          target = parent
+          parent = target.is_a?(Prism::ConstantPathNode) ? target.parent : nil
+        end
+
+        target
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/support/common.rb

@@ -147,6 +147,15 @@ module RubyLsp
         rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError
           nil
         end
+
+        sig { params(node: T.any(Prism::ModuleNode, Prism::ClassNode)).returns(T.nilable(String)) }
+        def namespace_constant_name(node)
+          path = node.constant_path
+          case path
+          when Prism::ConstantPathNode, Prism::ConstantReadNode, Prism::ConstantPathTargetNode
+            constant_name(path)
+          end
+        end
       end
     end
   end

data/lib/ruby_lsp/requests/support/rubocop_diagnostic.rb

@@ -40,6 +40,9 @@ module RubyLsp
 
         sig { returns(Interface::Diagnostic) }
         def to_lsp_diagnostic
+          # highlighted_area contains the begin and end position of the first line
+          # This ensures that multiline offenses don't clutter the editor
+          highlighted = @offense.highlighted_area
           Interface::Diagnostic.new(
             message: message,
             source: "RuboCop",
@@ -49,11 +52,11 @@ module RubyLsp
             range: Interface::Range.new(
               start: Interface::Position.new(
                 line: @offense.line - 1,
-                character: @offense.column,
+                character: highlighted.begin_pos,
               ),
               end: Interface::Position.new(
-                line: @offense.last_line - 1,
-                character: @offense.last_column,
+                line: @offense.line - 1,
+                character: highlighted.end_pos,
               ),
             ),
             data: {

data/lib/ruby_lsp/requests/support/rubocop_runner.rb

@@ -13,6 +13,10 @@ rescue LoadError
   raise StandardError, "Incompatible RuboCop version. Ruby LSP requires >= 1.4.0"
 end
 
+if RuboCop.const_defined?(:LSP) # This condition will be removed when requiring RuboCop >= 1.61.
+  RuboCop::LSP.enable
+end
+
 module RubyLsp
   module Requests
     module Support

metadata

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