ruby-lsp 0.1.0 → 0.2.2

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -3,10 +3,13 @@
 
 module RubyLsp
   module Requests
+    # ![Folding ranges demo](../../misc/folding_ranges.gif)
+    #
     # 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.
+    # request informs the editor of the ranges where and how code can be folded.
     #
     # # Example
+    #
     # ```ruby
     # def say_hello # <-- folding range start
     #   puts "Hello"
@@ -32,12 +35,13 @@ module RubyLsp
         SyntaxTree::Unless,
         SyntaxTree::Until,
         SyntaxTree::While,
+        SyntaxTree::Else,
+        SyntaxTree::Ensure,
+        SyntaxTree::Begin,
       ].freeze, T::Array[T.class_of(SyntaxTree::Node)])
 
       NODES_WITH_STATEMENTS = T.let([
-        SyntaxTree::Else,
         SyntaxTree::Elsif,
-        SyntaxTree::Ensure,
         SyntaxTree::In,
         SyntaxTree::Rescue,
         SyntaxTree::When,
@@ -45,9 +49,7 @@ module RubyLsp
 
       StatementNode = T.type_alias do
         T.any(
-          SyntaxTree::Else,
           SyntaxTree::Elsif,
-          SyntaxTree::Ensure,
           SyntaxTree::In,
           SyntaxTree::Rescue,
           SyntaxTree::When,
@@ -77,11 +79,10 @@ module RubyLsp
 
         case node
         when *SIMPLE_FOLDABLES
-          add_node_range(T.must(node))
+          location = T.must(node).location
+          add_lines_range(location.start_line, location.end_line - 1)
         when *NODES_WITH_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
           add_call_range(node)
           return
@@ -135,6 +136,11 @@ module RubyLsp
             kind: @kind
           )
         end
+
+        sig { returns(T::Boolean) }
+        def multiline?
+          @end_line > @start_line
+        end
       end
 
       sig { params(node: T.nilable(SyntaxTree::Node)).returns(T::Boolean) }
@@ -175,7 +181,7 @@ module RubyLsp
       def emit_partial_range
         return if @partial_range.nil?
 
-        @ranges << @partial_range.to_range
+        @ranges << @partial_range.to_range if @partial_range.multiline?
         @partial_range = nil
       end
 
@@ -189,13 +195,17 @@ module RubyLsp
             receiver = receiver.receiver
           when SyntaxTree::MethodAddBlock
             visit(receiver.block)
-            receiver = receiver.call.receiver
+            receiver = receiver.call
+
+            if receiver.is_a?(SyntaxTree::Call) || receiver.is_a?(SyntaxTree::CommandCall)
+              receiver = receiver.receiver
+            end
           else
             break
           end
         end
 
-        add_lines_range(receiver.location.start_line, node.location.end_line)
+        add_lines_range(receiver.location.start_line, node.location.end_line - 1)
 
         visit(node.arguments)
       end
@@ -205,9 +215,10 @@ module RubyLsp
         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)
+          add_lines_range(params_location.end_line, node.location.end_line - 1)
         else
-          add_node_range(node)
+          location = node.location
+          add_lines_range(location.start_line, location.end_line - 1)
         end
 
         visit(node.bodystmt.statements)
@@ -215,7 +226,7 @@ module RubyLsp
 
       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?
+        add_lines_range(node.location.start_line, statements.body.last.location.end_line) unless statements.empty?
       end
 
       sig { params(node: SyntaxTree::StringConcat).void }
@@ -223,13 +234,7 @@ module RubyLsp
         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)
-        location = node.location
-        add_lines_range(location.start_line, location.end_line)
+        add_lines_range(left.location.start_line, node.right.location.end_line - 1)
       end
 
       sig { params(start_line: Integer, end_line: Integer).void }

data/lib/ruby_lsp/requests/formatting.rb

@@ -1,8 +1,12 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "ruby_lsp/requests/support/rubocop_formatting_runner"
+
 module RubyLsp
   module Requests
+    # ![Formatting symbol demo](../../misc/formatting.gif)
+    #
     # 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.
@@ -14,43 +18,44 @@ module RubyLsp
     # puts "Hello" # --> formatting: fixes the indentation on save
     # end
     # ```
-    class Formatting < RuboCopRequest
+    class Formatting < BaseRequest
       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 = T.let(nil, T.nilable(String))
+        super(document)
+
+        @uri = uri
       end
 
       sig { override.returns(T.nilable(T.all(T::Array[LanguageServer::Protocol::Interface::TextEdit], Object))) }
       def run
-        super
+        formatted_text = formatted_file
+        return unless formatted_text
 
-        @formatted_text = @options[:stdin] # Rubocop applies the corrections on stdin
-        return unless @formatted_text
+        size = @document.source.size
+        return if formatted_text.size == size && formatted_text == @document.source
 
         [
           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
-              )
+              end: LanguageServer::Protocol::Interface::Position.new(line: size, character: size)
             ),
-            new_text: @formatted_text
+            new_text: formatted_text
           ),
         ]
       end
 
       private
 
-      sig { returns(T::Array[String]) }
-      def rubocop_flags
-        RUBOCOP_FLAGS
+      sig { returns(T.nilable(String)) }
+      def formatted_file
+        if defined?(Support::RuboCopFormattingRunner)
+          Support::RuboCopFormattingRunner.instance.run(@uri, @document)
+        else
+          SyntaxTree.format(@document.source)
+        end
       end
     end
   end

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -3,6 +3,8 @@
 
 module RubyLsp
   module Requests
+    # ![Selection ranges demo](../../misc/selection_ranges.gif)
+    #
     # 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).

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -3,6 +3,8 @@
 
 module RubyLsp
   module Requests
+    # ![Semantic highlighting demo](../../misc/semantic_highlighting.gif)
+    #
     # 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.
@@ -19,11 +21,31 @@ module RubyLsp
     class SemanticHighlighting < BaseRequest
       extend T::Sig
 
-      TOKEN_TYPES = T.let([
-        :variable,
-        :method,
-        :namespace,
-      ].freeze, T::Array[Symbol])
+      TOKEN_TYPES = T.let({
+        namespace: 0,
+        type: 1,
+        class: 2,
+        enum: 3,
+        interface: 4,
+        struct: 5,
+        typeParameter: 6,
+        parameter: 7,
+        variable: 8,
+        property: 9,
+        enumMember: 10,
+        event: 11,
+        function: 12,
+        method: 13,
+        macro: 14,
+        keyword: 15,
+        modifier: 16,
+        comment: 17,
+        string: 18,
+        number: 19,
+        regexp: 20,
+        operator: 21,
+        decorator: 22,
+      }.freeze, T::Hash[Symbol, Integer])
 
       TOKEN_MODIFIERS = T.let({
         declaration: 0,
@@ -38,6 +60,14 @@ module RubyLsp
         default_library: 9,
       }.freeze, T::Hash[Symbol, Integer])
 
+      SPECIAL_RUBY_METHODS = T.let([
+        Module.instance_methods(false),
+        Kernel.instance_methods(false),
+        Kernel.methods(false),
+        Bundler::Dsl.instance_methods(false),
+        Module.private_instance_methods(false),
+      ].flatten.map(&:to_s), T::Array[String])
+
       class SemanticToken < T::Struct
         const :location, SyntaxTree::Location
         const :length, Integer
@@ -51,7 +81,8 @@ module RubyLsp
 
         @encoder = encoder
         @tokens = T.let([], T::Array[SemanticToken])
-        @tree = T.let(document.tree, SyntaxTree::Node)
+        @tree = T.let(T.must(document.tree), SyntaxTree::Node)
+        @special_methods = T.let(nil, T.nilable(T::Array[String]))
       end
 
       sig do
@@ -77,13 +108,16 @@ module RubyLsp
       sig { params(node: SyntaxTree::Call).void }
       def visit_call(node)
         visit(node.receiver)
-        add_token(node.message.location, :method)
+
+        message = node.message
+        add_token(message.location, :method) if message != :call
+
         visit(node.arguments)
       end
 
       sig { params(node: SyntaxTree::Command).void }
       def visit_command(node)
-        add_token(node.message.location, :method)
+        add_token(node.message.location, :method) unless special_method?(node.message.value)
         visit(node.arguments)
       end
 
@@ -125,7 +159,7 @@ module RubyLsp
 
       sig { params(node: SyntaxTree::FCall).void }
       def visit_fcall(node)
-        add_token(node.value.location, :method)
+        add_token(node.value.location, :method) unless special_method?(node.value.value)
         visit(node.arguments)
       end
 
@@ -144,6 +178,20 @@ module RubyLsp
         end
       end
 
+      sig { params(node: SyntaxTree::Params).void }
+      def visit_params(node)
+        node.keywords.each do |keyword,|
+          location = keyword.location
+          add_token(location_without_colon(location), :variable)
+        end
+
+        rest = node.keyword_rest
+        return if rest.nil? || rest.is_a?(SyntaxTree::ArgsForward)
+
+        name = rest.name
+        add_token(name.location, :variable) if name
+      end
+
       sig { params(node: SyntaxTree::VarField).void }
       def visit_var_field(node)
         case node.value
@@ -166,7 +214,7 @@ module RubyLsp
 
       sig { params(node: SyntaxTree::VCall).void }
       def visit_vcall(node)
-        add_token(node.value.location, :method)
+        add_token(node.value.location, :method) unless special_method?(node.value.value)
       end
 
       sig { params(location: SyntaxTree::Location, type: Symbol, modifiers: T::Array[Symbol]).void }
@@ -177,11 +225,37 @@ module RubyLsp
           SemanticToken.new(
             location: location,
             length: length,
-            type: T.must(TOKEN_TYPES.index(type)),
+            type: T.must(TOKEN_TYPES[type]),
             modifier: modifiers_indices
           )
         )
       end
+
+      private
+
+      # Exclude the ":" symbol at the end of a location
+      # We use it on keyword parameters to be consistent
+      # with the rest of the parameters
+      sig { params(location: T.untyped).returns(SyntaxTree::Location) }
+      def location_without_colon(location)
+        SyntaxTree::Location.new(
+          start_line: location.start_line,
+          start_column: location.start_column,
+          start_char: location.start_char,
+          end_char: location.end_char - 1,
+          end_column: location.end_column - 1,
+          end_line: location.end_line,
+        )
+      end
+
+      # Textmate provides highlighting for a subset
+      # of these special Ruby-specific methods.
+      # We want to utilize that highlighting, so we
+      # avoid making a semantic token for it.
+      sig { params(method_name: String).returns(T::Boolean) }
+      def special_method?(method_name)
+        SPECIAL_RUBY_METHODS.include?(method_name)
+      end
     end
   end
 end

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

@@ -0,0 +1,88 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      class HighlightTarget
+        extend T::Sig
+
+        READ = LanguageServer::Protocol::Constant::DocumentHighlightKind::READ
+        WRITE = LanguageServer::Protocol::Constant::DocumentHighlightKind::WRITE
+
+        class HighlightMatch < T::Struct
+          const :type, Integer
+          const :node, SyntaxTree::Node
+        end
+
+        sig { params(node: SyntaxTree::Node).void }
+        def initialize(node)
+          @node = node
+          @value = T.let(value(node), T.nilable(String))
+        end
+
+        sig { params(other: SyntaxTree::Node).returns(T.nilable(HighlightMatch)) }
+        def highlight_type(other)
+          matched_highlight(other) if other.is_a?(SyntaxTree::Params) || (@value && @value == value(other))
+        end
+
+        private
+
+        # Match the target type (where the cursor is positioned) with the `other` type (the node we're currently
+        # visiting)
+        sig { params(other: SyntaxTree::Node).returns(T.nilable(HighlightMatch)) }
+        def matched_highlight(other)
+          case @node
+          # Method definitions and invocations
+          when SyntaxTree::VCall, SyntaxTree::FCall, SyntaxTree::Call, SyntaxTree::Command,
+               SyntaxTree::CommandCall, SyntaxTree::Def, SyntaxTree::Defs, SyntaxTree::DefEndless
+            case other
+            when SyntaxTree::VCall, SyntaxTree::FCall, SyntaxTree::Call, SyntaxTree::Command, SyntaxTree::CommandCall
+              HighlightMatch.new(type: READ, node: other)
+            when SyntaxTree::Def, SyntaxTree::Defs, SyntaxTree::Defs
+              HighlightMatch.new(type: WRITE, node: other.name)
+            end
+          # Variables, parameters and constants
+          when SyntaxTree::GVar, SyntaxTree::IVar, SyntaxTree::Const, SyntaxTree::CVar, SyntaxTree::VarField,
+               SyntaxTree::VarRef, SyntaxTree::Ident
+            case other
+            when SyntaxTree::VarField
+              HighlightMatch.new(type: WRITE, node: other)
+            when SyntaxTree::VarRef
+              HighlightMatch.new(type: READ, node: other)
+            when SyntaxTree::ClassDeclaration, SyntaxTree::ModuleDeclaration
+              HighlightMatch.new(type: WRITE, node: other.constant)
+            when SyntaxTree::ConstPathRef
+              HighlightMatch.new(type: READ, node: other.constant)
+            when SyntaxTree::Params
+              params = other.child_nodes.compact
+              match = params.find { |param| value(param) == @value }
+              HighlightMatch.new(type: WRITE, node: match) if match
+            end
+          end
+        end
+
+        sig { params(node: SyntaxTree::Node).returns(T.nilable(String)) }
+        def value(node)
+          case node
+          when SyntaxTree::ConstPathRef, SyntaxTree::ConstPathField, SyntaxTree::TopConstField
+            node.constant.value
+          when SyntaxTree::GVar, SyntaxTree::IVar, SyntaxTree::Const, SyntaxTree::CVar, SyntaxTree::Ident,
+               SyntaxTree::ArgsForward
+            node.value
+          when SyntaxTree::Field, SyntaxTree::Def, SyntaxTree::Defs, SyntaxTree::DefEndless, SyntaxTree::RestParam,
+               SyntaxTree::KwRestParam, SyntaxTree::BlockArg
+            node.name&.value
+          when SyntaxTree::VarField, SyntaxTree::VarRef, SyntaxTree::VCall, SyntaxTree::FCall
+            node.value&.value
+          when SyntaxTree::Call, SyntaxTree::Command, SyntaxTree::CommandCall
+            message = node.message
+            message != :call ? message.value : nil
+          when SyntaxTree::ClassDeclaration, SyntaxTree::ModuleDeclaration
+            node.constant.constant.value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -61,11 +61,18 @@ module RubyLsp
 
         sig { returns(LanguageServer::Protocol::Interface::Diagnostic) }
         def to_lsp_diagnostic
+          if @offense.correctable?
+            severity = RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name]
+            message = @offense.message
+          else
+            severity = LanguageServer::Protocol::Constant::DiagnosticSeverity::WARNING
+            message = "#{@offense.message}\n\nThis offense is not auto-correctable.\n"
+          end
           LanguageServer::Protocol::Interface::Diagnostic.new(
-            message: @offense.message,
+            message: message,
             source: "RuboCop",
             code: @offense.cop_name,
-            severity: RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name],
+            severity: severity,
             range: LanguageServer::Protocol::Interface::Range.new(
               start: LanguageServer::Protocol::Interface::Position.new(
                 line: @offense.line - 1,

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

@@ -0,0 +1,61 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "rubocop"
+rescue LoadError
+  return
+end
+
+require "cgi"
+require "singleton"
+
+module RubyLsp
+  module Requests
+    module Support
+      # :nodoc:
+      class RuboCopDiagnosticsRunner < RuboCop::Runner
+        extend T::Sig
+        include Singleton
+
+        sig { void }
+        def initialize
+          @options = T.let({}, T::Hash[Symbol, T.untyped])
+          @uri = T.let(nil, T.nilable(String))
+          @diagnostics = T.let([], T::Array[Support::RuboCopDiagnostic])
+
+          super(
+            ::RuboCop::Options.new.parse([
+              "--stderr", # Print any output to stderr so that our stdout does not get polluted
+              "--force-exclusion",
+              "--format",
+              "RuboCop::Formatter::BaseFormatter", # Suppress any output by using the base formatter
+            ]).first,
+            ::RuboCop::ConfigStore.new
+          )
+        end
+
+        sig { params(uri: String, document: Document).returns(T::Array[Support::RuboCopDiagnostic]) }
+        def run(uri, document)
+          @diagnostics.clear
+          @uri = uri
+
+          file = CGI.unescape(URI.parse(uri).path)
+          # We communicate with Rubocop via stdin
+          @options[:stdin] = document.source
+
+          # Invoke RuboCop with just this file in `paths`
+          super([file])
+          @diagnostics
+        end
+
+        private
+
+        sig { params(_file: String, offenses: T::Array[RuboCop::Cop::Offense]).void }
+        def file_finished(_file, offenses)
+          @diagnostics = offenses.map { |offense| Support::RuboCopDiagnostic.new(offense, T.must(@uri)) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "rubocop"
+rescue LoadError
+  return
+end
+
+require "cgi"
+require "singleton"
+
+module RubyLsp
+  module Requests
+    module Support
+      # :nodoc:
+      class RuboCopFormattingRunner < RuboCop::Runner
+        extend T::Sig
+        include Singleton
+
+        sig { void }
+        def initialize
+          @options = T.let({}, T::Hash[Symbol, T.untyped])
+
+          super(
+            ::RuboCop::Options.new.parse([
+              "--stderr", # Print any output to stderr so that our stdout does not get polluted
+              "--force-exclusion",
+              "--format",
+              "RuboCop::Formatter::BaseFormatter", # Suppress any output by using the base formatter
+              "-a", # --auto-correct
+            ]).first,
+            ::RuboCop::ConfigStore.new
+          )
+        end
+
+        sig { params(uri: String, document: Document).returns(T.nilable(String)) }
+        def run(uri, document)
+          file = CGI.unescape(URI.parse(uri).path)
+          # We communicate with Rubocop via stdin
+          @options[:stdin] = document.source
+
+          # Invoke RuboCop with just this file in `paths`
+          super([file])
+          @options[:stdin]
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests.rb

@@ -2,23 +2,36 @@
 # frozen_string_literal: true
 
 module RubyLsp
+  # Supported features
+  #
+  # - {RubyLsp::Requests::DocumentSymbol}
+  # - {RubyLsp::Requests::DocumentLink}
+  # - {RubyLsp::Requests::FoldingRanges}
+  # - {RubyLsp::Requests::SelectionRanges}
+  # - {RubyLsp::Requests::SemanticHighlighting}
+  # - {RubyLsp::Requests::Formatting}
+  # - {RubyLsp::Requests::Diagnostics}
+  # - {RubyLsp::Requests::CodeActions}
+  # - {RubyLsp::Requests::DocumentHighlight}
   module Requests
     autoload :BaseRequest, "ruby_lsp/requests/base_request"
     autoload :DocumentSymbol, "ruby_lsp/requests/document_symbol"
+    autoload :DocumentLink, "ruby_lsp/requests/document_link"
     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"
 
+    # :nodoc:
     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"
+      autoload :HighlightTarget, "ruby_lsp/requests/support/highlight_target"
     end
   end
 end