ruby-lsp 0.11.0 → 0.11.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7491255b178e72942f0b98ae97c83020c0a5726162d556fba7a2592a2c8b5132
-  data.tar.gz: d9c61449b9d3eb43a53a8c00b704ceab8691bb404dedd3324d3ad055d859974d
+  metadata.gz: 836f512695d45c2b360a2a6533185bd489a7d1c45eda21c0e67a2602cff23712
+  data.tar.gz: bdf8fdeefffbb7620ba60cdd91e7e73d7ee9121c5bd810f3456fd46835f5bf5e
 SHA512:
-  metadata.gz: 88b6b4d22784336e299caa42e09a701bd9c70ac3176c224c00700ad80605dd8ad17d4274eedc95dad4f6c6432fb192c2094ca8b5ca66ce3ab95bf7ba3eb68831
-  data.tar.gz: caabe89725f634f87ace44cc85c4d001a8f74dbbb0f2d59f1e2e7a763a3b7896e72a6432abbba7e85e07646ebfc7c812c1126ef8afda520a9f827b58a8cc881d
+  metadata.gz: 4be56dc36e58719d4ccdaea4b720507f21178b0fcfbbc9f634374dd808c33f46872c1cb25dc427f25f007d9b9b1333404c5724e8bbf8bab71ff1a3700c9a766d
+  data.tar.gz: 6afc266ad6ae954492d9603e456ba1f65ed00ec6fdc31984b1c42c6597867224d2a230ad165ee2c18afc39d7e5e6eb0f88fc2f4f53e09a724ef67cd4e87e53b2

data/VERSION

@@ -1 +1 @@
-0.11.0
+0.11.2

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

@@ -179,7 +179,12 @@ module RubyIndexer
 
       # When working on a gem, we need to make sure that its gemspec dependencies can't be excluded. This is necessary
       # because Bundler doesn't assign groups to gemspec dependencies
-      this_gem = Bundler.definition.dependencies.find { |d| d.to_spec.full_gem_path == Dir.pwd }
+      this_gem = Bundler.definition.dependencies.find do |d|
+        d.to_spec.full_gem_path == Dir.pwd
+      rescue Gem::MissingSpecError
+        false
+      end
+
       others.concat(this_gem.to_spec.dependencies) if this_gem
 
       excluded.each do |dependency|

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

@@ -130,7 +130,7 @@ module RubyIndexer
       if name.start_with?("::")
         name = name.delete_prefix("::")
         results = @entries[name] || @entries[follow_aliased_namespace(name)]
-        return results.map { |e| e.is_a?(Entry::UnresolvedAlias) ? resolve_alias(e) : e } if results
+        return results&.map { |e| e.is_a?(Entry::UnresolvedAlias) ? resolve_alias(e) : e }
       end
 
       nesting.length.downto(0).each do |i|
@@ -161,8 +161,9 @@ module RubyIndexer
     sig { params(indexable_path: IndexablePath, source: T.nilable(String)).void }
     def index_single(indexable_path, source = nil)
       content = source || File.read(indexable_path.full_path)
-      visitor = IndexVisitor.new(self, YARP.parse(content), indexable_path.full_path)
-      visitor.run
+      result = YARP.parse(content)
+      visitor = IndexVisitor.new(self, result, indexable_path.full_path)
+      result.value.accept(visitor)
 
       require_path = indexable_path.require_path
       @require_paths_tree.insert(require_path, indexable_path) if require_path
@@ -182,6 +183,8 @@ module RubyIndexer
     # aliases, so we have to invoke `follow_aliased_namespace` again to check until we only return a real name
     sig { params(name: String).returns(String) }
     def follow_aliased_namespace(name)
+      return name if @entries[name]
+
       parts = name.split("::")
       real_parts = []
 

data/lib/ruby_indexer/lib/ruby_indexer/visitor.rb

@@ -8,7 +8,6 @@ module RubyIndexer
     sig { params(index: Index, parse_result: YARP::ParseResult, file_path: String).void }
     def initialize(index, parse_result, file_path)
       @index = index
