ruby-lsp 0.1.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b072ffa3ea73a83aba6d6c32b931c4de30b0de06fd70655d620c3ed95bd8aa4
-  data.tar.gz: 24568688b20ffed38defcbc0b00708eb22a7dad20a9b5f397348242a64359bfd
+  metadata.gz: 0fefb041d92fb2000d3da23248ed622abd596a95264b421349f27d104b85f997
+  data.tar.gz: 312918f128e0a49a2f5b2066354df2fe45f9ed37af5e5eace6c76caa101155e5
 SHA512:
-  metadata.gz: ea1830f0be08cb291e67d80bbe21dbe17f3e4b4d285b1d9112e004ca2feff32eaca85af755bc2635e3341ab4e64491710c3ba13c5bed617e34495534e1d7a5f8
-  data.tar.gz: f84b1b27c5c17455d1e8423f1e52f98a754ed123e1722bd536ee7bfdc754952e5d6619c0f4402664a33dc278bdc2422a3e7a37c8de5f172e4456e7a6c08b7a67
+  metadata.gz: 7ab96bd356fe94e3a95572bec24053eed9b467c71acec431a80c600e87ea5a3c31f0f2aee20c7b3b407b5aabc9b5736e0bb385dedf2840747c892fe7ad090b69
+  data.tar.gz: 2ec3f3c88c851e86e7ef6485c7719a271dbda81717990446900fe121844daac905b5f554833b59769a4c6f626bb50579d5e51970e7a306d206c898d0a289d36c

data/CHANGELOG.md

@@ -6,6 +6,41 @@ Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how
 
 ## [Unreleased]
 
