ruby-lsp 0.22.0 → 0.22.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e48cef95e466e2a75943921fc08ede1a449e07096e44078ca063bdbee6d3c54b
-  data.tar.gz: c0ce6a0636645674e9e9a87219124b622b1280420c14c4bd12f8f0f0aafc3f32
+  metadata.gz: efd5671eae595026a17c3114a00de1053865ac828726dd7ac5a66548f6b1ad56
+  data.tar.gz: ccf5b7af12a6e1e327cc2d458be11f39a9ac7319ab9049863ed5a74e333e8a6f
 SHA512:
-  metadata.gz: 89d02237ecce7e784bb5275ba4d5fc30b64981ea337b078f3117037b98d8f734e0d7e6266078e76023125dd52bbcb6ded8d04fdac1c29eb8292fd29e401cece4
-  data.tar.gz: 7245d82a481bd9e6a56d0cce9ad03796bd1a6d9e770beb5632fcaf7669ab0af9e9c0c95f0b671d844231af718add21b98011665ac3355fab5647ab12378b60bf
+  metadata.gz: 8fbcdfaac508788a17fb3b7e939ce290e33049a0080ff6260abfaeb609ee76a033234ccc2efa5724587e9c4cbf4552e2cd5d2cb0af1186971b8ed06fec290cb3
+  data.tar.gz: 3e37acf250618e60df2addbce7f9acf86df4bf3e771b7b49c4cd8f4ad326ea82e3d41ad80c5ce71e3b0429dab98385df51f4645824cd419e32dac5ea13778760

data/VERSION

@@ -1 +1 @@
-0.22.0
+0.22.1

data/lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -282,6 +282,9 @@ module RubyIndexer
         @visibility_stack.push(Entry::Visibility::PRIVATE)
       when :module_function
         handle_module_function(node)
+      when :private_class_method
+        @visibility_stack.push(Entry::Visibility::PRIVATE)
+        handle_private_class_method(node)
       end
 
       @enhancements.each do |enhancement|
@@ -297,7 +300,7 @@ module RubyIndexer
     def on_call_node_leave(node)
       message = node.name
       case message
-      when :public, :protected, :private
+      when :public, :protected, :private, :private_class_method
         # We want to restore the visibility stack when we leave a method definition with a visibility modifier
         # e.g. `private def foo; end`
         if node.arguments&.arguments&.first&.is_a?(Prism::DefNode)
@@ -875,6 +878,45 @@ module RubyIndexer
       end
     end
 
+    sig { params(node: Prism::CallNode).void }
+    def handle_private_class_method(node)
+      node.arguments&.arguments&.each do |argument|
+        string_or_symbol_nodes = case argument
+        when Prism::StringNode, Prism::SymbolNode
+          [argument]
+        when Prism::ArrayNode
+          argument.elements
+        else
+          []
+        end
+
+        unless string_or_symbol_nodes.empty?
+          # pop the visibility off since there isn't a method definition following `private_class_method`
+          @visibility_stack.pop
+        end
+
+        string_or_symbol_nodes.each do |string_or_symbol_node|
+          method_name = case string_or_symbol_node
+          when Prism::StringNode
+            string_or_symbol_node.content
+          when Prism::SymbolNode
+            string_or_symbol_node.value
+          end
+          next unless method_name
+
+          owner_name = @owner_stack.last&.name
+          next unless owner_name
+
+          entries = @index.resolve_method(method_name, @index.existing_or_new_singleton_class(owner_name).name)
+          next unless entries
+
+          entries.each do |entry|
+            entry.visibility = Entry::Visibility::PRIVATE
+          end
+        end
+      end
+    end
+
     sig { returns(Entry::Visibility) }
     def current_visibility
       T.must(@visibility_stack.last)

data/lib/ruby_indexer/test/method_test.rb

@@ -149,6 +149,86 @@ module RubyIndexer
       end
     end
 
+    def test_private_class_method_visibility_tracking_string_symbol_arguments
+      index(<<~RUBY)
+        class Test
+          def self.foo
+          end
+
+          def self.bar
+          end
+
+          private_class_method("foo", :bar)
+
+          def self.baz
+          end
+        end
+      RUBY
+
+      ["foo", "bar"].each do |keyword|
+        entries = T.must(@index[keyword])
+        assert_equal(1, entries.size)
+        entry = entries.first
+        assert_predicate(entry, :private?)
+      end
+
+      entries = T.must(@index["baz"])
+      assert_equal(1, entries.size)
+      entry = entries.first
+      assert_predicate(entry, :public?)
+    end
+
+    def test_private_class_method_visibility_tracking_array_argument
+      index(<<~RUBY)
+        class Test
+          def self.foo
+          end
+
+          def self.bar
+          end
+
+          private_class_method(["foo", :bar])
+
+          def self.baz
+          end
+        end
+      RUBY
+
+      ["foo", "bar"].each do |keyword|
+        entries = T.must(@index[keyword])
+        assert_equal(1, entries.size)
+        entry = entries.first
+        assert_predicate(entry, :private?)
+      end
+
+      entries = T.must(@index["baz"])
+      assert_equal(1, entries.size)
+      entry = entries.first
+      assert_predicate(entry, :public?)
+    end
+
+    def test_private_class_method_visibility_tracking_method_argument
+      index(<<~RUBY)
+        class Test
+          private_class_method def self.foo
+          end
+
+          def self.bar
+          end
+        end
+      RUBY
+
+      entries = T.must(@index["foo"])
+      assert_equal(1, entries.size)
+      entry = entries.first
+      assert_predicate(entry, :private?)
+
+      entries = T.must(@index["bar"])
+      assert_equal(1, entries.size)
+      entry = entries.first
+      assert_predicate(entry, :public?)
+    end
+
     def test_comments_documentation
       index(<<~RUBY)
         # Documentation for Foo

data/lib/ruby_lsp/global_state.rb

@@ -146,7 +146,7 @@ module RubyLsp
 
     sig { params(flag: Symbol).returns(T.nilable(T::Boolean)) }
     def enabled_feature?(flag)
-      @enabled_feature_flags[flag]
+      @enabled_feature_flags[:all] || @enabled_feature_flags[flag]
     end
 
     sig { returns(String) }

data/lib/ruby_lsp/listeners/document_symbol.rb

@@ -41,6 +41,9 @@ module RubyLsp
           :on_module_node_enter,
           :on_module_node_leave,
           :on_instance_variable_write_node_enter,
+          :on_instance_variable_operator_write_node_enter,
+          :on_instance_variable_or_write_node_enter,
+          :on_instance_variable_and_write_node_enter,
           :on_class_variable_write_node_enter,
           :on_singleton_class_node_enter,
           :on_singleton_class_node_leave,
@@ -249,21 +252,51 @@ module RubyLsp
         @response_builder.pop
       end
 
+      sig { params(node: Prism::ClassVariableWriteNode).void }
+      def on_class_variable_write_node_enter(node)
+        create_document_symbol(
+          name: node.name.to_s,
+          kind: Constant::SymbolKind::VARIABLE,
+          range_location: node.name_loc,
+          selection_range_location: node.name_loc,
+        )
+      end
+
       sig { params(node: Prism::InstanceVariableWriteNode).void }
       def on_instance_variable_write_node_enter(node)
         create_document_symbol(
           name: node.name.to_s,
-          kind: Constant::SymbolKind::VARIABLE,
+          kind: Constant::SymbolKind::FIELD,
           range_location: node.name_loc,
           selection_range_location: node.name_loc,
         )
       end
 