-      @parse_result = parse_result
       @file_path = file_path
       @stack = T.let([], T::Array[String])
       @comments_by_line = T.let(
@@ -21,41 +20,84 @@ module RubyIndexer
       super()
     end
 
-    sig { void }
-    def run
-      visit(@parse_result.value)
+    sig { override.params(node: YARP::ClassNode).void }
+    def visit_class_node(node)
+      add_index_entry(node, Index::Entry::Class)
     end
 
-    sig { params(node: T.nilable(YARP::Node)).void }
-    def visit(node)
-      case node
-      when YARP::ProgramNode, YARP::StatementsNode
-        visit_child_nodes(node)
-      when YARP::ClassNode
-        add_index_entry(node, Index::Entry::Class)
-      when YARP::ModuleNode
-        add_index_entry(node, Index::Entry::Module)
-      when YARP::ConstantWriteNode, YARP::ConstantOrWriteNode
-        name = fully_qualify_name(node.name.to_s)
-        add_constant(node, name)
-      when YARP::ConstantPathWriteNode, YARP::ConstantPathOrWriteNode, YARP::ConstantPathOperatorWriteNode,
-        YARP::ConstantPathAndWriteNode
+    sig { override.params(node: YARP::ModuleNode).void }
+    def visit_module_node(node)
+      add_index_entry(node, Index::Entry::Module)
+    end
 
-        # ignore variable constants like `var::FOO` or `self.class::FOO`
-        return unless node.target.parent.nil? || node.target.parent.is_a?(YARP::ConstantReadNode)
+    sig { override.params(node: YARP::ConstantPathWriteNode).void }
+    def visit_constant_path_write_node(node)
+      # ignore variable constants like `var::FOO` or `self.class::FOO`
+      target = node.target
+      return unless target.parent.nil? || target.parent.is_a?(YARP::ConstantReadNode)
 
-        name = fully_qualify_name(node.target.location.slice)
-        add_constant(node, name)
-      when YARP::CallNode
-        message = node.message
-        handle_private_constant(node) if message == "private_constant"
-      end
+      name = fully_qualify_name(target.location.slice)
+      add_constant(node, name)
+    end
+
+    sig { override.params(node: YARP::ConstantPathOrWriteNode).void }
+    def visit_constant_path_or_write_node(node)
+      # ignore variable constants like `var::FOO` or `self.class::FOO`
+      target = node.target
+      return unless target.parent.nil? || target.parent.is_a?(YARP::ConstantReadNode)
+
+      name = fully_qualify_name(target.location.slice)
+      add_constant(node, name)
+    end
+
+    sig { override.params(node: YARP::ConstantPathOperatorWriteNode).void }
+    def visit_constant_path_operator_write_node(node)
+      # ignore variable constants like `var::FOO` or `self.class::FOO`
+      target = node.target
+      return unless target.parent.nil? || target.parent.is_a?(YARP::ConstantReadNode)
+
+      name = fully_qualify_name(target.location.slice)
+      add_constant(node, name)
+    end
+
+    sig { override.params(node: YARP::ConstantPathAndWriteNode).void }
+    def visit_constant_path_and_write_node(node)
+      # ignore variable constants like `var::FOO` or `self.class::FOO`
+      target = node.target
+      return unless target.parent.nil? || target.parent.is_a?(YARP::ConstantReadNode)
+
+      name = fully_qualify_name(target.location.slice)
+      add_constant(node, name)
+    end
+
+    sig { override.params(node: YARP::ConstantWriteNode).void }
+    def visit_constant_write_node(node)
+      name = fully_qualify_name(node.name.to_s)
+      add_constant(node, name)
+    end
+
+    sig { override.params(node: YARP::ConstantOrWriteNode).void }
+    def visit_constant_or_write_node(node)
+      name = fully_qualify_name(node.name.to_s)
+      add_constant(node, name)
+    end
+
+    sig { override.params(node: YARP::ConstantAndWriteNode).void }
+    def visit_constant_and_write_node(node)
+      name = fully_qualify_name(node.name.to_s)
+      add_constant(node, name)
+    end
+
+    sig { override.params(node: YARP::ConstantOperatorWriteNode).void }
+    def visit_constant_operator_write_node(node)
+      name = fully_qualify_name(node.name.to_s)
+      add_constant(node, name)
     end
 
-    # Override to avoid using `map` instead of `each`
-    sig { params(nodes: T::Array[T.nilable(YARP::Node)]).void }
-    def visit_all(nodes)
-      nodes.each { |node| visit(node) }
+    sig { override.params(node: YARP::CallNode).void }
+    def visit_call_node(node)
+      message = node.message
+      handle_private_constant(node) if message == "private_constant"
     end
 
     private
@@ -90,6 +132,8 @@ module RubyIndexer
         node: T.any(
           YARP::ConstantWriteNode,
           YARP::ConstantOrWriteNode,
+          YARP::ConstantAndWriteNode,
+          YARP::ConstantOperatorWriteNode,
           YARP::ConstantPathWriteNode,
           YARP::ConstantPathOrWriteNode,
           YARP::ConstantPathOperatorWriteNode,
@@ -133,7 +177,7 @@ module RubyIndexer
       comments = collect_comments(node)
       @index << klass.new(fully_qualify_name(name), @file_path, node.location, comments)
       @stack << name
-      visit_child_nodes(node)
+      visit(node.body)
       @stack.pop
     end
 

data/lib/ruby_indexer/test/constant_test.rb

@@ -306,5 +306,23 @@ module RubyIndexer
       constant = @index["A::M"].first
       assert_instance_of(Index::Entry::Constant, constant)
     end
+
+    def test_indexing_or_and_operator_nodes
+      index(<<~RUBY)
+        A ||= 1
+        B &&= 2
+        C &= 3
+        D::E ||= 4
+        F::G &&= 5
+        H::I &= 6
+      RUBY
+
+      assert_entry("A", Index::Entry::Constant, "/fake/path/foo.rb:0-0:0-7")
+      assert_entry("B", Index::Entry::Constant, "/fake/path/foo.rb:1-0:1-7")
+      assert_entry("C", Index::Entry::Constant, "/fake/path/foo.rb:2-0:2-6")
+      assert_entry("D::E", Index::Entry::Constant, "/fake/path/foo.rb:3-0:3-10")
+      assert_entry("F::G", Index::Entry::Constant, "/fake/path/foo.rb:4-0:4-10")
+      assert_entry("H::I", Index::Entry::Constant, "/fake/path/foo.rb:5-0:5-9")
+    end
   end
 end

data/lib/ruby_indexer/test/index_test.rb

@@ -178,5 +178,20 @@ module RubyIndexer
 
       assert_equal("Bar", entries.first.name)
     end
+
+    def test_resolving_aliases_to_non_existing_constants_with_conflicting_names
+      @index.index_single(IndexablePath.new("/fake", "/fake/path/foo.rb"), <<~RUBY)
+        module Foo
+          class Float < self
+            INFINITY = ::Float::INFINITY
+          end
+        end
+      RUBY
+
+      entry = @index.resolve("INFINITY", ["Foo", "Float"]).first
+      refute_nil(entry)
+
+      assert_instance_of(Index::Entry::UnresolvedAlias, entry)
+    end
   end
 end

data/lib/ruby_lsp/internal.rb

@@ -7,6 +7,7 @@ require "language_server-protocol"
 require "bundler"
 require "uri"
 require "cgi"
+require "set"
 
 require "ruby-lsp"
 require "ruby_indexer/ruby_indexer"

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -166,11 +166,6 @@ module RubyLsp
         add_simple_range(node)
       end
 
-      sig { params(node: YARP::Node).void }
-      def on_node(node)
-        emit_requires_range unless node.is_a?(YARP::CallNode)
-      end
-
       sig { params(node: YARP::StringConcatNode).void }
       def on_string_concat(node)
         left = T.let(node.left, YARP::Node)
@@ -271,6 +266,7 @@ module RubyLsp
 
       sig { params(start_line: Integer, end_line: Integer).void }
       def add_lines_range(start_line, end_line)
+        emit_requires_range
         return if start_line >= end_line
 
         @_response << Interface::FoldingRange.new(

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

@@ -56,7 +56,7 @@ module RubyLsp
 
     sig { params(gem_pattern: Regexp).returns(T::Boolean) }
     def direct_dependency?(gem_pattern)
-      dependency_keys.grep(gem_pattern).any?
+      dependencies.any?(gem_pattern)
     end
 
     sig { returns(T::Boolean) }
@@ -65,16 +65,24 @@ module RubyLsp
     end
 
     sig { returns(T::Array[String]) }
-    def dependency_keys
-      @dependency_keys ||= T.let(
+    def dependencies
+      # NOTE: If changing this behaviour, it's likely that the VS Code extension will also need changed.
+      @dependencies ||= T.let(
         begin
           Bundler.with_original_env { Bundler.default_gemfile }
-          Bundler.locked_gems.dependencies.keys
+          Bundler.locked_gems.dependencies.keys + gemspec_dependencies
         rescue Bundler::GemfileNotFound
           []
         end,
         T.nilable(T::Array[String]),
       )
     end
+
+    sig { returns(T::Array[String]) }
+    def gemspec_dependencies
+      Bundler.locked_gems.sources
+        .grep(Bundler::Source::Gemspec)
+        .flat_map { _1.gemspec&.dependencies&.map(&:name) }
+    end
   end
 end

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

@@ -47,13 +47,10 @@ module RubyLsp
 
         sig { returns(Interface::Diagnostic) }
         def to_lsp_diagnostic
-          if @offense.correctable?
-            severity = RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name]
-            message = @offense.message
-          else
-            severity = Constant::DiagnosticSeverity::WARNING
-            message = "#{@offense.message}\n\nThis offense is not auto-correctable.\n"
-          end
+          severity = RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name]
+          message  = @offense.message
+
+          message += "\n\nThis offense is not auto-correctable.\n" unless @offense.correctable?
 
           Interface::Diagnostic.new(
             message: message,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.11.2
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-10-03 00:00:00.000000000 Z
+date: 2023-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol