ruby-lsp 0.14.5 → 0.14.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '046081e0caf521f948f3952bd7a356ef6f0beb80c5a9ff72930a6d0c9fd8d9f4'
-  data.tar.gz: e65b5224342c412a0b28198af0e56b17a421eaacc7748a17d2ed30890c0a2d86
+  metadata.gz: 7c364aee0d80e6187f66e8eb6d50d7cdd21ffb129e0a0b17c9dc7bd5d8a18cad
+  data.tar.gz: 65964ec1d89f10adf9bcbf113efed6d43a977b669abe51182e90dd9870032623
 SHA512:
-  metadata.gz: 682219fbef2c6e1483c0e6b0c36bf2ce8c3bd15aed88e53ee1a05623f5569c7e52227300b1a6fb4968a6ba2b0844a7e985a0b134af9e9498036199673d660117
-  data.tar.gz: a13eb33a1a41514819f4d0612a5d50eb170a0adb36158b799cebffae34781a5d41c1b07922f0bec8310cf6439ea8356305224bcf1de7423b96ff6e28c9e744c8
+  metadata.gz: 971af8a3c02903597143a8ec49915eead6bc0f65a0175e4a443e381d671dd4a88f776a26f62af1bd69ee7dc3f478b36bef122febbfaed7656907eb1a6a7a3354
+  data.tar.gz: 15148c1c3765390f9bb92dbafe7043ac15b22de6b5c415c424a063f4742026d92831d84bcde2013ab742c4a889dc16d666d4ec5d18863d0db8acf793ce87f0a6

data/VERSION

@@ -1 +1 @@
-0.14.5
+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/executor.rb

@@ -235,15 +235,17 @@ module RubyLsp
 
     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/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

metadata

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