ruby-lsp 0.0.1 → 0.0.2

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    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
+        super
+
+        @diagnostics
+      end
+
+      def file_finished(_file, offenses)
+        @diagnostics = offenses.map { |offense| Diagnostic.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
+
+        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/document_symbol.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    class DocumentSymbol < BaseRequest
+      SYMBOL_KIND = {
+        file: 1,
+        module: 2,
+        namespace: 3,
+        package: 4,
+        class: 5,
+        method: 6,
+        property: 7,
+        field: 8,
+        constructor: 9,
+        enum: 10,
+        interface: 11,
+        function: 12,
+        variable: 13,
+        constant: 14,
+        string: 15,
+        number: 16,
+        boolean: 17,
+        array: 18,
+        object: 19,
+        key: 20,
+        null: 21,
+        enummember: 22,
+        struct: 23,
+        event: 24,
+        operator: 25,
+        typeparameter: 26,
+      }.freeze
+
+      ATTR_ACCESSORS = ["attr_reader", "attr_writer", "attr_accessor"].freeze
+
+      class SymbolHierarchyRoot
+        attr_reader :children
+
+        def initialize
+          @children = []
+        end
+      end
+
+      def initialize(document)
+        super
+
+        @root = SymbolHierarchyRoot.new
+        @stack = [@root]
+      end
+
+      def run
+        visit(@document.tree)
+        @root.children
+      end
+
+      def visit_class(node)
+        symbol = create_document_symbol(
+          name: node.constant.constant.value,
+          kind: :class,
+          range_node: node,
+          selection_range_node: node.constant
+        )
+
+        @stack << symbol
+        visit(node.bodystmt)
+        @stack.pop
+      end
+
+      def visit_command(node)
+        return unless ATTR_ACCESSORS.include?(node.message.value)
+
+        node.arguments.parts.each do |argument|
+          next unless argument.is_a?(SyntaxTree::SymbolLiteral)
+
+          create_document_symbol(
+            name: argument.value.value,
+            kind: :field,
+            range_node: argument,
+            selection_range_node: argument.value
+          )
+        end
+      end
+
+      def visit_const_path_field(node)
+        create_document_symbol(
+          name: node.constant.value,
+          kind: :constant,
+          range_node: node,
+          selection_range_node: node.constant
+        )
+      end
+
+      def visit_def(node)
+        name = node.name.value
+
+        symbol = create_document_symbol(
+          name: name,
+          kind: name == "initialize" ? :constructor : :method,
+          range_node: node,
+          selection_range_node: node.name
+        )
+
+        @stack << symbol
+        visit(node.bodystmt)
+        @stack.pop
+      end
+
+      def visit_def_endless(node)
+        name = node.name.value
+
+        symbol = create_document_symbol(
+          name: name,
+          kind: name == "initialize" ? :constructor : :method,
+          range_node: node,
+          selection_range_node: node.name
+        )
+
+        @stack << symbol
+        visit(node.statement)
+        @stack.pop
+      end
+
+      def visit_defs(node)
+        symbol = create_document_symbol(
+          name: "self.#{node.name.value}",
+          kind: :method,
+          range_node: node,
+          selection_range_node: node.name
+        )
+
+        @stack << symbol
+        visit(node.bodystmt)
+        @stack.pop
+      end
+
+      def visit_module(node)
+        symbol = create_document_symbol(
+          name: node.constant.constant.value,
+          kind: :module,
+          range_node: node,
+          selection_range_node: node.constant
+        )
+
+        @stack << symbol
+        visit(node.bodystmt)
+        @stack.pop
+      end
+
+      def visit_top_const_field(node)
+        create_document_symbol(
+          name: node.constant.value,
+          kind: :constant,
+          range_node: node,
+          selection_range_node: node.constant
+        )
+      end
+
+      def visit_var_field(node)
+        kind = case node.value
+        when SyntaxTree::Const
+          :constant
+        when SyntaxTree::CVar, SyntaxTree::IVar
+          :variable
+        else
+          return
+        end
+
+        create_document_symbol(
+          name: node.value.value,
+          kind: kind,
+          range_node: node,
+          selection_range_node: node.value
+        )
+      end
+
+      private
+
+      def create_document_symbol(name:, kind:, range_node:, selection_range_node:)
+        symbol = LanguageServer::Protocol::Interface::DocumentSymbol.new(
+          name: name,
+          kind: SYMBOL_KIND[kind],
+          range: range_from_syntax_tree_node(range_node),
+          selection_range: range_from_syntax_tree_node(selection_range_node),
+          children: [],
+        )
+
+        @stack.last.children << symbol
+
+        symbol
+      end
+
+      def range_from_syntax_tree_node(node)
+        loc = node.location
+
+        LanguageServer::Protocol::Interface::Range.new(
+          start: LanguageServer::Protocol::Interface::Position.new(line: loc.start_line - 1,
+            character: loc.start_column),
+          end: LanguageServer::Protocol::Interface::Position.new(line: loc.end_line - 1, character: loc.end_column),
+        )
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    class FoldingRanges < BaseRequest
+      SIMPLE_FOLDABLES = [
+        SyntaxTree::ArrayLiteral,
+        SyntaxTree::BraceBlock,
+        SyntaxTree::Case,
+        SyntaxTree::ClassDeclaration,
+        SyntaxTree::Command,
+        SyntaxTree::DoBlock,
+        SyntaxTree::FCall,
+        SyntaxTree::For,
+        SyntaxTree::HashLiteral,
+        SyntaxTree::Heredoc,
+        SyntaxTree::If,
+        SyntaxTree::ModuleDeclaration,
+        SyntaxTree::SClass,
+        SyntaxTree::Unless,
+        SyntaxTree::Until,
+        SyntaxTree::While,
+      ].freeze
+
+      NODES_WITH_STATEMENTS = [
+        SyntaxTree::Else,
+        SyntaxTree::Elsif,
+        SyntaxTree::Ensure,
+        SyntaxTree::In,
+        SyntaxTree::Rescue,
+        SyntaxTree::When,
+      ].freeze
+
+      def initialize(document)
+        super
+
+        @ranges = []
+        @partial_range = nil
+      end
+
+      def run
+        visit(@document.tree)
+        emit_partial_range
+        @ranges
+      end
+
+      private
+
+      def visit(node)
+        return unless handle_partial_range(node)
+
+        case node
+        when *SIMPLE_FOLDABLES
+          add_node_range(node)
+        when *NODES_WITH_STATEMENTS
+          add_statements_range(node, node.statements)
+        when SyntaxTree::Begin
+          add_statements_range(node, node.bodystmt.statements)
+        when SyntaxTree::Call, SyntaxTree::CommandCall
+          add_call_range(node)
+          return
+        when SyntaxTree::Def, SyntaxTree::Defs
+          add_def_range(node)
+        when SyntaxTree::StringConcat
+          add_string_concat(node)
+          return
+        end
+
+        super
+      end
+
+      class PartialRange
+        attr_reader :kind, :end_line
+
+        def self.from(node, kind)
+          new(node.location.start_line - 1, node.location.end_line - 1, kind)
+        end
+
+        def initialize(start_line, end_line, kind)
+          @start_line = start_line
+          @end_line = end_line
+          @kind = kind
+        end
+
+        def extend_to(node)
+          @end_line = node.location.end_line - 1
+          self
+        end
+
+        def new_section?(node)
+          node.is_a?(SyntaxTree::Comment) && @end_line + 1 != node.location.start_line - 1
+        end
+
+        def to_range
+          LanguageServer::Protocol::Interface::FoldingRange.new(
+            start_line: @start_line,
+            end_line: @end_line,
+            kind: @kind
+          )
+        end
+      end
+
+      def handle_partial_range(node)
+        kind = partial_range_kind(node)
+
+        if kind.nil?
+          emit_partial_range
+          return true
+        end
+
+        @partial_range = if @partial_range.nil?
+          PartialRange.from(node, kind)
+        elsif @partial_range.kind != kind || @partial_range.new_section?(node)
+          emit_partial_range
+          PartialRange.from(node, kind)
+        else
+          @partial_range.extend_to(node)
+        end
+
+        false
+      end
+
+      def partial_range_kind(node)
+        case node
+        when SyntaxTree::Comment
+          "comment"
+        when SyntaxTree::Command
+          if node.message.value == "require" || node.message.value == "require_relative"
+            "imports"
+          end
+        end
+      end
+
+      def emit_partial_range
+        return if @partial_range.nil?
+
+        @ranges << @partial_range.to_range
+        @partial_range = nil
+      end
+
+      def add_call_range(node)
+        receiver = node.receiver
+        loop do
+          case receiver
+          when SyntaxTree::Call
+            visit(receiver.arguments)
+            receiver = receiver.receiver
+          when SyntaxTree::MethodAddBlock
+            visit(receiver.block)
+            receiver = receiver.call.receiver
+          else
+            break
+          end
+        end
+
+        add_lines_range(receiver.location.start_line, node.location.end_line)
+
+        visit(node.arguments)
+      end
+
+      def add_def_range(node)
+        params_location = node.params.location
+
+        if params_location.start_line < params_location.end_line
+          add_lines_range(params_location.end_line, node.location.end_line)
+        else
+          add_node_range(node)
+        end
+
+        visit(node.bodystmt.statements)
+      end
+
+      def add_statements_range(node, statements)
+        add_lines_range(node.location.start_line, statements.location.end_line) unless statements.empty?
+      end
+
+      def add_string_concat(node)
+        left = node.left
+        left = left.left while left.is_a?(SyntaxTree::StringConcat)
+
+        add_lines_range(left.location.start_line, node.right.location.end_line)
+      end
+
+      def add_node_range(node)
+        add_location_range(node.location)
+      end
+
+      def add_location_range(location)
+        add_lines_range(location.start_line, location.end_line)
+      end
+
+      def add_lines_range(start_line, end_line)
+        return if start_line >= end_line
+
+        @ranges << LanguageServer::Protocol::Interface::FoldingRange.new(
+          start_line: start_line - 1,
+          end_line: end_line - 1,
+          kind: "region"
+        )
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/formatting.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    class Formatting < RuboCopRequest
+      RUBOCOP_FLAGS = (COMMON_RUBOCOP_FLAGS + ["--auto-correct"]).freeze
+
+      def initialize(uri, document)
+        super
+        @formatted_text = nil
+      end
+
+      def run
+        super
+
+        @formatted_text = @options[:stdin] # Rubocop applies the corrections on stdin
+        return unless @formatted_text
+
+        [
+          LanguageServer::Protocol::Interface::TextEdit.new(
+            range: LanguageServer::Protocol::Interface::Range.new(
+              start: LanguageServer::Protocol::Interface::Position.new(line: 0, character: 0),
+              end: LanguageServer::Protocol::Interface::Position.new(
+                line: text.size,
+                character: text.size
+              )
+            ),
+            new_text: @formatted_text
+          ),
+        ]
+      end
+
+      private
+
+      def rubocop_flags
+        RUBOCOP_FLAGS
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/rubocop_request.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "rubocop"
+require "cgi"
+
+module RubyLsp
+  module Requests
+    class RuboCopRequest < RuboCop::Runner
+      COMMON_RUBOCOP_FLAGS = [
+        "--stderr", # Print any output to stderr so that our stdout does not get polluted
+        "--format",
+        "RuboCop::Formatter::BaseFormatter", # Suppress any output by using the base formatter
+      ].freeze
+
+      attr_reader :file, :text
+
+      def self.run(uri, document)
+        new(uri, document).run
+      end
+
+      def initialize(uri, document)
+        @file = CGI.unescape(URI.parse(uri).path)
+        @text = document.source
+        @uri = uri
+
+        super(
+          ::RuboCop::Options.new.parse(rubocop_flags).first,
+          ::RuboCop::ConfigStore.new
+        )
+      end
+
+      def run
+        # We communicate with Rubocop via stdin
+        @options[:stdin] = text
+
+        # Invoke the actual run method with just this file in `paths`
+        super([file])
+      end
+
+      private
+
+      def rubocop_flags
+        COMMON_RUBOCOP_FLAGS
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    class SemanticHighlighting < BaseRequest
+      TOKEN_TYPES = [
+        :variable,
+        :method,
+      ].freeze
+      TOKEN_MODIFIERS = [].freeze
+
+      def initialize(document)
+        super
+
+        @tokens = []
+        @tree = document.tree
+        @current_row = 0
+        @current_column = 0
+      end
+
+      def run
+        visit(@tree)
+        LanguageServer::Protocol::Interface::SemanticTokens.new(data: @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, classification)
+        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
+      end
+
+      class InvalidTokenRowError < StandardError; end
+    end
+  end
+end