ruby-lsp 0.0.1 → 0.0.4

data/lib/ruby_lsp/requests/document_symbol.rb

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

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -0,0 +1,213 @@
+# typed: true
+# frozen_string_literal: true
+
+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,
+        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 = T.let(node.receiver, SyntaxTree::Node)
+        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 = T.let(node.left, SyntaxTree::Node)
+        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,52 @@
+# typed: true
+# frozen_string_literal: true
+
+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 + ["--autocorrect"]).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,50 @@
+# typed: true
+# frozen_string_literal: true
+
+require "rubocop"
+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
+        "--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)
+        @document = document
+        @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/selection_ranges.rb

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