ruby-lsp 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11dd3401d408ed456da9b4dd0aca906b991a45a0103ca8786eafbf34d4659c85
-  data.tar.gz: 8469dd62a3660965daee589835e1481fe09e17b55cbd9d61c461d4ba94db833e
+  metadata.gz: 0da1b154c2c048cdea8d1ca6f87e77b895482cdbea155058550eff983fdbae1c
+  data.tar.gz: 7a67502b28e7e525acc6349fafe5de9e9945350d84af72d0a9afaa5d5b0803d8
 SHA512:
-  metadata.gz: 6d2e0c3d9c5bf11068b1d5e3092d4b5f3b233066a33b7e74ea218f115fbb8b154798a8b8b0634569781245f1dedcb6da3e5ca3a23db04f78fc105c496d2a3280
-  data.tar.gz: 529ce841833605ac40c67536bbca1eb1a9568b742de854f4698ced147813ec63569fd926d4035d518f7bb0ab54d2bbd4665e7ad2564923b49036573a0d4625e7
+  metadata.gz: 77968226990bdcbab7026e962a3b7e1e3459f920939aa19a50331daa7b4a24b180eb46a342b5385412a43b73d1d6e40d6f9de2f1321a512cf65d36046b978cbc
+  data.tar.gz: a27e182f7c554d9b231f4ea69b15b52d0c4c32fe0cbb17879480c8b9ada87288c59ffa93fbfd99963c456bf4a6298164c920f720611532609f5e985e3c1e890c

data/README.md

@@ -42,6 +42,15 @@ See the [documentation](https://shopify.github.io/ruby-lsp) for more in-depth de
 For creating rich themes for Ruby using the semantic highlighting information, see the [semantic highlighting
 documentation](SEMANTIC_HIGHLIGHTING.md).
 
+### Extensions
+
+The Ruby LSP provides a server extension system that allows other gems to enhance the base functionality with more
+editor features. This is the mechanism that powers extensions like
+
+- [Ruby LSP Rails](https://github.com/Shopify/ruby-lsp-rails)
+
+For instructions on how to create extensions, see the [server extensions documentation](SERVER_EXTENSIONS.md).
+
 ## Learn More
 
 * [RubyConf 2022: Improving the development experience with language servers](https://www.youtube.com/watch?v=kEfXPTm1aCI) ([Vinicius Stock](https://github.com/vinistock))

data/VERSION

@@ -1 +1 @@
-0.6.1
+0.6.2

data/lib/ruby_lsp/check_docs.rb

@@ -52,7 +52,7 @@ module RubyLsp
       # Find all classes that inherit from BaseRequest or Listener, which are the ones we want to make sure are
       # documented
       features = ObjectSpace.each_object(Class).filter_map do |k|
-        klass = T.cast(k, T::Class[T.anything])
+        klass = T.unsafe(k)
         klass if klass < RubyLsp::Requests::BaseRequest || klass < RubyLsp::Listener
       end
 

data/lib/ruby_lsp/event_emitter.rb

@@ -53,6 +53,12 @@ module RubyLsp
 
     # Visit dispatchers are below. Notice that for nodes that create a new scope (e.g.: classes, modules, method defs)
     # we need both an `on_*` and `after_*` event. This is because some requests must know when we exit the scope
+    sig { override.params(node: T.nilable(SyntaxTree::Node)).void }
+    def visit(node)
+      @listeners[:on_node]&.each { |l| T.unsafe(l).on_node(node) }
+      super
+    end
+
     sig { override.params(node: SyntaxTree::ClassDeclaration).void }
     def visit_class(node)
       @listeners[:on_class]&.each { |l| T.unsafe(l).on_class(node) }

data/lib/ruby_lsp/executor.rb

@@ -130,7 +130,7 @@ module RubyLsp
           )
 
           nil
-        rescue StandardError => error
+        rescue StandardError, LoadError => error
           @message_queue << Notification.new(
             message: "window/showMessage",
             params: Interface::ShowMessageParams.new(
@@ -156,7 +156,7 @@ module RubyLsp
       when "textDocument/diagnostic"
         begin
           diagnostic(uri)
-        rescue StandardError => error
+        rescue StandardError, LoadError => error
           @message_queue << Notification.new(
             message: "window/showMessage",
             params: Interface::ShowMessageParams.new(
@@ -275,10 +275,17 @@ module RubyLsp
       params(
         uri: String,
         position: Document::PositionShape,
-      ).returns(T::Array[Interface::DocumentHighlight])
+      ).returns(T.nilable(T::Array[Interface::DocumentHighlight]))
     end
     def document_highlight(uri, position)
-      Requests::DocumentHighlight.new(@store.get(uri), position).run
+      document = @store.get(uri)
+      return if document.syntax_error?
+
+      target, parent = document.locate_node(position)
+      emitter = EventEmitter.new
+      listener = Requests::DocumentHighlight.new(target, parent, emitter, @message_queue)
+      emitter.visit(document.tree)
+      listener.response
     end
 
     sig { params(uri: String, range: Document::RangeShape).returns(T.nilable(T::Array[Interface::InlayHint])) }

data/lib/ruby_lsp/requests/code_lens.rb

@@ -29,6 +29,7 @@ module RubyLsp
 
       BASE_COMMAND = T.let((File.exist?("Gemfile.lock") ? "bundle exec ruby" : "ruby") + " -Itest ", String)
       ACCESS_MODIFIERS = T.let(["public", "private", "protected"], T::Array[String])
+      SUPPORTED_TEST_LIBRARIES = T.let(["minitest", "test-unit"], T::Array[String])
 
       sig { override.returns(ResponseType) }
       attr_reader :response
@@ -61,8 +62,9 @@ module RubyLsp
       def on_class(node)
         @visibility_stack.push(["public", "public"])
         class_name = node.constant.constant.value
+        @class_stack.push(class_name)
+
         if class_name.end_with?("Test")
-          @class_stack.push(class_name)
           add_test_code_lens(
             node,
             name: class_name,
@@ -81,7 +83,7 @@ module RubyLsp
       sig { params(node: SyntaxTree::DefNode).void }
       def on_def(node)
         class_name = @class_stack.last
-        return unless class_name
+        return unless class_name&.end_with?("Test")
 
         visibility, _ = @visibility_stack.last
         if visibility == "public"
@@ -156,6 +158,9 @@ module RubyLsp
 
       sig { params(node: SyntaxTree::Node, name: String, command: String, kind: Symbol).void }
       def add_test_code_lens(node, name:, command:, kind:)
+        # don't add code lenses if the test library is not supported or unknown
+        return unless SUPPORTED_TEST_LIBRARIES.include?(@test_library)
+
         arguments = [
           @path,
           name,
@@ -195,10 +200,13 @@ module RubyLsp
 
       sig { params(node: SyntaxTree::Command).returns(T.nilable(String)) }
       def resolve_gem_remote(node)
-        gem_statement = node.arguments.parts.flat_map(&:child_nodes).first
-        return unless gem_statement
+        gem_statement = node.arguments.parts.first
+        return unless gem_statement.is_a?(SyntaxTree::StringLiteral)
+
+        gem_name = gem_statement.parts.first
+        return unless gem_name.is_a?(SyntaxTree::TStringContent)
 
-        spec = Gem::Specification.stubs.find { |gem| gem.name == gem_statement.value }&.to_spec
+        spec = Gem::Specification.stubs.find { |gem| gem.name == gem_name.value }&.to_spec
         return if spec.nil?
 
         [spec.homepage, spec.metadata["source_code_uri"]].compact.find do |page|

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -22,34 +22,49 @@ module RubyLsp
     #   FOO # should be highlighted as "read"
     # end
     # ```
-    class DocumentHighlight < BaseRequest
+    class DocumentHighlight < Listener
       extend T::Sig
 
-      sig { params(document: Document, position: Document::PositionShape).void }
-      def initialize(document, position)
-        super(document)
+      ResponseType = type_member { { fixed: T::Array[Interface::DocumentHighlight] } }
 
-        @highlights = T.let([], T::Array[Interface::DocumentHighlight])
-        return unless document.parsed?
+      sig { override.returns(ResponseType) }
+      attr_reader :response
 
-        @target = T.let(find(position), T.nilable(Support::HighlightTarget))
+      sig do
+        params(
+          target: T.nilable(SyntaxTree::Node),
+          parent: T.nilable(SyntaxTree::Node),
+          emitter: EventEmitter,
+          message_queue: Thread::Queue,
+        ).void
       end
+      def initialize(target, parent, emitter, message_queue)
+        super(emitter, message_queue)
+
+        @response = T.let([], T::Array[Interface::DocumentHighlight])
+
+        return unless target && parent
 
-      sig { override.returns(T.all(T::Array[Interface::DocumentHighlight], Object)) }
-      def run
-        # no @target means the target is not highlightable
-        visit(@document.tree) if @document.parsed? && @target
-        @highlights
+        highlight_target =
+          case target
+          when *DIRECT_HIGHLIGHTS
+            Support::HighlightTarget.new(target)
+          when SyntaxTree::Ident
+            relevant_node = parent.is_a?(SyntaxTree::Params) ? target : parent
+            Support::HighlightTarget.new(relevant_node)
+          end
+
+        @target = T.let(highlight_target, T.nilable(Support::HighlightTarget))
+
+        emitter.register(self, :on_node) if @target
       end
 
-      sig { override.params(node: T.nilable(SyntaxTree::Node)).void }
-      def visit(node)
+      sig { params(node: T.nilable(SyntaxTree::Node)).void }
+      def on_node(node)
         return if node.nil?
 
         match = T.must(@target).highlight_type(node)
         add_highlight(match) if match
-
-        super
       end
 
       private
@@ -65,30 +80,10 @@ module RubyLsp
         T::Array[T.class_of(SyntaxTree::Node)],
       )
 
-      sig do
-        params(
-          position: Document::PositionShape,
-        ).returns(T.nilable(Support::HighlightTarget))
-      end
-      def find(position)
-        matched, parent = @document.locate_node(position)
-
-        return unless matched && parent
-        return unless matched.is_a?(SyntaxTree::Ident) || DIRECT_HIGHLIGHTS.include?(matched.class)
-
-        case matched
-        when *DIRECT_HIGHLIGHTS
-          Support::HighlightTarget.new(matched)
-        when SyntaxTree::Ident
-          relevant_node = parent.is_a?(SyntaxTree::Params) ? matched : parent
-          Support::HighlightTarget.new(relevant_node)
-        end
-      end
-
       sig { params(match: Support::HighlightTarget::HighlightMatch).void }
       def add_highlight(match)
         range = range_from_syntax_tree_node(match.node)
-        @highlights << Interface::DocumentHighlight.new(range: range, kind: match.type)
+        @response << Interface::DocumentHighlight.new(range: range, kind: match.type)
       end
     end
   end

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -30,13 +30,11 @@ module RubyLsp
       def initialize(document, position, trigger_character)
         super(document)
 
-        scanner = document.create_scanner
-        line_begin = position[:line] == 0 ? 0 : scanner.find_char_position({ line: position[:line] - 1, character: 0 })
-        @line_end = T.let(scanner.find_char_position(position), Integer)
-        line = T.must(@document.source[line_begin..@line_end])
+        @lines = T.let(@document.source.lines, T::Array[String])
+        line = @lines[[position[:line] - 1, 0].max]
 
-        @indentation = T.let(find_indentation(line), Integer)
-        @previous_line = T.let(line.strip.chomp, String)
+        @indentation = T.let(line ? find_indentation(line) : 0, Integer)
+        @previous_line = T.let(line ? line.strip.chomp : "", String)
         @position = position
         @edits = T.let([], T::Array[Interface::TextEdit])
         @trigger_character = trigger_character
@@ -87,30 +85,15 @@ module RubyLsp
         return unless END_REGEXES.any? { |regex| regex.match?(@previous_line) }
 
         indents = " " * @indentation
+        current_line = @lines[@position[:line]]
+        next_line = @lines[@position[:line] + 1]
 
-        if @previous_line.include?("\n")
-          # If the previous line has a line break, then it means there's content after the line break that triggered
-          # this completion. For these cases, we want to add the `end` after the content and move the cursor back to the
-          # keyword that triggered the completion
-
-          line = @position[:line]
-
-          # If there are enough lines in the document, we want to add the `end` token on the line below the extra
-          # content. Otherwise, we want to insert and extra line break ourselves
-          correction = if T.must(@document.source[@line_end..-1]).count("\n") >= 2
-            line -= 1
-            "#{indents}end"
-          else
-            "#{indents}\nend"
-          end
-
-          add_edit_with_text(correction, { line: @position[:line] + 1, character: @position[:character] })
-          move_cursor_to(line, @indentation + 3)
-        else
-          # If there's nothing after the new line break that triggered the completion, then we want to add the `end` and
-          # move the cursor to the body of the statement
+        if current_line.nil? || current_line.blank?
           add_edit_with_text(" \n#{indents}end")
           move_cursor_to(@position[:line], @indentation + 2)
+        elsif next_line.nil? || next_line.blank?
+          add_edit_with_text("#{indents}end", { line: @position[:line] + 1, character: @position[:character] })
+          move_cursor_to(@position[:line], @indentation + 3)
         end
       end
 

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

@@ -20,15 +20,19 @@ module RubyLsp
 
       sig { returns(String) }
       def detected_test_library
-        if direct_dependency?(/^minitest/)
+        # A Rails app may have a dependency on minitest, but we would instead want to use the Rails test runner provided
+        # by ruby-lsp-rails.
+        if direct_dependency?(/^rails$/)
+          "rails"
+        # NOTE: Intentionally ends with $ to avoid mis-matching minitest-reporters, etc. in a Rails app.
+        elsif direct_dependency?(/^minitest$/)
           "minitest"
         elsif direct_dependency?(/^test-unit/)
           "test-unit"
         elsif direct_dependency?(/^rspec/)
           "rspec"
         else
-          warn("WARNING: No test library detected. Assuming minitest.")
-          "minitest"
+          "unknown"
         end
       end
 

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

@@ -78,7 +78,7 @@ module URI
     if URI.respond_to?(:register_scheme)
       URI.register_scheme("SOURCE", self)
     else
-      @@schemes = T.let(@@schemes, T::Hash[String, T::Class[T.anything]]) # rubocop:disable Style/ClassVars
+      @@schemes = T.let(@@schemes, T::Hash[String, T.untyped]) # rubocop:disable Style/ClassVars
       @@schemes["SOURCE"] = self
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.2
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-06-19 00:00:00.000000000 Z
+date: 2023-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol