ruby-lsp 0.17.4 → 0.17.13

data/lib/ruby_lsp/document.rb

@@ -3,6 +3,13 @@
 
 module RubyLsp
   class Document
+    class LanguageId < T::Enum
+      enums do
+        Ruby = new("ruby")
+        ERB = new("erb")
+      end
+    end
+
     extend T::Sig
     extend T::Helpers
 
@@ -34,21 +41,14 @@ module RubyLsp
       @parse_result = T.let(parse, Prism::ParseResult)
     end
 
-    sig { returns(Prism::ProgramNode) }
-    def tree
-      @parse_result.value
-    end
-
-    sig { returns(T::Array[Prism::Comment]) }
-    def comments
-      @parse_result.comments
-    end
-
     sig { params(other: Document).returns(T::Boolean) }
     def ==(other)
-      @source == other.source
+      self.class == other.class && uri == other.uri && @source == other.source
     end
 
+    sig { abstract.returns(LanguageId) }
+    def language_id; end
+
     # TODO: remove this method once all nonpositional requests have been migrated to the listener pattern
     sig do
       type_parameters(:T)
@@ -96,10 +96,8 @@ module RubyLsp
     sig { abstract.returns(Prism::ParseResult) }
     def parse; end
 
-    sig { returns(T::Boolean) }
-    def syntax_error?
-      @parse_result.failure?
-    end
+    sig { abstract.returns(T::Boolean) }
+    def syntax_error?; end
 
     sig { returns(Scanner) }
     def create_scanner
@@ -129,8 +127,18 @@ module RubyLsp
       parent = T.let(nil, T.nilable(Prism::Node))
       nesting_nodes = T.let(
         [],
-        T::Array[T.any(Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode, Prism::DefNode)],
+        T::Array[T.any(
+          Prism::ClassNode,
+          Prism::ModuleNode,
+          Prism::SingletonClassNode,
+          Prism::DefNode,
+          Prism::BlockNode,
+          Prism::LambdaNode,
+          Prism::ProgramNode,
+        )],
       )
+
+      nesting_nodes << node if node.is_a?(Prism::ProgramNode)
       call_node = T.let(nil, T.nilable(Prism::CallNode))
 
       until queue.empty?
@@ -160,11 +168,8 @@ module RubyLsp
         # Keep track of the nesting where we found the target. This is used to determine the fully qualified name of the
         # target when it is a constant
         case candidate
-        when Prism::ClassNode, Prism::ModuleNode
-          nesting_nodes << candidate
-        when Prism::SingletonClassNode
-          nesting_nodes << candidate
-        when Prism::DefNode
+        when Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode, Prism::DefNode, Prism::BlockNode,
+          Prism::LambdaNode
           nesting_nodes << candidate
         end
 
@@ -205,31 +210,7 @@ module RubyLsp
         end
       end
 
-      nesting = []
-      surrounding_method = T.let(nil, T.nilable(String))
-
-      nesting_nodes.each do |node|
-        case node
-        when Prism::ClassNode, Prism::ModuleNode
-          nesting << node.constant_path.slice
-        when Prism::SingletonClassNode
-          nesting << "<Class:#{nesting.last}>"
-        when Prism::DefNode
-          surrounding_method = node.name.to_s
-          next unless node.receiver.is_a?(Prism::SelfNode)
-
-          nesting << "<Class:#{nesting.last}>"
-        end
-      end
-
-      NodeContext.new(closest, parent, nesting, call_node, surrounding_method)
-    end
-
-    sig { returns(T::Boolean) }
-    def sorbet_sigil_is_true_or_higher
-      parse_result.magic_comments.any? do |comment|
-        comment.key == "typed" && ["true", "strict", "strong"].include?(comment.value)
-      end
+      NodeContext.new(closest, parent, nesting_nodes, call_node)
     end
 
     class Scanner

data/lib/ruby_lsp/erb_document.rb

