ruby-lsp 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25bad06533efa8072f0d501520e7429220be622d06a9061eb02171e1d515a498
-  data.tar.gz: dc8cc9436d3b57b362661ba36b8f02b90495287386f94ac5b20916ce5e6025bf
+  metadata.gz: 58ed87185da0a5d1da74b10f1525f1ca1341f1001f3a4cbdf2b086dd93750ad9
+  data.tar.gz: 1210f736e4cd8450cbe1e1d796dbd22a889c244c6ea5902bc6082f3791064ddc
 SHA512:
-  metadata.gz: b8ae688533a36c018cfbca467f7db2b54d121787cff48b7fd56723c03790df34c99a2ace3a0770ee6e3971b5ac1aa5e559b9264d1466ba93556f3d9ec051abaa
-  data.tar.gz: 1db946d571c62209b40fc4aef7048ea55f39c446bf87ff638d44aefcbdf2e8abdfad79c60ec5e9f0c3dc1fdda78f867582e4f58b56c861941197651bd286e6b3
+  metadata.gz: a1ed47a3e4d53dbf5250beaa98b3095c89099e67829f2ecac3149b34ecc87ae579c67ed6cd67035ee9930c0fffa0db6c0d4fdc3c3398520196005b180f28ea6f
+  data.tar.gz: 18d07a7c5426fa8cfad11cfab44dbabf05fd3a1352f1bf9272b04fb35c78f0bb0b4860dd4b7bbfda89efb9cfa99fc3ef77fbb679ff2b21bbd4cffb3c53a14bd5

data/.github/workflows/ci.yml

@@ -4,7 +4,7 @@ on: [push, pull_request]
 
 jobs:
   build:
-    runs-on: self-hosted
+    runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
@@ -17,6 +17,8 @@ jobs:
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
+      - name: Check if documentation is up to date
+        run: bundle exec rake check_docs
       - name: Lint Ruby files
         run: bin/rubocop
       - name: Run tests

data/.github/workflows/publish_docs.yml

@@ -0,0 +1,32 @@
+name: Publish docs
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    name: Publish documentation website
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.1.1
+          bundler-cache: true
+
+      - name: Configure git
+        run: |
+          git config user.name github-actions
+          git config user.email github-actions@github.com
+
+      - name: Generate documentation
+        run: bundle exec rake yard
+
+      - name: Commit to gh-pages
+        run: |
+          git add docs
+          git commit -m "Publish website $(git log --format=format:%h -1)"
+          git push --force origin main:gh-pages

data/Gemfile

@@ -8,6 +8,7 @@ gem "debug", "~> 1.5"
 gem "minitest", "~> 5.15"
 gem "minitest-reporters", "~> 1.5"
 gem "rake", "~> 13.0"
-gem "rubocop-shopify", "~> 2.5"
+gem "rubocop-shopify", "~> 2.6"
 gem "rubocop-minitest", "~> 0.19.1"
 gem "rubocop-rake", "~> 0.6.0"
+gem "yard", "~> 0.9"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ruby-lsp (0.0.2)
+    ruby-lsp (0.0.3)
       language_server-protocol
       rubocop (>= 1.0)
       syntax_tree (>= 2.3)
@@ -28,32 +28,37 @@ GEM
     parallel (1.22.1)
     parser (3.1.2.0)
       ast (~> 2.4.1)
+    prettier_print (0.1.0)
     rainbow (3.1.1)
     rake (13.0.6)
-    regexp_parser (2.3.1)
+    regexp_parser (2.4.0)
     reline (0.3.1)
       io-console (~> 0.5)
     rexml (3.2.5)
-    rubocop (1.28.1)
+    rubocop (1.29.1)
       parallel (~> 1.10)
       parser (>= 3.1.0.0)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
-      rexml
+      rexml (>= 3.2.5, < 4.0)
       rubocop-ast (>= 1.17.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.17.0)
+    rubocop-ast (1.18.0)
       parser (>= 3.1.1.0)
     rubocop-minitest (0.19.1)
       rubocop (>= 0.90, < 2.0)
     rubocop-rake (0.6.0)
       rubocop (~> 1.0)
-    rubocop-shopify (2.5.0)
-      rubocop (~> 1.25)
+    rubocop-shopify (2.6.0)
+      rubocop (~> 1.29)
     ruby-progressbar (1.11.0)
-    syntax_tree (2.3.1)
+    syntax_tree (2.7.1)
+      prettier_print
     unicode-display_width (2.1.0)
+    webrick (1.7.0)
+    yard (0.9.27)
+      webrick (~> 1.7.0)
 
 PLATFORMS
   arm64-darwin-21
@@ -66,8 +71,9 @@ DEPENDENCIES
   rake (~> 13.0)
   rubocop-minitest (~> 0.19.1)
   rubocop-rake (~> 0.6.0)
-  rubocop-shopify (~> 2.5)
+  rubocop-shopify (~> 2.6)
   ruby-lsp!
+  yard (~> 0.9)
 
 BUNDLED WITH
    2.3.7

data/README.md

@@ -1,4 +1,21 @@
-# ruby-lsp
+![Build Status](https://github.com/Shopify/ruby-lsp/workflows/CI/badge.svg)
+
+# Ruby LSP
+
+This gem is an implementation of the language server protocol specification for Ruby, used to improve editor features.
+
+## Usage
+
+Install the gem. There's no need to require it, since the server is used as a standalone executable.
+
+```ruby
+group :development do
+  gem "ruby-lsp", require: false
+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.
 
 ## Contributing
 

data/Rakefile

@@ -2,6 +2,7 @@
 
 require "bundler/gem_tasks"
 require "rake/testtask"
+require "yard"
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
@@ -9,6 +10,10 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList["test/**/*_test.rb"]
 end
 
+YARD::Rake::YardocTask.new do |t|
+  t.options = ["--markup", "markdown", "--output-dir", "docs"]
+end
+
 require "rubocop/rake_task"
 
 RuboCop::RakeTask.new

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/exe/ruby-lsp

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "syntax_tree"
+require "ruby-lsp"
 require "ruby_lsp/cli"
 
 RubyLsp::Cli.start(ARGV)

data/lib/ruby-lsp.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
 
 module RubyLsp
+  VERSION = File.read(File.expand_path("../VERSION", __dir__)).strip
 end

data/lib/ruby_lsp/cli.rb

@@ -12,13 +12,15 @@ module RubyLsp
       handler.config do
         on("initialize") do |request|
           store.clear
-          respond_with_capabilities(request.dig(:params, :initializationOptions).fetch(:enabledFeatures, []))
+          initialization_options = request.dig(:params, :initializationOptions)
+
+          configure_options(initialization_options)
+          respond_with_capabilities(initialization_options.fetch(:enabledFeatures, []))
         end
 
         on("textDocument/didChange") do |request|
           uri = request.dig(:params, :textDocument, :uri)
-          text = request.dig(:params, :contentChanges, 0, :text)
-          store.set(uri, text)
+          store.push_edits(uri, request.dig(:params, :contentChanges))
 
           send_diagnostics(uri)
           nil
@@ -48,6 +50,13 @@ module RubyLsp
           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

data/lib/ruby_lsp/document.rb

@@ -1,14 +1,17 @@
 # frozen_string_literal: true
 
+require "strscan"
+
 module RubyLsp
   class Document
-    attr_reader :tree, :parser, :source
+    attr_reader :tree, :source, :syntax_error_edits
 
     def initialize(source)
-      @source = source
-      @parser = SyntaxTree::Parser.new(source)
-      @tree = @parser.parse
+      @tree = SyntaxTree.parse(source)
       @cache = {}
+      @syntax_error_edits = []
+      @source = source
+      @parsable_source = source.dup
     end
 
     def ==(other)
@@ -23,5 +26,65 @@ module RubyLsp
       @cache[request_name] = result
       result
     end
+
+    def push_edits(edits)
+      # Apply the edits on the real source
+      edits.each { |edit| apply_edit(@source, edit[:range], edit[:text]) }
+
+      @cache.clear
+      @tree = SyntaxTree.parse(@source)
+      @syntax_error_edits.clear
+      @parsable_source = @source.dup
+      nil
+    rescue SyntaxTree::Parser::ParseError
+      update_parsable_source(edits)
+    end
+
+    def syntax_errors?
+      @syntax_error_edits.any?
+    end
+
+    private
+
+    def update_parsable_source(edits)
+      # If the new edits caused a syntax error, make all edits blank spaces and line breaks to adjust the line and
+      # column numbers. This is attempt to make the document parsable while partial edits are being applied
+      edits.each do |edit|
+        @syntax_error_edits << edit
+        next if edit[:text].empty? # skip deletions, since they may have caused the syntax error
+
+        apply_edit(@parsable_source, edit[:range], edit[:text].gsub(/[^\r\n]/, " "))
+      end
+
+      @tree = SyntaxTree.parse(@parsable_source)
+    rescue SyntaxTree::Parser::ParseError
+      # If we can't parse the source even after emptying the edits, then just fallback to the previous source
+    end
+
+    def apply_edit(source, range, text)
+      scanner = Scanner.new(source)
+      start_position = scanner.find_position(range[:start])
+      end_position = scanner.find_position(range[:end])
+
+      source[start_position...end_position] = text
+    end
+
+    class Scanner
+      def initialize(source)
+        @source = source
+        @scanner = StringScanner.new(source)
+        @current_line = 0
+      end
+
+      def find_position(position)
+        # Move the string scanner counting line breaks until we reach the right line
+        until @current_line == position[:line]
+          @scanner.scan_until(/\R/)
+          @current_line += 1
+        end
+
+        @scanner.pos + position[:character]
+      end
+    end
   end
 end

data/lib/ruby_lsp/handler.rb

@@ -2,9 +2,15 @@
 
 require "ruby_lsp/requests"
 require "ruby_lsp/store"
+require "benchmark"
 
 module RubyLsp
   class Handler
+    IGNORED_FOR_TELEMETRY = [
+      "initialized",
+      "$/cancelRequest",
+    ].freeze
+
     attr_reader :store
 
     Interface = LanguageServer::Protocol::Interface
@@ -21,7 +27,7 @@ module RubyLsp
     def start
       $stderr.puts "Starting Ruby LSP..."
       @reader.read do |request|
-        handle(request)
+        with_telemetry(request) { handle(request) }
       end
     end
 
@@ -76,9 +82,10 @@ module RubyLsp
       Interface::InitializeResult.new(
         capabilities: Interface::ServerCapabilities.new(
           text_document_sync: Interface::TextDocumentSyncOptions.new(
-            change: Constant::TextDocumentSyncKind::FULL,
+            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,
@@ -100,9 +107,25 @@ module RubyLsp
       end
     end
 
+    def respond_with_selection_ranges(uri, positions)
+      ranges = store.cache_fetch(uri, :selection_ranges) do |document|
+        Requests::SelectionRanges.run(document)
+      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
+
     def respond_with_semantic_highlighting(uri)
       store.cache_fetch(uri, :semantic_highlighting) do |document|
-        Requests::SemanticHighlighting.run(document)
+        Requests::SemanticHighlighting.new(document, encoder: Requests::Support::SemanticTokenEncoder.new).run
       end
     end
 
@@ -129,5 +152,30 @@ module RubyLsp
         Requests::CodeActions.run(uri, document, range)
       end
     end
+
+    def configure_options(initialization_options)
+      @telemetry_enabled = initialization_options.fetch(:telemetryEnabled, false)
+    end
+
+    def with_telemetry(request)
+      return yield unless @telemetry_enabled && !IGNORED_FOR_TELEMETRY.include?(request[:method])
+
+      result = nil
+      request_time = Benchmark.realtime do
+        result = yield
+      end
+
+      params = {
+        request: request[:method],
+        requestTime: request_time,
+        lspVersion: RubyLsp::VERSION,
+      }
+
+      uri = request.dig(:params, :textDocument, :uri)
+      params[:uri] = uri if uri
+
+      @writer.write(method: "telemetry/event", params: params)
+      result
+    end
   end
 end

data/lib/ruby_lsp/requests/base_request.rb

@@ -2,6 +2,7 @@
 
 module RubyLsp
   module Requests
+    # :nodoc:
     class BaseRequest < SyntaxTree::Visitor
       def self.run(document)
         new(document).run

data/lib/ruby_lsp/requests/code_actions.rb

@@ -2,6 +2,17 @@
 
 module RubyLsp
   module Requests
+    # 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.
+    #
+    # # Example
+    #
+    # ```ruby
+    # def say_hello
+    # puts "Hello" # --> code action: quick fix indentation
+    # end
+    # ```
     class CodeActions
       def self.run(uri, document, range)
         new(uri, document, range).run
@@ -16,7 +27,7 @@ module RubyLsp
       def run
         diagnostics = Diagnostics.run(@uri, @document)
         corrections = diagnostics.select { |diagnostic| diagnostic.correctable? && diagnostic.in_range?(@range) }
-        return if corrections.empty?
+        return [] if corrections.empty?
 
         corrections.map!(&:to_lsp_code_action)
       end

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -2,95 +2,34 @@
 
 module RubyLsp
   module Requests
+    # The
+    # [diagnostics](https://microsoft.github.io/language-server-protocol/specification#textDocument_publishDiagnostics)
+    # request informs the editor of RuboCop offenses for a given file.
+    #
+    # # Example
+    #
+    # ```ruby
+    # def say_hello
+    # puts "Hello" # --> diagnostics: incorrect indentantion
+    # end
+    # ```
     class Diagnostics < RuboCopRequest
-      RUBOCOP_TO_LSP_SEVERITY = {
-        convention: LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION,
-        info: LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION,
-        refactor: LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION,
-        warning: LanguageServer::Protocol::Constant::DiagnosticSeverity::WARNING,
-        error: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
-        fatal: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
-      }.freeze
-
       def run
+        return syntax_error_diagnostics if @document.syntax_errors?
+
         super
 
         @diagnostics
       end
 
       def file_finished(_file, offenses)
-        @diagnostics = offenses.map { |offense| Diagnostic.new(offense, @uri) }
+        @diagnostics = offenses.map { |offense| Support::RuboCopDiagnostic.new(offense, @uri) }
       end
 
-      class Diagnostic
-        attr_reader :replacements
-
-        def initialize(offense, uri)
-          @offense = offense
-          @uri = uri
-          @replacements = offense.correctable? ? offense_replacements : []
-        end
-
-        def correctable?
-          @offense.correctable?
-        end
-
-        def in_range?(range)
-          range.cover?(@offense.line - 1)
-        end
-
-        def to_lsp_code_action
-          LanguageServer::Protocol::Interface::CodeAction.new(
-            title: "Autocorrect #{@offense.cop_name}",
-            kind: LanguageServer::Protocol::Constant::CodeActionKind::QUICK_FIX,
-            edit: LanguageServer::Protocol::Interface::WorkspaceEdit.new(
-              document_changes: [
-                LanguageServer::Protocol::Interface::TextDocumentEdit.new(
-                  text_document: LanguageServer::Protocol::Interface::OptionalVersionedTextDocumentIdentifier.new(
-                    uri: @uri,
-                    version: nil
-                  ),
-                  edits: @replacements
-                ),
-              ]
-            ),
-            is_preferred: true,
-          )
-        end
-
-        def to_lsp_diagnostic
-          LanguageServer::Protocol::Interface::Diagnostic.new(
-            message: @offense.message,
-            source: "RuboCop",
-            code: @offense.cop_name,
-            severity: RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name],
-            range: LanguageServer::Protocol::Interface::Range.new(
-              start: LanguageServer::Protocol::Interface::Position.new(
-                line: @offense.line - 1,
-                character: @offense.column
-              ),
-              end: LanguageServer::Protocol::Interface::Position.new(
-                line: @offense.last_line - 1,
-                character: @offense.last_column
-              )
-            )
-          )
-        end
-
-        private
+      private
 
-        def offense_replacements
-          @offense.corrector.as_replacements.map do |range, replacement|
-            LanguageServer::Protocol::Interface::TextEdit.new(
-              range: LanguageServer::Protocol::Interface::Range.new(
-                start: LanguageServer::Protocol::Interface::Position.new(line: range.line - 1, character: range.column),
-                end: LanguageServer::Protocol::Interface::Position.new(line: range.last_line - 1,
-                  character: range.last_column)
-              ),
-              new_text: replacement
-            )
-          end
-        end
+      def syntax_error_diagnostics
+        @document.syntax_error_edits.map { |e| Support::SyntaxErrorDiagnostic.new(e) }
       end
     end
   end

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -2,6 +2,27 @@
 
 module RubyLsp
   module Requests
+    # 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
+    # this information, the editor can populate breadcrumbs, file outline and allow for fuzzy symbol searches.
+    #
+    # In VS Code, fuzzy symbol search can be accessed by opened the command palette and inserting an `@` symbol.
+    #
+    # # Example
+    #
+    # ```ruby
+    # class Person # --> document symbol: class
+    #   attr_reader :age # --> document symbol: field
+    #
+    #   def initialize
+    #     @age = 0 # --> document symbol: variable
+    #   end
+    #
+    #   def age # --> document symbol: method
+    #   end
+    # end
+    # ```
     class DocumentSymbol < BaseRequest
       SYMBOL_KIND = {
         file: 1,

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -2,6 +2,15 @@
 
 module RubyLsp
   module Requests
+    # The [folding ranges](https://microsoft.github.io/language-server-protocol/specification#textDocument_foldingRange)
+    # request informs the editor of the ranges where code can be folded.
+    #
+    # # Example
+    # ```ruby
+    # def say_hello # <-- folding range start
+    #   puts "Hello"
+    # end # <-- folding range end
+    # ```
     class FoldingRanges < BaseRequest
       SIMPLE_FOLDABLES = [
         SyntaxTree::ArrayLiteral,

data/lib/ruby_lsp/requests/formatting.rb

@@ -2,6 +2,17 @@
 
 module RubyLsp
   module Requests
+    # The [formatting](https://microsoft.github.io/language-server-protocol/specification#textDocument_formatting)
+    # request uses RuboCop to fix auto-correctable offenses in the document. This requires enabling format on save and
+    # registering the ruby-lsp as the Ruby formatter.
+    #
+    # # Example
+    #
+    # ```ruby
+    # def say_hello
+    # puts "Hello" # --> formatting: fixes the indentation on save
+    # end
+    # ```
     class Formatting < RuboCopRequest
       RUBOCOP_FLAGS = (COMMON_RUBOCOP_FLAGS + ["--auto-correct"]).freeze
 

data/lib/ruby_lsp/requests/rubocop_request.rb

@@ -5,6 +5,7 @@ require "cgi"
 
 module RubyLsp
   module Requests
+    # :nodoc:
     class RuboCopRequest < RuboCop::Runner
       COMMON_RUBOCOP_FLAGS = [
         "--stderr", # Print any output to stderr so that our stdout does not get polluted
@@ -20,6 +21,7 @@ module RubyLsp
 
       def initialize(uri, document)
         @file = CGI.unescape(URI.parse(uri).path)
+        @document = document
         @text = document.source
         @uri = uri
 

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # The [selection ranges](https://microsoft.github.io/language-server-protocol/specification#textDocument_selectionRange)
+    # request informs the editor of ranges that the user may want to select based on the location(s)
+    # of their cursor(s).
+    #
+    # Trigger this request with: Ctrl + Shift + -> or Ctrl + Shift + <-
+    #
+    # # Example
+    #
+    # ```ruby
+    # def foo # --> The next selection range encompasses the entire method definition.
+    #   puts "Hello, world!" # --> Cursor is on this line
+    # end
+    # ```
+    class SelectionRanges < BaseRequest
+      NODES_THAT_CAN_BE_PARENTS = [
+        SyntaxTree::Assign,
+        SyntaxTree::ArrayLiteral,
+        SyntaxTree::Begin,
+        SyntaxTree::BraceBlock,
+        SyntaxTree::Call,
+        SyntaxTree::Case,
+        SyntaxTree::ClassDeclaration,
+        SyntaxTree::Command,
+        SyntaxTree::Def,
+        SyntaxTree::Defs,
+        SyntaxTree::DoBlock,
+        SyntaxTree::Elsif,
+        SyntaxTree::Else,
+        SyntaxTree::EmbDoc,
+        SyntaxTree::Ensure,
+        SyntaxTree::FCall,
+        SyntaxTree::For,
+        SyntaxTree::HashLiteral,
+        SyntaxTree::Heredoc,
+        SyntaxTree::HeredocBeg,
+        SyntaxTree::HshPtn,
+        SyntaxTree::If,
+        SyntaxTree::In,
+        SyntaxTree::Lambda,
+        SyntaxTree::MethodAddBlock,
+        SyntaxTree::ModuleDeclaration,
+        SyntaxTree::Params,
+        SyntaxTree::Rescue,
+        SyntaxTree::RescueEx,
+        SyntaxTree::StringConcat,
+        SyntaxTree::StringLiteral,
+        SyntaxTree::Unless,
+        SyntaxTree::Until,
+        SyntaxTree::VCall,
+        SyntaxTree::When,
+        SyntaxTree::While,
+      ].freeze
+
+      def initialize(document)
+        super(document)
+
+        @ranges = []
+        @stack = []
+      end
+
+      def run
+        visit(@document.tree)
+        @ranges.reverse!
+      end
+
+      private
+
+      def visit(node)
+        return if node.nil?
+
+        range = create_selection_range(node.location, @stack.last)
+
+        @ranges << range
+        return if node.child_nodes.empty?
+
+        @stack << range if NODES_THAT_CAN_BE_PARENTS.include?(node.class)
+        visit_all(node.child_nodes)
+        @stack.pop if NODES_THAT_CAN_BE_PARENTS.include?(node.class)
+      end
+
+      def create_selection_range(location, parent = nil)
+        RubyLsp::Requests::Support::SelectionRange.new(
+          range: LanguageServer::Protocol::Interface::Range.new(
+            start: LanguageServer::Protocol::Interface::Position.new(
+              line: location.start_line - 1,
+              character: location.start_column,
+            ),
+            end: LanguageServer::Protocol::Interface::Position.new(
+              line: location.end_line - 1,
+              character: location.end_column,
+            ),
+          ),
+          parent: parent
+        )
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -2,6 +2,19 @@
 
 module RubyLsp
   module Requests
+    # The [semantic
+    # highlighting](https://microsoft.github.io/language-server-protocol/specification#textDocument_semanticTokens)
+    # request informs the editor of the correct token types to provide consistent and accurate highlighting for themes.
+    #
+    # # Example
+    #
+    # ```ruby
+    # def foo
+    #   var = 1 # --> semantic highlighting: local variable
+    #   some_invocation # --> semantic highlighting: method invocation
+    #   var # --> semantic highlighting: local variable
+    # end
+    # ```
     class SemanticHighlighting < BaseRequest
       TOKEN_TYPES = [
         :variable,
@@ -9,18 +22,21 @@ module RubyLsp
       ].freeze
       TOKEN_MODIFIERS = [].freeze
 
-      def initialize(document)
-        super
+      SemanticToken = Struct.new(:location, :length, :type, :modifier)
 
+      def initialize(document, encoder: nil)
+        super(document)
+
+        @encoder = encoder
         @tokens = []
         @tree = document.tree
-        @current_row = 0
-        @current_column = 0
       end
 
       def run
         visit(@tree)
-        LanguageServer::Protocol::Interface::SemanticTokens.new(data: @tokens)
+        return @tokens unless @encoder
+
+        @encoder.encode(@tokens)
       end
 
       def visit_m_assign(node)
@@ -73,44 +89,10 @@ module RubyLsp
         add_token(node.value.location, :method)
       end
 
-      def add_token(location, classification)
+      def add_token(location, type)
         length = location.end_char - location.start_char
-
-        compute_delta(location) do |delta_line, delta_column|
-          @tokens.push(delta_line, delta_column, length, TOKEN_TYPES.index(classification), 0)
-        end
-      end
-
-      # The delta array is computed according to the LSP specification:
-      # > The protocol for the token format relative uses relative
-      # > positions, because most tokens remain stable relative to
-      # > each other when edits are made in a file. This simplifies
-      # > the computation of a delta if a server supports it. So each
-      # > token is represented using 5 integers.
-
-      # For more information on how each number is calculated, read:
-      # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_semanticTokens
-      def compute_delta(location)
-        row = location.start_line - 1
-        column = location.start_column
-
-        if row < @current_row
-          raise InvalidTokenRowError, "Invalid token row detected: " \
-            "Ensure tokens are added in the expected order."
-        end
-
-        delta_line = row - @current_row
-
-        delta_column = column
-        delta_column -= @current_column if delta_line == 0
-
-        yield delta_line, delta_column
-
-        @current_row = row
-        @current_column = column
+        @tokens.push(SemanticToken.new(location, length, TOKEN_TYPES.index(type), 0))
       end
-
-      class InvalidTokenRowError < StandardError; end
     end
   end
 end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      class RuboCopDiagnostic
+        RUBOCOP_TO_LSP_SEVERITY = {
+          convention: LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION,
+          info: LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION,
+          refactor: LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION,
+          warning: LanguageServer::Protocol::Constant::DiagnosticSeverity::WARNING,
+          error: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
+          fatal: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
+        }.freeze
+
+        attr_reader :replacements
+
+        def initialize(offense, uri)
+          @offense = offense
+          @uri = uri
+          @replacements = offense.correctable? ? offense_replacements : []
+        end
+
+        def correctable?
+          @offense.correctable?
+        end
+
+        def in_range?(range)
+          range.cover?(@offense.line - 1)
+        end
+
+        def to_lsp_code_action
+          LanguageServer::Protocol::Interface::CodeAction.new(
+            title: "Autocorrect #{@offense.cop_name}",
+            kind: LanguageServer::Protocol::Constant::CodeActionKind::QUICK_FIX,
+            edit: LanguageServer::Protocol::Interface::WorkspaceEdit.new(
+              document_changes: [
+                LanguageServer::Protocol::Interface::TextDocumentEdit.new(
+                  text_document: LanguageServer::Protocol::Interface::OptionalVersionedTextDocumentIdentifier.new(
+                    uri: @uri,
+                    version: nil
+                  ),
+                  edits: @replacements
+                ),
+              ]
+            ),
+            is_preferred: true,
+          )
+        end
+
+        def to_lsp_diagnostic
+          LanguageServer::Protocol::Interface::Diagnostic.new(
+            message: @offense.message,
+            source: "RuboCop",
+            code: @offense.cop_name,
+            severity: RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name],
+            range: LanguageServer::Protocol::Interface::Range.new(
+              start: LanguageServer::Protocol::Interface::Position.new(
+                line: @offense.line - 1,
+                character: @offense.column
+              ),
+              end: LanguageServer::Protocol::Interface::Position.new(
+                line: @offense.last_line - 1,
+                character: @offense.last_column
+              )
+            )
+          )
+        end
+
+        private
+
+        def offense_replacements
+          @offense.corrector.as_replacements.map do |range, replacement|
+            LanguageServer::Protocol::Interface::TextEdit.new(
+              range: LanguageServer::Protocol::Interface::Range.new(
+                start: LanguageServer::Protocol::Interface::Position.new(line: range.line - 1, character: range.column),
+                end: LanguageServer::Protocol::Interface::Position.new(line: range.last_line - 1,
+                  character: range.last_column)
+              ),
+              new_text: replacement
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      class SelectionRange < LanguageServer::Protocol::Interface::SelectionRange
+        def cover?(position)
+          line_range = (range.start.line..range.end.line)
+          character_range = (range.start.character..range.end.character)
+
+          line_range.cover?(position[:line]) && character_range.cover?(position[:character])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      class SemanticTokenEncoder
+        def initialize
+          @current_row = 0
+          @current_column = 0
+        end
+
+        def encode(tokens)
+          delta = tokens
+            .sort_by do |token|
+              [token.location.start_line, token.location.start_column]
+            end
+            .flat_map do |token|
+              compute_delta(token)
+            end
+
+          LanguageServer::Protocol::Interface::SemanticTokens.new(data: delta)
+        end
+
+        # The delta array is computed according to the LSP specification:
+        # > The protocol for the token format relative uses relative
+        # > positions, because most tokens remain stable relative to
+        # > each other when edits are made in a file. This simplifies
+        # > the computation of a delta if a server supports it. So each
+        # > token is represented using 5 integers.
+
+        # For more information on how each number is calculated, read:
+        # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_semanticTokens
+        def compute_delta(token)
+          row = token.location.start_line - 1
+          column = token.location.start_column
+          delta_line = row - @current_row
+
+          delta_column = column
+          delta_column -= @current_column if delta_line == 0
+
+          [delta_line, delta_column, token.length, token.type, token.modifier]
+        ensure
+          @current_row = row
+          @current_column = column
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      class SyntaxErrorDiagnostic
+        def initialize(edit)
+          @edit = edit
+        end
+
+        def correctable?
+          false
+        end
+
+        def to_lsp_diagnostic
+          LanguageServer::Protocol::Interface::Diagnostic.new(
+            message: "Syntax error",
+            source: "SyntaxTree",
+            severity: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
+            range: @edit[:range]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests.rb

@@ -5,10 +5,18 @@ module RubyLsp
     autoload :BaseRequest, "ruby_lsp/requests/base_request"
     autoload :DocumentSymbol, "ruby_lsp/requests/document_symbol"
     autoload :FoldingRanges, "ruby_lsp/requests/folding_ranges"
+    autoload :SelectionRanges, "ruby_lsp/requests/selection_ranges"
     autoload :SemanticHighlighting, "ruby_lsp/requests/semantic_highlighting"
     autoload :RuboCopRequest, "ruby_lsp/requests/rubocop_request"
     autoload :Formatting, "ruby_lsp/requests/formatting"
     autoload :Diagnostics, "ruby_lsp/requests/diagnostics"
     autoload :CodeActions, "ruby_lsp/requests/code_actions"
+
+    module Support
+      autoload :RuboCopDiagnostic, "ruby_lsp/requests/support/rubocop_diagnostic"
+      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"
+    end
   end
 end

data/lib/ruby_lsp/store.rb

@@ -24,6 +24,10 @@ module RubyLsp
       # Do not update the store if there are syntax errors
     end
 
+    def push_edits(uri, edits)
+      @state[uri].push_edits(edits)
+    end
+
     def clear
       @state.clear
     end

data/rakelib/check_docs.rake

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+desc "Check if all LSP requests are documented"
+task :check_docs do
+  require "language_server-protocol"
+  require "syntax_tree"
+  require "logger"
+  require "ruby_lsp/requests/base_request"
+  require "ruby_lsp/requests/rubocop_request"
+
+  Dir["#{Dir.pwd}/lib/ruby_lsp/requests/*.rb"].each do |file|
+    require(file)
+    YARD.parse(file, [], Logger::Severity::FATAL)
+  end
+
+  spec_matcher = %r{\(https://microsoft.github.io/language-server-protocol/specification#.*\)}
+  error_messages = RubyLsp::Requests.constants.each_with_object(Hash.new { |h, k| h[k] = [] }) do |request, errors|
+    full_name = "RubyLsp::Requests::#{request}"
+    docs = YARD::Registry.at(full_name).docstring
+    next if /:nodoc:/.match?(docs)
+
+    if docs.empty?
+      errors[full_name] << "Missing documentation for request handler class"
+    elsif !spec_matcher.match?(docs)
+      errors[full_name] << <<~MESSAGE
+        Documentation for request handler classes must link to the official LSP specification.
+
+        For example, if your request handles text document hover, you should add a link to
+        https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_hover.
+      MESSAGE
+    elsif !/# Example/.match?(docs)
+      errors[full_name] << <<~MESSAGE
+        Documentation for request handler class must contain an example.
+
+        = Example
+            def my_method # <-- something happens here
+            end
+      MESSAGE
+    end
+  end
+
+  formatted_errors = error_messages.map { |name, errors| "#{name}: #{errors.join(", ")}" }
+
+  if error_messages.any?
+    puts <<~MESSAGE
+      The following requests have invalid documentation:
+
+      #{formatted_errors.join("\n")}
+    MESSAGE
+
+    exit!
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-04-26 00:00:00.000000000 Z
+date: 2022-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -64,6 +64,7 @@ files:
 - ".github/probots.yml"
 - ".github/pull_request_template.md"
 - ".github/workflows/ci.yml"
+- ".github/workflows/publish_docs.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - ".vscode/extensions.json"
@@ -93,8 +94,14 @@ files:
 - lib/ruby_lsp/requests/folding_ranges.rb
 - lib/ruby_lsp/requests/formatting.rb
 - lib/ruby_lsp/requests/rubocop_request.rb
+- lib/ruby_lsp/requests/selection_ranges.rb
 - lib/ruby_lsp/requests/semantic_highlighting.rb
+- lib/ruby_lsp/requests/support/rubocop_diagnostic.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/store.rb
+- rakelib/check_docs.rake
 - ruby-lsp.gemspec
 - service.yml
 - shipit.production.yml