ruby-lsp 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f81baa8f09011e5130c955c4c5d2a33583379b0b073caee556719b874efc320e
-  data.tar.gz: 55a664f923d93bda9ddb06624303f889123496c672c46b31ea71c629cfa96a81
+  metadata.gz: d067270389ee6b02bb03fb6363e272b6808e7c3d27d77354442801d09a617149
+  data.tar.gz: 74e7cd206a790a8c139969f5167ab3d38686f78646c619488153fd8ab139892e
 SHA512:
-  metadata.gz: 8a872f34699bfaa4f955c714c4e49eed52e87b009afc0a642d0ad434956f6a14690188ad9c359cc7aadd53e96fbd0d5d320e00aa263265e1ce3d3e369e8bd124
-  data.tar.gz: 06444ea3e08b961445db6cb1a9093fc322b40ddf47daa00deb09a77f3b114014be8f525d7d391430b578b7916042bf345759d113c74e41a8ea51d65791abe69c
+  metadata.gz: 8d65637f892541a79fde71e3f523dfc37c887ec4892315ffe58b450718c8fa6e2a342036c394c28f5a94da0a1348948a104609881109c5621488b9d23a581bc1
+  data.tar.gz: 1d25dbac214c23c2af2bd991d4c57bdae9dce488ac886cc700d7ab10a7e3b4a0e72ddc2c1d4be459b332e9cdfac69588d42eac11ff78023d365e0d5ef6701f78

data/.rubocop.yml

@@ -37,3 +37,4 @@ Sorbet/StrictSigil:
   Exclude:
     - "**/*.rake"
     - "test/**/*.rb"
+    - "lib/ruby-lsp.rb"

data/CHANGELOG.md

@@ -6,6 +6,19 @@ Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how
 
 ## [Unreleased]
 
+## [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/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ruby-lsp (0.2.0)
+    ruby-lsp (0.2.1)
       language_server-protocol
       sorbet-runtime
       syntax_tree (>= 2.4)

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.2.1

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,109 +86,14 @@ 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
 
+      return if response.nil?
+
       @writer.write(
         method: "textDocument/publishDiagnostics",
         params: Interface::PublishDiagnosticsParams.new(
@@ -194,6 +101,8 @@ module RubyLsp
           diagnostics: response.map(&:to_lsp_diagnostic)
         )
       )
+    rescue RuboCop::ValidationError => e
+      show_message(Constant::MessageType::ERROR, "Error in RuboCop configuration file: #{e.message}")
     end
 
     sig { params(uri: String).void }
@@ -204,23 +113,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/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

@@ -78,7 +78,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
 
@@ -179,7 +179,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 }

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

@@ -0,0 +1,87 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      class HighlightTarget
+        extend T::Sig
+
+        READ = LanguageServer::Protocol::Constant::DocumentHighlightKind::READ
+        WRITE = LanguageServer::Protocol::Constant::DocumentHighlightKind::WRITE
+
+        class HighlightMatch < T::Struct
+          const :type, Integer
+          const :node, SyntaxTree::Node
+        end
+
+        sig { params(node: SyntaxTree::Node).void }
+        def initialize(node)
+          @node = node
+          @value = T.let(value(node), T.nilable(String))
+        end
+
+        sig { params(other: SyntaxTree::Node).returns(T.nilable(HighlightMatch)) }
+        def highlight_type(other)
+          matched_highlight(other) if other.is_a?(SyntaxTree::Params) || (@value && @value == value(other))
+        end
+
+        private
+
+        # Match the target type (where the cursor is positioned) with the `other` type (the node we're currently
+        # visiting)
+        sig { params(other: SyntaxTree::Node).returns(T.nilable(HighlightMatch)) }
+        def matched_highlight(other)
+          case @node
+          # Method definitions and invocations
+          when SyntaxTree::VCall, SyntaxTree::FCall, SyntaxTree::Call, SyntaxTree::Command,
+               SyntaxTree::CommandCall, SyntaxTree::Def, SyntaxTree::Defs, SyntaxTree::DefEndless
+            case other
+            when SyntaxTree::VCall, SyntaxTree::FCall, SyntaxTree::Call, SyntaxTree::Command, SyntaxTree::CommandCall
+              HighlightMatch.new(type: READ, node: other)
+            when SyntaxTree::Def, SyntaxTree::Defs, SyntaxTree::Defs
+              HighlightMatch.new(type: WRITE, node: other.name)
+            end
+          # Variables, parameters and constants
+          when SyntaxTree::GVar, SyntaxTree::IVar, SyntaxTree::Const, SyntaxTree::CVar, SyntaxTree::VarField,
+               SyntaxTree::VarRef, SyntaxTree::Ident
+            case other
+            when SyntaxTree::VarField
+              HighlightMatch.new(type: WRITE, node: other)
+            when SyntaxTree::VarRef
+              HighlightMatch.new(type: READ, node: other)
+            when SyntaxTree::ClassDeclaration, SyntaxTree::ModuleDeclaration
+              HighlightMatch.new(type: WRITE, node: other.constant)
+            when SyntaxTree::ConstPathRef
+              HighlightMatch.new(type: READ, node: other.constant)
+            when SyntaxTree::Params
+              params = other.child_nodes.compact
+              match = params.find { |param| value(param) == @value }
+              HighlightMatch.new(type: WRITE, node: match) if match
+            end
+          end
+        end
+
+        sig { params(node: SyntaxTree::Node).returns(T.nilable(String)) }
+        def value(node)
+          case node
+          when SyntaxTree::ConstPathRef, SyntaxTree::ConstPathField, SyntaxTree::TopConstField
+            node.constant.value
+          when SyntaxTree::GVar, SyntaxTree::IVar, SyntaxTree::Const, SyntaxTree::CVar, SyntaxTree::Ident,
+               SyntaxTree::ArgsForward
+            node.value
+          when SyntaxTree::Field, SyntaxTree::Def, SyntaxTree::Defs, SyntaxTree::DefEndless, SyntaxTree::RestParam,
+               SyntaxTree::KwRestParam, SyntaxTree::BlockArg
+            node.name&.value
+          when SyntaxTree::VarField, SyntaxTree::VarRef, SyntaxTree::VCall, SyntaxTree::FCall
+            node.value&.value
+          when SyntaxTree::Call, SyntaxTree::Command, SyntaxTree::CommandCall
+            node.message.value
+          when SyntaxTree::ClassDeclaration, SyntaxTree::ModuleDeclaration
+            node.constant.constant.value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests.rb

@@ -29,6 +29,7 @@ module RubyLsp
       autoload :SelectionRange, "ruby_lsp/requests/support/selection_range"
       autoload :SemanticTokenEncoder, "ruby_lsp/requests/support/semantic_token_encoder"
       autoload :SyntaxErrorDiagnostic, "ruby_lsp/requests/support/syntax_error_diagnostic"
+      autoload :HighlightTarget, "ruby_lsp/requests/support/highlight_target"
     end
   end
 end

data/lib/ruby_lsp/server.rb

@@ -0,0 +1,160 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "ruby_lsp/internal"
+
+module RubyLsp
+  Handler.start do
+    on("initialize") do |request|
+      store.clear
+      initialization_options = request.dig(:params, :initializationOptions)
+      enabled_features = initialization_options.fetch(:enabledFeatures, [])
+
+      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
+
+    on("textDocument/didChange") do |request|
+      uri = request.dig(:params, :textDocument, :uri)
+      store.push_edits(uri, request.dig(:params, :contentChanges))
+
+      send_diagnostics(uri)
+      Handler::VOID
+    end
+
+    on("textDocument/didOpen") do |request|
+      uri = request.dig(:params, :textDocument, :uri)
+      text = request.dig(:params, :textDocument, :text)
+      store.set(uri, text)
+
+      send_diagnostics(uri)
+      Handler::VOID
+    end
+
+    on("textDocument/didClose") do |request|
+      uri = request.dig(:params, :textDocument, :uri)
+      store.delete(uri)
+      clear_diagnostics(uri)
+
+      Handler::VOID
+    end
+
+    on("textDocument/documentSymbol") do |request|
+      store.cache_fetch(request.dig(:params, :textDocument, :uri), :document_symbol) do |document|
+        Requests::DocumentSymbol.new(document).run
+      end
+    end
+
+    on("textDocument/foldingRange") do |request|
+      store.cache_fetch(request.dig(:params, :textDocument, :uri), :folding_ranges) do |document|
+        Requests::FoldingRanges.new(document).run
+      end
+    end
+
+    on("textDocument/selectionRange") do |request|
+      uri = request.dig(:params, :textDocument, :uri)
+      positions = request.dig(:params, :positions)
+
+      ranges = store.cache_fetch(uri, :selection_ranges) do |document|
+        Requests::SelectionRanges.new(document).run
+      end
+
+      return if ranges.nil?
+
+      # 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
+
+    on("textDocument/semanticTokens/full") do |request|
+      store.cache_fetch(request.dig(:params, :textDocument, :uri), :semantic_highlighting) do |document|
+        T.cast(
+          Requests::SemanticHighlighting.new(
+            document,
+            encoder: Requests::Support::SemanticTokenEncoder.new
+          ).run,
+          LanguageServer::Protocol::Interface::SemanticTokens
+        )
+      end
+    end
+
+    on("textDocument/formatting") do |request|
+      uri = request.dig(:params, :textDocument, :uri)
+
+      Requests::Formatting.new(uri, store.get(uri)).run
+    end
+
+    on("textDocument/documentHighlight") do |request|
+      document = store.get(request.dig(:params, :textDocument, :uri))
+      return unless document.parsed?
+
+      Requests::DocumentHighlight.new(document, request.dig(:params, :position)).run
+    end
+
+    on("textDocument/codeAction") do |request|
+      uri = request.dig(:params, :textDocument, :uri)
+      range = request.dig(:params, :range)
+      start_line = range.dig(:start, :line)
+      end_line = range.dig(:end, :line)
+
+      store.cache_fetch(uri, :code_actions) do |document|
+        Requests::CodeActions.new(uri, document, start_line..end_line).run
+      end
+    end
+
+    on("shutdown") { shutdown }
+
+    on("exit") do
+      # We return zero if shutdown has already been received or one otherwise as per the recommendation in the spec
+      # https://microsoft.github.io/language-server-protocol/specification/#exit
+      status = store.empty? ? 0 : 1
+      exit(status)
+    end
+  end
+end

data/lib/ruby_lsp/store.rb

@@ -25,9 +25,8 @@ module RubyLsp
 
     sig { params(uri: String, content: String).void }
     def set(uri, content)
-      @state[uri] = Document.new(content)
-    rescue SyntaxTree::Parser::ParseError
-      # Do not update the store if there are syntax errors
+      document = Document.new(content)
+      @state[uri] = document
     end
 
     sig { params(uri: String, edits: T::Array[Document::EditShape]).void }
@@ -40,6 +39,11 @@ module RubyLsp
       @state.clear
     end
 
+    sig { returns(T::Boolean) }
+    def empty?
+      @state.empty?
+    end
+
     sig { params(uri: String).void }
     def delete(uri)
       @state.delete(uri)
@@ -51,10 +55,13 @@ module RubyLsp
           uri: String,
           request_name: Symbol,
           block: T.proc.params(document: Document).returns(T.type_parameter(:T))
-        ).returns(T.type_parameter(:T))
+        ).returns(T.nilable(T.type_parameter(:T)))
     end
     def cache_fetch(uri, request_name, &block)
-      get(uri).cache_fetch(request_name, &block)
+      document = get(uri)
+      return unless document.parsed?
+
+      document.cache_fetch(request_name, &block)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-07-07 00:00:00.000000000 Z
+date: 2022-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -85,7 +85,6 @@ files:
 - dev.yml
 - exe/ruby-lsp
 - lib/ruby-lsp.rb
-- lib/ruby_lsp/cli.rb
 - lib/ruby_lsp/document.rb
 - lib/ruby_lsp/handler.rb
 - lib/ruby_lsp/internal.rb
@@ -99,12 +98,14 @@ files:
 - lib/ruby_lsp/requests/formatting.rb
 - lib/ruby_lsp/requests/selection_ranges.rb
 - lib/ruby_lsp/requests/semantic_highlighting.rb
+- lib/ruby_lsp/requests/support/highlight_target.rb
 - lib/ruby_lsp/requests/support/rubocop_diagnostic.rb
 - lib/ruby_lsp/requests/support/rubocop_diagnostics_runner.rb
 - lib/ruby_lsp/requests/support/rubocop_formatting_runner.rb
 - lib/ruby_lsp/requests/support/selection_range.rb
 - lib/ruby_lsp/requests/support/semantic_token_encoder.rb
 - lib/ruby_lsp/requests/support/syntax_error_diagnostic.rb
+- lib/ruby_lsp/server.rb
 - lib/ruby_lsp/store.rb
 - rakelib/check_docs.rake
 - ruby-lsp.gemspec

data/lib/ruby_lsp/cli.rb

@@ -1,89 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "language_server-protocol"
-
-require_relative "handler"
-
-module RubyLsp
-  module Cli
-    extend T::Sig
-
-    sig { void }
-    def self.start
-      handler = RubyLsp::Handler.new
-
-      handler.config do
-        on("initialize") do |request|
-          store.clear
-          initialization_options = request.dig(:params, :initializationOptions)
-
-          respond_with_capabilities(initialization_options.fetch(:enabledFeatures, []))
-        end
-
-        on("textDocument/didChange") do |request|
-          uri = request.dig(:params, :textDocument, :uri)
-          store.push_edits(uri, request.dig(:params, :contentChanges))
-
-          send_diagnostics(uri)
-          RubyLsp::Handler::VOID
-        end
-
-        on("textDocument/didOpen") do |request|
-          uri = request.dig(:params, :textDocument, :uri)
-          text = request.dig(:params, :textDocument, :text)
-          store.set(uri, text)
-
-          send_diagnostics(uri)
-          RubyLsp::Handler::VOID
-        end
-
-        on("textDocument/didClose") do |request|
-          uri = request.dig(:params, :textDocument, :uri)
-          store.delete(uri)
-          clear_diagnostics(uri)
-
-          RubyLsp::Handler::VOID
-        end
-
-        on("textDocument/documentSymbol") do |request|
-          respond_with_document_symbol(request.dig(:params, :textDocument, :uri))
-        end
-
-        on("textDocument/foldingRange") do |request|
-          respond_with_folding_ranges(request.dig(:params, :textDocument, :uri))
-        end
-
-        on("textDocument/selectionRange") do |request|
-          respond_with_selection_ranges(
-            request.dig(:params, :textDocument, :uri),
-            request.dig(:params, :positions),
-          )
-        end
-
-        on("textDocument/semanticTokens/full") do |request|
-          respond_with_semantic_highlighting(request.dig(:params, :textDocument, :uri))
-        end
-
-        on("textDocument/formatting") do |request|
-          respond_with_formatting(request.dig(:params, :textDocument, :uri))
-        end
-
-        on("textDocument/documentHighlight") do |request|
-          respond_with_document_highlight(request.dig(:params, :textDocument, :uri), request.dig(:params, :position))
-        end
-
-        on("textDocument/codeAction") do |request|
-          range = request.dig(:params, :range)
-          start_line = range.dig(:start, :line)
-          end_line = range.dig(:end, :line)
-          respond_with_code_actions(request.dig(:params, :textDocument, :uri), (start_line..end_line))
-        end
-
-        on("shutdown") { shutdown }
-      end
-
-      handler.start
-    end
-  end
-end