@@ -0,0 +1,125 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  class ERBDocument < Document
+    extend T::Sig
+
+    sig { override.returns(Prism::ParseResult) }
+    def parse
+      return @parse_result unless @needs_parsing
+
+      @needs_parsing = false
+      scanner = ERBScanner.new(@source)
+      scanner.scan
+      @parse_result = Prism.parse(scanner.ruby)
+    end
+
+    sig { override.returns(T::Boolean) }
+    def syntax_error?
+      @parse_result.failure?
+    end
+
+    sig { override.returns(LanguageId) }
+    def language_id
+      LanguageId::ERB
+    end
+
+    class ERBScanner
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :ruby, :html
+
+      sig { params(source: String).void }
+      def initialize(source)
+        @source = source
+        @html = T.let(+"", String)
+        @ruby = T.let(+"", String)
+        @current_pos = T.let(0, Integer)
+        @inside_ruby = T.let(false, T::Boolean)
+      end
+
+      sig { void }
+      def scan
+        while @current_pos < @source.length
+          scan_char
+          @current_pos += 1
+        end
+      end
+
+      private
+
+      sig { void }
+      def scan_char
+        char = @source[@current_pos]
+
+        case char
+        when "<"
+          if next_char == "%"
+            @inside_ruby = true
+            @current_pos += 1
+            push_char("  ")
+
+            if next_char == "=" && @source[@current_pos + 2] == "="
+              @current_pos += 2
+              push_char("  ")
+            elsif next_char == "=" || next_char == "-"
+              @current_pos += 1
+              push_char(" ")
+            end
+          else
+            push_char(T.must(char))
+          end
+        when "-"
+          if @inside_ruby && next_char == "%" &&
+              @source[@current_pos + 2] == ">"
+            @current_pos += 2
+            push_char("   ")
+            @inside_ruby = false
+          else
+            push_char(T.must(char))
+          end
+        when "%"
+          if @inside_ruby && next_char == ">"
+            @inside_ruby = false
+            @current_pos += 1
+            push_char("  ")
+          else
+            push_char(T.must(char))
+          end
+        when "\r"
+          @ruby << char
+          @html << char
+
+          if next_char == "\n"
+            @ruby << next_char
+            @html << next_char
+            @current_pos += 1
+          end
+        when "\n"
+          @ruby << char
+          @html << char
+        else
+          push_char(T.must(char))
+        end
+      end
+
+      sig { params(char: String).void }
+      def push_char(char)
+        if @inside_ruby
+          @ruby << char
+          @html << " " * char.length
+        else
+          @ruby << " " * char.length
+          @html << char
+        end
+      end
+
+      sig { returns(String) }
+      def next_char
+        @source[@current_pos + 1] || ""
+      end
+    end
+  end
+end

data/lib/ruby_lsp/global_state.rb

@@ -21,7 +21,7 @@ module RubyLsp
     attr_reader :encoding
 
     sig { returns(T::Boolean) }
-    attr_reader :supports_watching_files
+    attr_reader :supports_watching_files, :experimental_features
 
     sig { returns(TypeInferrer) }
     attr_reader :type_inferrer
@@ -36,9 +36,10 @@ module RubyLsp
       @test_library = T.let("minitest", String)
       @has_type_checker = T.let(true, T::Boolean)
       @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
-      @type_inferrer = T.let(TypeInferrer.new(@index), TypeInferrer)
       @supported_formatters = T.let({}, T::Hash[String, Requests::Support::Formatter])
       @supports_watching_files = T.let(false, T::Boolean)
+      @experimental_features = T.let(false, T::Boolean)
+      @type_inferrer = T.let(TypeInferrer.new(@index, @experimental_features), TypeInferrer)
     end
 
     sig { params(identifier: String, instance: Requests::Support::Formatter).void }
@@ -56,21 +57,48 @@ module RubyLsp
       @linters.filter_map { |name| @supported_formatters[name] }
     end
 
-    sig { params(options: T::Hash[Symbol, T.untyped]).void }
+    # Applies the options provided by the editor and returns an array of notifications to send back to the client
+    sig { params(options: T::Hash[Symbol, T.untyped]).returns(T::Array[Notification]) }
     def apply_options(options)
+      notifications = []
       direct_dependencies = gather_direct_dependencies
       all_dependencies = gather_direct_and_indirect_dependencies
       workspace_uri = options.dig(:workspaceFolders, 0, :uri)
       @workspace_uri = URI(workspace_uri) if workspace_uri
 
       specified_formatter = options.dig(:initializationOptions, :formatter)
