ruby-lsp 0.0.1 → 0.0.4

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -0,0 +1,112 @@
+# typed: true
+# frozen_string_literal: true
+
+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,
+        :method,
+      ].freeze
+
+      TOKEN_MODIFIERS = {
+        declaration: 0,
+        definition: 1,
+        readonly: 2,
+        static: 3,
+        deprecated: 4,
+        abstract: 5,
+        async: 6,
+        modification: 7,
+        documentation: 8,
+        default_library: 9,
+      }.freeze
+
+      SemanticToken = Struct.new(:location, :length, :type, :modifier)
+
+      def initialize(document, encoder: nil)
+        super(document)
+
+        @encoder = encoder
+        @tokens = []
+        @tree = document.tree
+      end
+
+      def run
+        visit(@tree)
+        return @tokens unless @encoder
+
+        @encoder.encode(@tokens)
+      end
+
+      def visit_m_assign(node)
+        node.target.parts.each do |var_ref|
+          add_token(var_ref.value.location, :variable)
+        end
+      end
+
+      def visit_var_field(node)
+        case node.value
+        when SyntaxTree::Ident
+          add_token(node.value.location, :variable)
+        end
+      end
+
+      def visit_var_ref(node)
+        case node.value
+        when SyntaxTree::Ident
+          add_token(node.value.location, :variable)
+        end
+      end
+
+      def visit_a_ref_field(node)
+        add_token(node.collection.value.location, :variable)
+      end
+
+      def visit_call(node)
+        visit(node.receiver)
+        add_token(node.message.location, :method)
+        visit(node.arguments)
+      end
+
+      def visit_command(node)
+        add_token(node.message.location, :method)
+        visit(node.arguments)
+      end
+
+      def visit_command_call(node)
+        visit(node.receiver)
+        add_token(node.message.location, :method)
+        visit(node.arguments)
+      end
+
+      def visit_fcall(node)
+        add_token(node.value.location, :method)
+        visit(node.arguments)
+      end
+
+      def visit_vcall(node)
+        add_token(node.value.location, :method)
+      end
+
+      def add_token(location, type, modifiers = [])
+        length = location.end_char - location.start_char
+        modifiers_indices = modifiers.filter_map { |modifier| TOKEN_MODIFIERS[modifier] }
+        @tokens.push(SemanticToken.new(location, length, TOKEN_TYPES.index(type), modifiers_indices))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# typed: true
+# 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,17 @@
+# typed: true
+# 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,60 @@
+# typed: true
+# 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, encode_modifiers(token.modifier)]
+        ensure
+          @current_row = row
+          @current_column = column
+        end
+
+        # Encode an array of modifiers to positions onto a bit flag
+        # For example, [:default_library] will be encoded as
+        # 0b1000000000, as :default_library is the 10th bit according
+        # to the token modifiers index map.
+        def encode_modifiers(modifiers)
+          modifiers.inject(0) do |encoded_modifiers, modifier|
+            encoded_modifiers | (1 << modifier)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# typed: true
+# 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

@@ -0,0 +1,24 @@
+# typed: true
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    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"
+    autoload :DocumentHighlight, "ruby_lsp/requests/document_highlight"
+
+    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

@@ -0,0 +1,59 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "cgi"
+require "uri"
+require "ruby_lsp/document"
+
+module RubyLsp
+  class Store
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @state = T.let({}, T::Hash[String, Document])
+    end
+
+    sig { params(uri: String).returns(Document) }
+    def get(uri)
+      document = @state[uri]
+      return document unless document.nil?
+
+      set(uri, File.binread(CGI.unescape(URI.parse(uri).path)))
+      T.must(@state[uri])
+    end
+
+    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
+    end
+
+    sig { params(uri: String, edits: T::Array[Document::EditShape]).void }
+    def push_edits(uri, edits)
+      T.must(@state[uri]).push_edits(edits)
+    end
+
+    sig { void }
+    def clear
+      @state.clear
+    end
+
+    sig { params(uri: String).void }
+    def delete(uri)
+      @state.delete(uri)
+    end
+
+    sig do
+      params(
+        uri: String,
+        request_name: Symbol,
+        block: T.proc.params(document: Document).returns(T.untyped)
+      ).returns(T.untyped)
+    end
+    def cache_fetch(uri, request_name, &block)
+      get(uri).cache_fetch(request_name, &block)
+    end
+  end
+end

data/rakelib/check_docs.rake

@@ -0,0 +1,56 @@
+# typed: false
+# 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 # rubocop:disable Sorbet/ConstantsFromStrings
+    .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

data/ruby-lsp.gemspec

@@ -10,6 +10,7 @@ Gem::Specification.new do |s|
   s.summary = "A simple language server for ruby"
   s.description = "A simple language server for ruby"
   s.homepage = "https://github.com/Shopify/ruby-lsp"
+  s.license = "MIT"
 
   s.files = Dir.chdir(File.expand_path(__dir__)) do
     %x(git ls-files -z).split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
@@ -18,5 +19,8 @@ Gem::Specification.new do |s|
   s.executables = s.files.grep(/\Aexe/) { |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency "language_server-protocol"
+  s.add_dependency("language_server-protocol")
+  s.add_dependency("rubocop", ">= 1.0")
+  s.add_dependency("sorbet-runtime")
+  s.add_dependency("syntax_tree", ">= 2.3")
 end

data/sorbet/config

@@ -0,0 +1,4 @@
+--dir
+.
+--ignore=vendor/
+--ignore=test/fixtures/

data/sorbet/rbi/.rubocop.yml

@@ -0,0 +1,8 @@
+inherit_gem:
+  rubocop-sorbet: config/rbi.yml
+
+Lint/EmptyFile:
+  Enabled: false
+
+Sorbet/TypeAliasName:
+  Enabled: false