ruby-lsp 0.2.0 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f81baa8f09011e5130c955c4c5d2a33583379b0b073caee556719b874efc320e
-  data.tar.gz: 55a664f923d93bda9ddb06624303f889123496c672c46b31ea71c629cfa96a81
+  metadata.gz: 96c21e90970f4cbf198609a42471cf554ce86a3b6af9296ded95994ad373317a
+  data.tar.gz: a28aa2c13ba4d79f53082160b0eca7e8461efad831b6c6cca2a6a4d34765a6c0
 SHA512:
-  metadata.gz: 8a872f34699bfaa4f955c714c4e49eed52e87b009afc0a642d0ad434956f6a14690188ad9c359cc7aadd53e96fbd0d5d320e00aa263265e1ce3d3e369e8bd124
-  data.tar.gz: 06444ea3e08b961445db6cb1a9093fc322b40ddf47daa00deb09a77f3b114014be8f525d7d391430b578b7916042bf345759d113c74e41a8ea51d65791abe69c
+  metadata.gz: 5ab1bf48ae4943a710f34ef0aace64c1d8991271bdca71482a2367c3a103299c52ebaef203fa32945236d689dda67d2bb1b5cc5ca9ffa698f5dd057dd62e242f
+  data.tar.gz: 8b9453d71b65634e1ea275f3a2552548f530dc144acd18cdcbcee493f153b824a13bc60bbbe5ac937a993d9e9c56ce8cb70773d354b5cea7acda3f4f44722ffd

data/CHANGELOG.md

@@ -6,6 +6,33 @@ Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how
 
 ## [Unreleased]
 
+## [0.2.3]
+
+- Resolve generic source URIs for jump to gem source (https://github.com/Shopify/ruby-lsp/pull/237)
+
+## [0.2.2]
+
+- Support document links (https://github.com/Shopify/ruby-lsp/pull/195)
+- Avoid returning on request blocks (https://github.com/Shopify/ruby-lsp/pull/232)
+- Better specify gemspec files (https://github.com/Shopify/ruby-lsp/pull/233)
+- Include Kernel instance methods as special methods for semantic highlighting (https://github.com/Shopify/ruby-lsp/pull/231)
+- Fix call processing when message is a :call symbol literal (https://github.com/Shopify/ruby-lsp/pull/236)
+- Alert users about non auto-correctable diagnostics (https://github.com/Shopify/ruby-lsp/pull/230)
+- Let clients pull diagnostics instead of pushing on edits (https://github.com/Shopify/ruby-lsp/pull/242)
+
+## [0.2.1]
+
+- Implement the exit lifecycle request (https://github.com/Shopify/ruby-lsp/pull/198)
+- Remove the Sorbet runtime from the gem's default load path (https://github.com/Shopify/ruby-lsp/pull/214)
+- Return nil if the document is already formatted (https://github.com/Shopify/ruby-lsp/pull/216)
+- Handle nameless keyword rest parameters in semantic highlighting (https://github.com/Shopify/ruby-lsp/pull/222)
+- Display a warning on invalid RuboCop configuration (https://github.com/Shopify/ruby-lsp/pull/226)
+- Centralize request handling logic in server.rb (https://github.com/Shopify/ruby-lsp/pull/221)
+- Fix folding ranges for chained invocations involving an FCall (https://github.com/Shopify/ruby-lsp/pull/223)
+- Fix handling of argument fowarding in semantic highlighting (https://github.com/Shopify/ruby-lsp/pull/228)
+- Recover from initial syntax errors when opening documents (https://github.com/Shopify/ruby-lsp/pull/224)
+- Highlight occurrences and definitions in document highlight (https://github.com/Shopify/ruby-lsp/pull/187)
+
 ## [0.2.0]
 
 - Add semantic token for keyword and keyword rest params (https://github.com/Shopify/ruby-lsp/pull/142)

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.2.3

data/exe/ruby-lsp

@@ -18,6 +18,4 @@ rescue
   nil
 end
 
-require_relative "../lib/ruby_lsp/internal"
-
-RubyLsp::Cli.start
+require_relative "../lib/ruby_lsp/server"

data/lib/ruby-lsp.rb

@@ -1,6 +1,6 @@
-# typed: strict
+# typed: true
 # frozen_string_literal: true
 
 module RubyLsp
-  VERSION = T.let(File.read(File.expand_path("../VERSION", __dir__)).strip, String)
+  VERSION = File.read(File.expand_path("../VERSION", __dir__)).strip
 end

data/lib/ruby_lsp/document.rb

@@ -9,7 +9,7 @@ module RubyLsp
     RangeShape = T.type_alias { { start: PositionShape, end: PositionShape } }
     EditShape = T.type_alias { { range: RangeShape, text: String } }
 
-    sig { returns(SyntaxTree::Node) }
+    sig { returns(T.nilable(SyntaxTree::Node)) }
     attr_reader :tree
 
     sig { returns(String) }
@@ -20,11 +20,13 @@ module RubyLsp
 
     sig { params(source: String).void }
     def initialize(source)
-      @tree = T.let(SyntaxTree.parse(source), SyntaxTree::Node)
       @cache = T.let({}, T::Hash[Symbol, T.untyped])
       @syntax_error_edits = T.let([], T::Array[EditShape])
-      @source = source
+      @source = T.let(source, String)
       @parsable_source = T.let(source.dup, String)
+      @tree = T.let(SyntaxTree.parse(@source), T.nilable(SyntaxTree::Node))
+    rescue SyntaxTree::Parser::ParseError
+      # Do not raise if we failed to parse
     end
 
     sig { params(other: Document).returns(T::Boolean) }
@@ -67,6 +69,11 @@ module RubyLsp
       @syntax_error_edits.any?
     end
 
+    sig { returns(T::Boolean) }
+    def parsed?
+      !@tree.nil?
+    end
+
     private
 
     sig { params(edits: T::Array[EditShape]).void }

data/lib/ruby_lsp/handler.rb

@@ -6,17 +6,24 @@ require "ruby_lsp/store"
 require "benchmark"
 
 module RubyLsp
+  Interface = LanguageServer::Protocol::Interface
+  Constant = LanguageServer::Protocol::Constant
+  Transport = LanguageServer::Protocol::Transport
+
   class Handler
     extend T::Sig
     VOID = T.let(Object.new.freeze, Object)
 
+    sig { params(blk: T.proc.bind(Handler).params(arg0: T.untyped).void).void }
+    def self.start(&blk)
+      handler = new
+      handler.instance_exec(&blk)
+      handler.start
+    end
+
     sig { returns(Store) }
     attr_reader :store
 
-    Interface = LanguageServer::Protocol::Interface
-    Constant = LanguageServer::Protocol::Constant
-    Transport = LanguageServer::Protocol::Transport
-
     sig { void }
     def initialize
       @writer = T.let(Transport::Stdio::Writer.new, Transport::Stdio::Writer)
@@ -31,11 +38,6 @@ module RubyLsp
       @reader.read { |request| handle(request) }
     end
 
-    sig { params(blk: T.proc.bind(Handler).params(arg0: T.untyped).void).void }
-    def config(&blk)
-      instance_exec(&blk)
-    end
-
     private
 
     sig do
@@ -84,118 +86,6 @@ module RubyLsp
       store.clear
     end
 
-    sig { params(enabled_features: T::Array[String]).returns(Interface::InitializeResult) }
-    def respond_with_capabilities(enabled_features)
-      document_symbol_provider = if enabled_features.include?("documentSymbols")
-        Interface::DocumentSymbolClientCapabilities.new(
-          hierarchical_document_symbol_support: true,
-          symbol_kind: {
-            value_set: Requests::DocumentSymbol::SYMBOL_KIND.values,
-          }
-        )
-      end
-
-      folding_ranges_provider = if enabled_features.include?("foldingRanges")
-        Interface::FoldingRangeClientCapabilities.new(line_folding_only: true)
-      end
-
-      semantic_tokens_provider = if enabled_features.include?("semanticHighlighting")
-        Interface::SemanticTokensRegistrationOptions.new(
-          document_selector: { scheme: "file", language: "ruby" },
-          legend: Interface::SemanticTokensLegend.new(
-            token_types: Requests::SemanticHighlighting::TOKEN_TYPES.keys,
-            token_modifiers: Requests::SemanticHighlighting::TOKEN_MODIFIERS.keys
-          ),
-          range: false,
-          full: {
-            delta: true,
-          }
-        )
-      end
-
-      Interface::InitializeResult.new(
-        capabilities: Interface::ServerCapabilities.new(
-          text_document_sync: Interface::TextDocumentSyncOptions.new(
-            change: Constant::TextDocumentSyncKind::INCREMENTAL,
-            open_close: true,
-          ),
-          selection_range_provider: enabled_features.include?("selectionRanges"),
-          document_symbol_provider: document_symbol_provider,
-          folding_range_provider: folding_ranges_provider,
-          semantic_tokens_provider: semantic_tokens_provider,
-          document_formatting_provider: enabled_features.include?("formatting"),
-          document_highlight_provider: enabled_features.include?("documentHighlights"),
-          code_action_provider: enabled_features.include?("codeActions")
-        )
-      )
-    end
-
-    sig { params(uri: String).returns(T::Array[LanguageServer::Protocol::Interface::DocumentSymbol]) }
-    def respond_with_document_symbol(uri)
-      store.cache_fetch(uri, :document_symbol) do |document|
-        RubyLsp::Requests::DocumentSymbol.new(document).run
-      end
-    end
-
-    sig { params(uri: String).returns(T::Array[LanguageServer::Protocol::Interface::FoldingRange]) }
-    def respond_with_folding_ranges(uri)
-      store.cache_fetch(uri, :folding_ranges) do |document|
-        Requests::FoldingRanges.new(document).run
-      end
-    end
-
-    sig do
-      params(
-        uri: String,
-        positions: T::Array[Document::PositionShape]
-      ).returns(T::Array[T.nilable(RubyLsp::Requests::Support::SelectionRange)])
-    end
-    def respond_with_selection_ranges(uri, positions)
-      ranges = store.cache_fetch(uri, :selection_ranges) do |document|
-        Requests::SelectionRanges.new(document).run
-      end
-
-      # Per the selection range request spec (https://microsoft.github.io/language-server-protocol/specification#textDocument_selectionRange),
-      # every position in the positions array should have an element at the same index in the response
-      # array. For positions without a valid selection range, the corresponding element in the response
-      # array will be nil.
-      positions.map do |position|
-        ranges.find do |range|
-          range.cover?(position)
-        end
-      end
-    end
-
-    sig { params(uri: String).returns(LanguageServer::Protocol::Interface::SemanticTokens) }
-    def respond_with_semantic_highlighting(uri)
-      store.cache_fetch(uri, :semantic_highlighting) do |document|
-        T.cast(
-          Requests::SemanticHighlighting.new(document, encoder: Requests::Support::SemanticTokenEncoder.new).run,
-          LanguageServer::Protocol::Interface::SemanticTokens
-        )
-      end
-    end
-
-    sig { params(uri: String).returns(T.nilable(T::Array[LanguageServer::Protocol::Interface::TextEdit])) }
-    def respond_with_formatting(uri)
-      Requests::Formatting.new(uri, store.get(uri)).run
-    end
-
-    sig { params(uri: String).void }
-    def send_diagnostics(uri)
-      response = store.cache_fetch(uri, :diagnostics) do |document|
-        Requests::Diagnostics.new(uri, document).run
-      end
-
-      @writer.write(
-        method: "textDocument/publishDiagnostics",
-        params: Interface::PublishDiagnosticsParams.new(
-          uri: uri,
-          diagnostics: response.map(&:to_lsp_diagnostic)
-        )
-      )
-    end
-
     sig { params(uri: String).void }
     def clear_diagnostics(uri)
       @writer.write(
@@ -204,23 +94,12 @@ module RubyLsp
       )
     end
 
-    sig do
-      params(uri: String, range: T::Range[Integer]).returns(T::Array[LanguageServer::Protocol::Interface::CodeAction])
-    end
-    def respond_with_code_actions(uri, range)
-      store.cache_fetch(uri, :code_actions) do |document|
-        Requests::CodeActions.new(uri, document, range).run
-      end
-    end
-
-    sig do
-      params(
-        uri: String,
-        position: Document::PositionShape
-      ).returns(T::Array[LanguageServer::Protocol::Interface::DocumentHighlight])
-    end
-    def respond_with_document_highlight(uri, position)
-      Requests::DocumentHighlight.new(store.get(uri), position).run
+    sig { params(type: Integer, message: String).void }
+    def show_message(type, message)
+      @writer.write(
+        method: "window/showMessage",
+        params: Interface::ShowMessageParams.new(type: type, message: message)
+      )
     end
 
     sig do

data/lib/ruby_lsp/internal.rb

@@ -3,5 +3,7 @@
 
 require "sorbet-runtime"
 require "syntax_tree"
+require "language_server-protocol"
+
 require "ruby-lsp"
-require "ruby_lsp/cli"
+require "ruby_lsp/handler"

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -25,21 +25,11 @@ module RubyLsp
     class DocumentHighlight < BaseRequest
       extend T::Sig
 
-      VarNodes = T.type_alias do
-        T.any(
-          SyntaxTree::GVar,
-          SyntaxTree::Ident,
-          SyntaxTree::IVar,
-          SyntaxTree::Const,
-          SyntaxTree::CVar
-        )
-      end
-
       sig { params(document: Document, position: Document::PositionShape).void }
       def initialize(document, position)
         @highlights = T.let([], T::Array[LanguageServer::Protocol::Interface::DocumentHighlight])
         position = Document::Scanner.new(document.source).find_position(position)
-        @target = T.let(find(document.tree, position), T.nilable(VarNodes))
+        @target = T.let(find(T.must(document.tree), position), T.nilable(Support::HighlightTarget))
 
         super(document)
       end
@@ -53,33 +43,24 @@ module RubyLsp
         @highlights
       end
 
-      sig { params(node: SyntaxTree::VarField).void }
-      def visit_var_field(node)
-        if matches_target?(node.value)
-          add_highlight(
-            node.value,
-            LanguageServer::Protocol::Constant::DocumentHighlightKind::WRITE
-          )
-        end
-
-        super
-      end
+      sig { params(node: T.nilable(SyntaxTree::Node)).void }
+      def visit(node)
+        return if node.nil?
 
-      sig { params(node: SyntaxTree::VarRef).void }
-      def visit_var_ref(node)
-        if matches_target?(node.value)
-          add_highlight(
-            node.value,
-            LanguageServer::Protocol::Constant::DocumentHighlightKind::READ
-          )
-        end
+        match = T.must(@target).highlight_type(node)
+        add_highlight(match) if match
 
         super
       end
 
       private
 
-      sig { params(node: SyntaxTree::Node, position: Integer).returns(T.nilable(VarNodes)) }
+      sig do
+        params(
+          node: SyntaxTree::Node,
+          position: Integer,
+        ).returns(T.nilable(Support::HighlightTarget))
+      end
       def find(node, position)
         matched =
           node.child_nodes.compact.bsearch do |child|
@@ -91,22 +72,24 @@ module RubyLsp
           end
 
         case matched
-        when SyntaxTree::GVar, SyntaxTree::Ident, SyntaxTree::IVar, SyntaxTree::Const, SyntaxTree::CVar
-          matched
+        when SyntaxTree::GVar,
+             SyntaxTree::IVar,
+             SyntaxTree::Const,
+             SyntaxTree::CVar,
+             SyntaxTree::VarField
+          Support::HighlightTarget.new(matched)
+        when SyntaxTree::Ident
+          relevant_node = node.is_a?(SyntaxTree::Params) ? matched : node
+          Support::HighlightTarget.new(relevant_node)
         when SyntaxTree::Node
           find(matched, position)
         end
       end
 
-      sig { params(node: SyntaxTree::Node).returns(T::Boolean) }
-      def matches_target?(node)
-        node.is_a?(@target.class) && T.cast(node, VarNodes).value == T.must(@target).value
-      end
-
-      sig { params(node: SyntaxTree::Node, kind: Integer).void }
-      def add_highlight(node, kind)
-        range = range_from_syntax_tree_node(node)
-        @highlights << LanguageServer::Protocol::Interface::DocumentHighlight.new(range: range, kind: kind)
+      sig { params(match: Support::HighlightTarget::HighlightMatch).void }
+      def add_highlight(match)
+        range = range_from_syntax_tree_node(match.node)
+        @highlights << LanguageServer::Protocol::Interface::DocumentHighlight.new(range: range, kind: match.type)
       end
     end
   end

data/lib/ruby_lsp/requests/document_link.rb

@@ -0,0 +1,119 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "ruby_lsp/requests/support/source_uri"
+
+module RubyLsp
+  module Requests
+    # ![Document link demo](../../misc/document_link.gif)
+    #
+    # The [document link](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentLink)
+    # makes `# source://PATH_TO_FILE#line` comments in a Ruby/RBI file clickable if the file exists.
+    # When the user clicks the link, it'll open that location.
+    #
+    # # Example
+    #
+    # ```ruby
+    # # source://syntax_tree/3.2.1/lib/syntax_tree.rb#51 <- it will be clickable and will take the user to that location
+    # def format(source, maxwidth = T.unsafe(nil))
+    # end
+    # ```
+    class DocumentLink < BaseRequest
+      extend T::Sig
+
+      GEM_TO_VERSION_MAP = T.let(
+        [*::Gem::Specification.default_stubs, *::Gem::Specification.stubs].map! do |s|
+          [s.name, s.version.to_s]
+        end.to_h.freeze,
+        T::Hash[String, String]
+      )
+
+      class << self
+        extend T::Sig
+
+        sig { returns(T::Hash[String, T::Array[String]]) }
+        def gem_paths
+          @gem_paths ||= T.let(begin
+            lookup = {}
+
+            Gem::Specification.stubs.each do |stub|
+              spec = stub.to_spec
+              lookup[spec.name] = {}
+              lookup[spec.name][spec.version.to_s] = {}
+
+              Dir.glob("**/*.rb", base: "#{spec.full_gem_path}/").each do |path|
+                lookup[spec.name][spec.version.to_s][path] = "#{spec.full_gem_path}/#{path}"
+              end
+            end
+
+            Gem::Specification.default_stubs.each do |stub|
+              spec = stub.to_spec
+              lookup[spec.name] = {}
+              lookup[spec.name][spec.version.to_s] = {}
+              prefix_matchers = [//]
+              prefix_matchers.concat(spec.require_paths.map { |rp| Regexp.new("^#{rp}/") })
+              prefix_matcher = Regexp.union(prefix_matchers)
+
+              spec.files.each do |file|
+                path = file.sub(prefix_matcher, "")
+                lookup[spec.name][spec.version.to_s][path] = "#{RbConfig::CONFIG["rubylibdir"]}/#{path}"
+              end
+            end
+
+            lookup
+          end, T.nilable(T::Hash[String, T::Array[String]]))
+        end
+      end
+
+      sig { params(uri: String, document: Document).void }
+      def initialize(uri, document)
+        super(document)
+
+        # Match the version based on the version in the RBI file name. Notice that the `@` symbol is sanitized to `%40`
+        # in the URI
+        version_match = /(?<=%40)[\d.]+(?=\.rbi$)/.match(uri)
+        @gem_version = T.let(version_match && version_match[0], T.nilable(String))
+        @links = T.let([], T::Array[LanguageServer::Protocol::Interface::DocumentLink])
+      end
+
+      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::DocumentLink], Object)) }
+      def run
+        visit(@document.tree)
+        @links
+      end
+
+      sig { params(node: SyntaxTree::Comment).void }
+      def visit_comment(node)
+        match = node.value.match(%r{source://.*#\d+$})
+        return unless match
+
+        uri = T.cast(URI(match[0]), URI::Source)
+        gem_version = resolve_version(uri)
+        file_path = self.class.gem_paths.dig(uri.gem_name, gem_version, uri.path)
+        return if file_path.nil?
+
+        @links << LanguageServer::Protocol::Interface::DocumentLink.new(
+          range: range_from_syntax_tree_node(node),
+          target: "file://#{file_path}##{uri.line_number}",
+          tooltip: "Jump to #{file_path}##{uri.line_number}"
+        )
+      end
+
+      private
+
+      # Try to figure out the gem version for a source:// link. The order of precedence is:
+      # 1. The version in the URI
+      # 2. The version in the RBI file name
+      # 3. The version from the gemspec
+      sig { params(uri: URI::Source).returns(T.nilable(String)) }
+      def resolve_version(uri)
+        version = uri.gem_version
+        return version unless version.nil? || version.empty?
+
+        return @gem_version unless @gem_version.nil? || @gem_version.empty?
+
+        GEM_TO_VERSION_MAP[uri.gem_name]
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -195,7 +195,11 @@ module RubyLsp
             receiver = receiver.receiver
           when SyntaxTree::MethodAddBlock
             visit(receiver.block)
-            receiver = receiver.call.receiver
+            receiver = receiver.call
+
+            if receiver.is_a?(SyntaxTree::Call) || receiver.is_a?(SyntaxTree::CommandCall)
+              receiver = receiver.receiver
+            end
           else
             break
           end

data/lib/ruby_lsp/requests/formatting.rb

@@ -34,6 +34,7 @@ module RubyLsp
         return unless formatted_text
 
         size = @document.source.size
+        return if formatted_text.size == size && formatted_text == @document.source
 
         [
           LanguageServer::Protocol::Interface::TextEdit.new(

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -60,10 +60,13 @@ module RubyLsp
         default_library: 9,
       }.freeze, T::Hash[Symbol, Integer])
 
-      SPECIAL_RUBY_METHODS = T.let((Module.instance_methods(false) +
-        Kernel.methods(false) + Bundler::Dsl.instance_methods(false) +
-        Module.private_instance_methods(false))
-        .map(&:to_s), T::Array[String])
+      SPECIAL_RUBY_METHODS = T.let([
+        Module.instance_methods(false),
+        Kernel.instance_methods(false),
+        Kernel.methods(false),
+        Bundler::Dsl.instance_methods(false),
+        Module.private_instance_methods(false),
+      ].flatten.map(&:to_s), T::Array[String])
 
       class SemanticToken < T::Struct
         const :location, SyntaxTree::Location
@@ -78,7 +81,7 @@ module RubyLsp
 
         @encoder = encoder
         @tokens = T.let([], T::Array[SemanticToken])
-        @tree = T.let(document.tree, SyntaxTree::Node)
+        @tree = T.let(T.must(document.tree), SyntaxTree::Node)
         @special_methods = T.let(nil, T.nilable(T::Array[String]))
       end
 
@@ -105,7 +108,10 @@ module RubyLsp
       sig { params(node: SyntaxTree::Call).void }
       def visit_call(node)
         visit(node.receiver)
-        add_token(node.message.location, :method)
+
+        message = node.message
+        add_token(message.location, :method) if message != :call
+
         visit(node.arguments)
       end
 
@@ -179,7 +185,11 @@ module RubyLsp
           add_token(location_without_colon(location), :variable)
         end
 
-        add_token(node.keyword_rest.name.location, :variable) if node.keyword_rest
+        rest = node.keyword_rest
+        return if rest.nil? || rest.is_a?(SyntaxTree::ArgsForward)
+
+        name = rest.name
+        add_token(name.location, :variable) if name
       end
 
       sig { params(node: SyntaxTree::VarField).void }