-      @formatter = specified_formatter if specified_formatter
-      @formatter = detect_formatter(direct_dependencies, all_dependencies) if @formatter == "auto"
+
+      if specified_formatter
+        @formatter = specified_formatter
+
+        if specified_formatter != "auto"
+          notifications << Notification.window_log_message("Using formatter specified by user: #{@formatter}")
+        end
+      end
+
+      if @formatter == "auto"
+        @formatter = detect_formatter(direct_dependencies, all_dependencies)
+        notifications << Notification.window_log_message("Auto detected formatter: #{@formatter}")
+      end
 
       specified_linters = options.dig(:initializationOptions, :linters)
-      @linters = specified_linters || detect_linters(direct_dependencies)
+      @linters = specified_linters || detect_linters(direct_dependencies, all_dependencies)
+
+      notifications << if specified_linters
+        Notification.window_log_message("Using linters specified by user: #{@linters.join(", ")}")
+      else
+        Notification.window_log_message("Auto detected linters: #{@linters.join(", ")}")
+      end
+
       @test_library = detect_test_library(direct_dependencies)
+      notifications << Notification.window_log_message("Detected test library: #{@test_library}")
+
       @has_type_checker = detect_typechecker(direct_dependencies)
+      if @has_type_checker
+        notifications << Notification.window_log_message(
+          "Ruby LSP detected this is a Sorbet project and will defer to the Sorbet LSP for some functionality",
+        )
+      end
 
       encodings = options.dig(:capabilities, :general, :positionEncodings)
       @encoding = if !encodings || encodings.empty?
@@ -87,6 +115,11 @@ module RubyLsp
       if file_watching_caps&.dig(:dynamicRegistration) && file_watching_caps&.dig(:relativePatternSupport)
         @supports_watching_files = true
       end
+
+      @experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled) || false
+      @type_inferrer.experimental_features = @experimental_features
+
+      notifications
     end
 
     sig { returns(String) }
@@ -124,10 +157,14 @@ module RubyLsp
 
     # Try to detect if there are linters in the project's dependencies. For auto-detection, we always only consider a
     # single linter. To have multiple linters running, the user must configure them manually
-    sig { params(dependencies: T::Array[String]).returns(T::Array[String]) }
-    def detect_linters(dependencies)
+    sig { params(dependencies: T::Array[String], all_dependencies: T::Array[String]).returns(T::Array[String]) }
+    def detect_linters(dependencies, all_dependencies)
       linters = []
-      linters << "rubocop" if dependencies.any?(/^rubocop/)
+
+      if dependencies.any?(/^rubocop/) || (all_dependencies.include?("rubocop") && dot_rubocop_yml_present)
+        linters << "rubocop"
+      end
+
       linters
     end
 
@@ -155,16 +192,7 @@ module RubyLsp
     def detect_typechecker(dependencies)
       return false if ENV["RUBY_LSP_BYPASS_TYPECHECKER"]
 
-      # We can't read the env from within `Bundle.with_original_env` so we need to set it here.
-      ruby_lsp_env_is_test = (ENV["RUBY_LSP_ENV"] == "test")
-      Bundler.with_original_env do
-        sorbet_static_detected = dependencies.any?(/^sorbet-static/)
-        # Don't show message while running tests, since it's noisy
-        if sorbet_static_detected && !ruby_lsp_env_is_test
-          $stderr.puts("Ruby LSP detected this is a Sorbet project so will defer to Sorbet LSP for some functionality")
-        end
-        sorbet_static_detected
-      end
+      dependencies.any?(/^sorbet-static/)
     rescue Bundler::GemfileNotFound
       false
     end

data/lib/ruby_lsp/internal.rb

@@ -15,6 +15,7 @@ Bundler.ui.level = :silent
 require "uri"
 require "cgi"
 require "set"
+require "strscan"
 require "prism"
 require "prism/visitor"
 require "language_server-protocol"
@@ -34,6 +35,7 @@ require "ruby_lsp/response_builders"
 require "ruby_lsp/node_context"
 require "ruby_lsp/document"
 require "ruby_lsp/ruby_document"
+require "ruby_lsp/erb_document"
 require "ruby_lsp/store"
 require "ruby_lsp/addon"
 require "ruby_lsp/requests/support/rubocop_runner"