-      sig { params(node: Prism::ClassVariableWriteNode).void }
-      def on_class_variable_write_node_enter(node)
+      sig { params(node: Prism::InstanceVariableOperatorWriteNode).void }
+      def on_instance_variable_operator_write_node_enter(node)
         create_document_symbol(
           name: node.name.to_s,
-          kind: Constant::SymbolKind::VARIABLE,
+          kind: Constant::SymbolKind::FIELD,
+          range_location: node.name_loc,
+          selection_range_location: node.name_loc,
+        )
+      end
+
+      sig { params(node: Prism::InstanceVariableOrWriteNode).void }
+      def on_instance_variable_or_write_node_enter(node)
+        create_document_symbol(
+          name: node.name.to_s,
+          kind: Constant::SymbolKind::FIELD,
+          range_location: node.name_loc,
+          selection_range_location: node.name_loc,
+        )
+      end
+
+      sig { params(node: Prism::InstanceVariableAndWriteNode).void }
+      def on_instance_variable_and_write_node_enter(node)
+        create_document_symbol(
+          name: node.name.to_s,
+          kind: Constant::SymbolKind::FIELD,
           range_location: node.name_loc,
           selection_range_location: node.name_loc,
         )

data/lib/ruby_lsp/setup_bundler.rb

@@ -45,6 +45,9 @@ module RubyLsp
       )
       @lockfile = T.let(@gemfile ? Bundler.default_lockfile : nil, T.nilable(Pathname))
 
+      @gemfile_hash = T.let(@gemfile ? Digest::SHA256.hexdigest(@gemfile.read) : nil, T.nilable(String))
+      @lockfile_hash = T.let(@lockfile&.exist? ? Digest::SHA256.hexdigest(@lockfile.read) : nil, T.nilable(String))
+
       @gemfile_name = T.let(@gemfile&.basename&.to_s || "Gemfile", String)
 
       # Custom bundle paths
@@ -91,10 +94,8 @@ module RubyLsp
         return run_bundle_install(@custom_gemfile)
       end
 
-      lockfile_contents = @lockfile.read
-      current_lockfile_hash = Digest::SHA256.hexdigest(lockfile_contents)
-
-      if @custom_lockfile.exist? && @lockfile_hash_path.exist? && @lockfile_hash_path.read == current_lockfile_hash
+      if @lockfile_hash && @custom_lockfile.exist? && @lockfile_hash_path.exist? &&
+          @lockfile_hash_path.read == @lockfile_hash
         $stderr.puts(
           "Ruby LSP> Skipping composed bundle setup since #{@custom_lockfile} already exists and is up to date",
         )
@@ -103,7 +104,7 @@ module RubyLsp
 
       FileUtils.cp(@lockfile.to_s, @custom_lockfile.to_s)
       correct_relative_remote_paths
-      @lockfile_hash_path.write(current_lockfile_hash)
+      @lockfile_hash_path.write(@lockfile_hash)
       run_bundle_install(@custom_gemfile)
     end
 
@@ -214,6 +215,23 @@ module RubyLsp
         @error_path.write(Marshal.dump(e))
       end
 
+      # If either the Gemfile or the lockfile have been modified during the process of setting up the bundle, retry
+      # composing the bundle from scratch
+
+      if @gemfile && @lockfile
+        current_gemfile_hash = Digest::SHA256.hexdigest(@gemfile.read)
+        current_lockfile_hash = Digest::SHA256.hexdigest(@lockfile.read)
+
+        if !@retry && (current_gemfile_hash != @gemfile_hash || current_lockfile_hash != @lockfile_hash)
+          @gemfile_hash = current_gemfile_hash
+          @lockfile_hash = current_lockfile_hash
+          @retry = true
+          @custom_dir.rmtree
+          $stderr.puts("Ruby LSP> Bundle was modified during setup. Retrying from scratch...")
+          return setup!
+        end
+      end
+
       env
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.22.0
+  version: 0.22.1
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-20 00:00:00.000000000 Z
+date: 2024-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol