ruby-lsp 0.0.2 → 0.1.0

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -1,9 +1,33 @@
+# typed: strict
 # 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 = {
+      extend T::Sig
+
+      SYMBOL_KIND = T.let({
         file: 1,
         module: 2,
         namespace: 3,
@@ -30,33 +54,43 @@ module RubyLsp
         event: 24,
         operator: 25,
         typeparameter: 26,
-      }.freeze
+      }.freeze, T::Hash[Symbol, Integer])
 
-      ATTR_ACCESSORS = ["attr_reader", "attr_writer", "attr_accessor"].freeze
+      ATTR_ACCESSORS = T.let(["attr_reader", "attr_writer", "attr_accessor"].freeze, T::Array[String])
 
       class SymbolHierarchyRoot
+        extend T::Sig
+
+        sig { returns(T::Array[LanguageServer::Protocol::Interface::DocumentSymbol]) }
         attr_reader :children
 
+        sig { void }
         def initialize
-          @children = []
+          @children = T.let([], T::Array[LanguageServer::Protocol::Interface::DocumentSymbol])
         end
       end
 
+      sig { params(document: Document).void }
       def initialize(document)
         super
 
-        @root = SymbolHierarchyRoot.new
-        @stack = [@root]
+        @root = T.let(SymbolHierarchyRoot.new, SymbolHierarchyRoot)
+        @stack = T.let(
+          [@root],
+          T::Array[T.any(SymbolHierarchyRoot, LanguageServer::Protocol::Interface::DocumentSymbol)]
+        )
       end
 
+      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::DocumentSymbol], Object)) }
       def run
         visit(@document.tree)
         @root.children
       end
 
+      sig { params(node: SyntaxTree::ClassDeclaration).void }
       def visit_class(node)
         symbol = create_document_symbol(
-          name: node.constant.constant.value,
+          name: fully_qualified_name(node),
           kind: :class,
           range_node: node,
           selection_range_node: node.constant
@@ -67,6 +101,7 @@ module RubyLsp
         @stack.pop
       end
 
+      sig { params(node: SyntaxTree::Command).void }
       def visit_command(node)
         return unless ATTR_ACCESSORS.include?(node.message.value)
 
@@ -82,6 +117,7 @@ module RubyLsp
         end
       end
 
+      sig { params(node: SyntaxTree::ConstPathField).void }
       def visit_const_path_field(node)
         create_document_symbol(
           name: node.constant.value,
@@ -91,6 +127,7 @@ module RubyLsp
         )
       end
 
+      sig { params(node: SyntaxTree::Def).void }
       def visit_def(node)
         name = node.name.value
 
@@ -106,6 +143,7 @@ module RubyLsp
         @stack.pop
       end
 
+      sig { params(node: SyntaxTree::DefEndless).void }
       def visit_def_endless(node)
         name = node.name.value
 
@@ -121,6 +159,7 @@ module RubyLsp
         @stack.pop
       end
 
+      sig { params(node: SyntaxTree::Defs).void }
       def visit_defs(node)
         symbol = create_document_symbol(
           name: "self.#{node.name.value}",
@@ -134,9 +173,10 @@ module RubyLsp
         @stack.pop
       end
 
+      sig { params(node: SyntaxTree::ModuleDeclaration).void }
       def visit_module(node)
         symbol = create_document_symbol(
-          name: node.constant.constant.value,
+          name: fully_qualified_name(node),
           kind: :module,
           range_node: node,
           selection_range_node: node.constant
@@ -147,6 +187,7 @@ module RubyLsp
         @stack.pop
       end
 
+      sig { params(node: SyntaxTree::TopConstField).void }
       def visit_top_const_field(node)
         create_document_symbol(
           name: node.constant.value,
@@ -156,6 +197,7 @@ module RubyLsp
         )
       end
 
+      sig { params(node: SyntaxTree::VarField).void }
       def visit_var_field(node)
         kind = case node.value
         when SyntaxTree::Const
@@ -176,6 +218,14 @@ module RubyLsp
 
       private
 
+      sig do
+        params(
+          name: String,
+          kind: Symbol,
+          range_node: SyntaxTree::Node,
+          selection_range_node: SyntaxTree::Node
+        ).returns(LanguageServer::Protocol::Interface::DocumentSymbol)
+      end
       def create_document_symbol(name:, kind:, range_node:, selection_range_node:)
         symbol = LanguageServer::Protocol::Interface::DocumentSymbol.new(
           name: name,
@@ -185,19 +235,28 @@ module RubyLsp
           children: [],
         )
 
-        @stack.last.children << symbol
+        T.must(@stack.last).children << symbol
 
         symbol
       end
 
-      def range_from_syntax_tree_node(node)
-        loc = node.location
+      sig { params(node: T.any(SyntaxTree::ClassDeclaration, SyntaxTree::ModuleDeclaration)).returns(String) }
+      def fully_qualified_name(node)
+        constant = T.let(node.constant, SyntaxTree::Node)
+        name = +node.constant.constant.value
 
-        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),
-        )
+        while constant.is_a?(SyntaxTree::ConstPathRef)
+          constant = constant.parent
+
+          case constant
+          when SyntaxTree::ConstPathRef
+            name.prepend("#{constant.constant.value}::")
+          when SyntaxTree::VarRef
+            name.prepend("#{constant.value.value}::")
+          end
+        end
+
+        name
       end
     end
   end

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -1,9 +1,21 @@
+# typed: strict
 # 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 = [
+      extend T::Sig
+
+      SIMPLE_FOLDABLES = T.let([
         SyntaxTree::ArrayLiteral,
         SyntaxTree::BraceBlock,
         SyntaxTree::Case,
@@ -20,24 +32,37 @@ module RubyLsp
         SyntaxTree::Unless,
         SyntaxTree::Until,
         SyntaxTree::While,
-      ].freeze
+      ].freeze, T::Array[T.class_of(SyntaxTree::Node)])
 
-      NODES_WITH_STATEMENTS = [
+      NODES_WITH_STATEMENTS = T.let([
         SyntaxTree::Else,
         SyntaxTree::Elsif,
         SyntaxTree::Ensure,
         SyntaxTree::In,
         SyntaxTree::Rescue,
         SyntaxTree::When,
-      ].freeze
+      ].freeze, T::Array[T.class_of(SyntaxTree::Node)])
+
+      StatementNode = T.type_alias do
+        T.any(
+          SyntaxTree::Else,
+          SyntaxTree::Elsif,
+          SyntaxTree::Ensure,
+          SyntaxTree::In,
+          SyntaxTree::Rescue,
+          SyntaxTree::When,
+        )
+      end
 
+      sig { params(document: Document).void }
       def initialize(document)
         super
 
-        @ranges = []
-        @partial_range = nil
+        @ranges = T.let([], T::Array[LanguageServer::Protocol::Interface::FoldingRange])
+        @partial_range = T.let(nil, T.nilable(PartialRange))
       end
 
+      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::FoldingRange], Object)) }
       def run
         visit(@document.tree)
         emit_partial_range
@@ -46,14 +71,15 @@ module RubyLsp
 
       private
 
+      sig { params(node: T.nilable(SyntaxTree::Node)).void }
       def visit(node)
         return unless handle_partial_range(node)
 
         case node
         when *SIMPLE_FOLDABLES
-          add_node_range(node)
+          add_node_range(T.must(node))
         when *NODES_WITH_STATEMENTS
-          add_statements_range(node, node.statements)
+          add_statements_range(T.must(node), T.cast(node, StatementNode).statements)
         when SyntaxTree::Begin
           add_statements_range(node, node.bodystmt.statements)
         when SyntaxTree::Call, SyntaxTree::CommandCall
@@ -70,27 +96,38 @@ module RubyLsp
       end
 
       class PartialRange
-        attr_reader :kind, :end_line
+        extend T::Sig
 
+        sig { returns(String) }
+        attr_reader :kind
+
+        sig { returns(Integer) }
+        attr_reader :end_line
+
+        sig { params(node: SyntaxTree::Node, kind: String).returns(PartialRange) }
         def self.from(node, kind)
           new(node.location.start_line - 1, node.location.end_line - 1, kind)
         end
 
+        sig { params(start_line: Integer, end_line: Integer, kind: String).void }
         def initialize(start_line, end_line, kind)
           @start_line = start_line
           @end_line = end_line
           @kind = kind
         end
 
+        sig { params(node: SyntaxTree::Node).returns(PartialRange) }
         def extend_to(node)
           @end_line = node.location.end_line - 1
           self
         end
 
+        sig { params(node: SyntaxTree::Node).returns(T::Boolean) }
         def new_section?(node)
           node.is_a?(SyntaxTree::Comment) && @end_line + 1 != node.location.start_line - 1
         end
 
+        sig { returns(LanguageServer::Protocol::Interface::FoldingRange) }
         def to_range
           LanguageServer::Protocol::Interface::FoldingRange.new(
             start_line: @start_line,
@@ -100,6 +137,7 @@ module RubyLsp
         end
       end
 
+      sig { params(node: T.nilable(SyntaxTree::Node)).returns(T::Boolean) }
       def handle_partial_range(node)
         kind = partial_range_kind(node)
 
@@ -108,18 +146,20 @@ module RubyLsp
           return true
         end
 
+        target_node = T.must(node)
         @partial_range = if @partial_range.nil?
-          PartialRange.from(node, kind)
-        elsif @partial_range.kind != kind || @partial_range.new_section?(node)
+          PartialRange.from(target_node, kind)
+        elsif @partial_range.kind != kind || @partial_range.new_section?(target_node)
           emit_partial_range
-          PartialRange.from(node, kind)
+          PartialRange.from(target_node, kind)
         else
-          @partial_range.extend_to(node)
+          @partial_range.extend_to(target_node)
         end
 
         false
       end
 
+      sig { params(node: T.nilable(SyntaxTree::Node)).returns(T.nilable(String)) }
       def partial_range_kind(node)
         case node
         when SyntaxTree::Comment
@@ -131,6 +171,7 @@ module RubyLsp
         end
       end
 
+      sig { void }
       def emit_partial_range
         return if @partial_range.nil?
 
@@ -138,8 +179,9 @@ module RubyLsp
         @partial_range = nil
       end
 
+      sig { params(node: T.any(SyntaxTree::Call, SyntaxTree::CommandCall)).void }
       def add_call_range(node)
-        receiver = node.receiver
+        receiver = T.let(node.receiver, SyntaxTree::Node)
         loop do
           case receiver
           when SyntaxTree::Call
@@ -158,6 +200,7 @@ module RubyLsp
         visit(node.arguments)
       end
 
+      sig { params(node: T.any(SyntaxTree::Def, SyntaxTree::Defs)).void }
       def add_def_range(node)
         params_location = node.params.location
 
@@ -170,25 +213,26 @@ module RubyLsp
         visit(node.bodystmt.statements)
       end
 
+      sig { params(node: SyntaxTree::Node, statements: SyntaxTree::Statements).void }
       def add_statements_range(node, statements)
         add_lines_range(node.location.start_line, statements.location.end_line) unless statements.empty?
       end
 
+      sig { params(node: SyntaxTree::StringConcat).void }
       def add_string_concat(node)
-        left = node.left
+        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
 
+      sig { params(node: SyntaxTree::Node).void }
       def add_node_range(node)
-        add_location_range(node.location)
-      end
-
-      def add_location_range(location)
+        location = node.location
         add_lines_range(location.start_line, location.end_line)
       end
 
+      sig { params(start_line: Integer, end_line: Integer).void }
       def add_lines_range(start_line, end_line)
         return if start_line >= end_line
 

data/lib/ruby_lsp/requests/formatting.rb

@@ -1,15 +1,31 @@
+# typed: strict
 # 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 + ["--auto-correct"]).freeze
+      extend T::Sig
 
+      RUBOCOP_FLAGS = T.let((COMMON_RUBOCOP_FLAGS + ["--auto-correct"]).freeze, T::Array[String])
+
+      sig { params(uri: String, document: Document).void }
       def initialize(uri, document)
         super
-        @formatted_text = nil
+        @formatted_text = T.let(nil, T.nilable(String))
       end
 
+      sig { override.returns(T.nilable(T.all(T::Array[LanguageServer::Protocol::Interface::TextEdit], Object))) }
       def run
         super
 
@@ -32,6 +48,7 @@ module RubyLsp
 
       private
 
+      sig { returns(T::Array[String]) }
       def rubocop_flags
         RUBOCOP_FLAGS
       end

data/lib/ruby_lsp/requests/rubocop_request.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 require "rubocop"
@@ -5,23 +6,33 @@ require "cgi"
 
 module RubyLsp
   module Requests
+    # :nodoc:
     class RuboCopRequest < RuboCop::Runner
-      COMMON_RUBOCOP_FLAGS = [
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      COMMON_RUBOCOP_FLAGS = T.let([
         "--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
+      ].freeze, T::Array[String])
 
-      attr_reader :file, :text
+      sig { returns(String) }
+      attr_reader :file
 
-      def self.run(uri, document)
-        new(uri, document).run
-      end
+      sig { returns(String) }
+      attr_reader :text
 
+      sig { params(uri: String, document: Document).void }
       def initialize(uri, document)
-        @file = CGI.unescape(URI.parse(uri).path)
-        @text = document.source
+        @file = T.let(CGI.unescape(URI.parse(uri).path), String)
+        @document = document
+        @text = T.let(document.source, String)
         @uri = uri
+        @options = T.let({}, T::Hash[Symbol, T.untyped])
+        @diagnostics = T.let([], T::Array[Support::RuboCopDiagnostic])
 
         super(
           ::RuboCop::Options.new.parse(rubocop_flags).first,
@@ -29,6 +40,7 @@ module RubyLsp
         )
       end
 
+      sig { overridable.returns(Object) }
       def run
         # We communicate with Rubocop via stdin
         @options[:stdin] = text
@@ -39,6 +51,7 @@ module RubyLsp
 
       private
 
+      sig { returns(T::Array[String]) }
       def rubocop_flags
         COMMON_RUBOCOP_FLAGS
       end

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -0,0 +1,114 @@
+# typed: strict
+# 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
+      extend T::Sig
+
+      NODES_THAT_CAN_BE_PARENTS = T.let([
+        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, T::Array[T.class_of(SyntaxTree::Node)])
+
+      sig { params(document: Document).void }
+      def initialize(document)
+        super(document)
+
+        @ranges = T.let([], T::Array[Support::SelectionRange])
+        @stack = T.let([], T::Array[Support::SelectionRange])
+      end
+
+      sig { override.returns(T.all(T::Array[Support::SelectionRange], Object)) }
+      def run
+        visit(@document.tree)
+        @ranges.reverse!
+      end
+
+      private
+
+      sig { params(node: T.nilable(SyntaxTree::Node)).void }
+      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
+
+      sig do
+        params(
+          location: SyntaxTree::Location,
+          parent: T.nilable(Support::SelectionRange)
+        ).returns(Support::SelectionRange)
+      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