+## [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)
+- Return error responses on exceptions (https://github.com/Shopify/ruby-lsp/pull/160)
+- Sanitize home directory for telemetry (https://github.com/Shopify/ruby-lsp/pull/171)
+- Avoid adding semantic tokens for special methods (https://github.com/Shopify/ruby-lsp/pull/162)
+- Properly respect excluded files in RuboCop requests (https://github.com/Shopify/ruby-lsp/pull/173)
+- Clear diagnostics when closing files (https://github.com/Shopify/ruby-lsp/pull/174)
+- Avoid pushing ranges for single line partial ranges (https://github.com/Shopify/ruby-lsp/pull/185)
+- Change folding ranges to include closing tokens (https://github.com/Shopify/ruby-lsp/pull/181)
+- Remove RuboCop dependency and fallback to SyntaxTree formatting (https://github.com/Shopify/ruby-lsp/pull/184)
+
 ## [0.1.0]
 
 - Implement token modifiers in SemanticTokenEncoder ([#112](https://github.com/Shopify/ruby-lsp/pull/112))

data/README.md

@@ -17,7 +17,8 @@ end
 If using VS Code, install the [Ruby LSP plugin](https://github.com/Shopify/vscode-ruby-lsp) to get the extra features in
 the editor.
 
-See the [documentation](https://shopify.github.io/ruby-lsp) for supported features.
+See the [documentation](https://shopify.github.io/ruby-lsp) for
+[supported features](https://shopify.github.io/ruby-lsp/RubyLsp/Requests.html).
 
 ## Contributing
 

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.2

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
@@ -62,7 +64,16 @@ module RubyLsp
             error = e
           end
 
-          @writer.write(id: request[:id], result: result) unless result == VOID
+          if error
+            @writer.write(
+              {
+                id: request[:id],
+                error: { code: Constant::ErrorCodes::INTERNAL_ERROR, message: error.inspect, data: request.to_json },
+              }
+            )
+          elsif result != VOID
+            @writer.write(id: request[:id], result: result)
+          end
         end
       end
 
@@ -75,135 +86,20 @@ 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,
-            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
-
+    def clear_diagnostics(uri)
       @writer.write(
         method: "textDocument/publishDiagnostics",
-        params: Interface::PublishDiagnosticsParams.new(
-          uri: uri,
-          diagnostics: response.map(&:to_lsp_diagnostic)
-        )
+        params: Interface::PublishDiagnosticsParams.new(uri: uri, diagnostics: [])
       )
     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
@@ -227,7 +123,7 @@ module RubyLsp
         params[:errorMessage] = error.message
       end
 
-      params[:uri] = uri if uri
+      params[:uri] = uri.sub(%r{.*://#{Dir.home}}, "~") if uri
       params
     end
   end

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/code_actions.rb

@@ -3,6 +3,8 @@
 
 module RubyLsp
   module Requests
+    # ![Code actions demo](../../misc/code_actions.gif)
+    #
     # The [code actions](https://microsoft.github.io/language-server-protocol/specification#textDocument_codeAction)
     # request informs the editor of RuboCop quick fixes that can be applied. These are accesible by hovering over a
     # specific diagnostic.

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -1,8 +1,12 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "ruby_lsp/requests/support/rubocop_diagnostics_runner"
+
 module RubyLsp
   module Requests
+    # ![Diagnostics demo](../../misc/diagnostics.gif)
+    #
     # The
     # [diagnostics](https://microsoft.github.io/language-server-protocol/specification#textDocument_publishDiagnostics)
     # request informs the editor of RuboCop offenses for a given file.
@@ -14,9 +18,16 @@ module RubyLsp
     # puts "Hello" # --> diagnostics: incorrect indentantion
     # end
     # ```
-    class Diagnostics < RuboCopRequest
+    class Diagnostics < BaseRequest
       extend T::Sig
 
+      sig { params(uri: String, document: Document).void }
+      def initialize(uri, document)
+        super(document)
+
+        @uri = uri
+      end
+
       sig do
         override.returns(
           T.any(
@@ -27,15 +38,9 @@ module RubyLsp
       end
       def run
         return syntax_error_diagnostics if @document.syntax_errors?
+        return [] unless defined?(Support::RuboCopDiagnosticsRunner)
 
-        super
-
-        @diagnostics
-      end
-
-      sig { params(_file: String, offenses: T::Array[RuboCop::Cop::Offense]).void }
-      def file_finished(_file, offenses)
-        @diagnostics = offenses.map { |offense| Support::RuboCopDiagnostic.new(offense, @uri) }
+        Support::RuboCopDiagnosticsRunner.instance.run(@uri, @document)
       end
 
       private

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -3,6 +3,8 @@
 
 module RubyLsp
   module Requests
+    # ![Document highlight demo](../../misc/document_highlight.gif)
+    #
     # The [document highlight](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentHighlight)
     # informs the editor all relevant elements of the currently pointed item for highlighting. For example, when
     # the cursor is on the `F` of the constant `FOO`, the editor should identify other occurences of `FOO`
@@ -23,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
@@ -51,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
+      sig { params(node: T.nilable(SyntaxTree::Node)).void }
+      def visit(node)
+        return if node.nil?
 
-        super
-      end
-
-      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|
@@ -89,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,59 @@
+# typed: strict
+# frozen_string_literal: true
+
+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
+
+      RUBY_ROOT = "RUBY_ROOT"
+
+      sig { params(document: Document).void }
+      def initialize(document)
+        super
+
+        @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://(?<path>.*):(?<line>\d+)$})
+        return unless match
+
+        file_path = if match[:path].start_with?(RUBY_ROOT)
+          match[:path].sub(RUBY_ROOT, RbConfig::CONFIG["rubylibdir"])
+        else
+          File.join(Bundler.bundle_path, "gems", match[:path])
+        end
+        return unless File.exist?(file_path)
+
+        target = "file://#{file_path}##{match[:line]}"
+
+        @links << LanguageServer::Protocol::Interface::DocumentLink.new(
+          range: range_from_syntax_tree_node(node),
+          target: target,
+          tooltip: "Jump to #{target.delete_prefix("file://")}"
+        )
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -3,6 +3,8 @@
 
 module RubyLsp
   module Requests
+    # ![Document symbol demo](../../misc/document_symbol.gif)
+    #
     # The [document
     # symbol](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentSymbol) request
     # informs the editor of all the important symbols, such as classes, variables, and methods, defined in a file. With