ruby-lsp 0.3.6 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59e3f670a003f565c001d00333a727d8cf4080eb274d4ebdf248bc0ad76b9c16
-  data.tar.gz: 5010473614d96f47ba10a267844448d6b5985b469cdfec752489be268ba95510
+  metadata.gz: cddece941249b188843957c1c026e6e1e10f875c26a7c2f14f556a53556cc94f
+  data.tar.gz: cdc7368658e3de269033b41bceb831becb68320cd1444ec9792380408ee2a4f2
 SHA512:
-  metadata.gz: '0853a29d497f7befc9bcbbd0387c3e456293728788b0067b91026f4c61c5013240284adc913471b5c015184b19752ecac5e958ab021f301e41c24ce55ed876e2'
-  data.tar.gz: c2ee016b997013590cad9c575b1461d50f833d3fc06a7b22aa953aa73d6163feb5d821fe443c4ba20b0ac25cf686f32ed26c34348016408f6118f45261cce8a9
+  metadata.gz: d28c2f96939d517cacae6b86407e5990ca1587f99848bc14ff98ea24b5421e2ad38ba0ee39a7040c2a4694623e349c907c6f2a764737e0cc9316d302804687b2
+  data.tar.gz: a5e118206994b0e58ff9568043eb534360e591f931c0c8f078579283ab0519057a236606728c230e4be86f7405035a6e2bea1e52959af280f2067f0e52127278

data/README.md

@@ -28,6 +28,14 @@ are expected to adhere to the
 [Contributor Covenant](https://github.com/Shopify/ruby-lsp/blob/main/CODE_OF_CONDUCT.md)
 code of conduct.
 
+### Running the test suite
+
+Run the test suite with `bin/test`.
+
+For more visibility into which tests are running, use the `SpecReporter`:
+
+`SPEC_REPORTER=1 bin/test`
+
 ### Expectation testing
 
 To simplify the way we run tests over different pieces of Ruby code, we use a custom expectations test framework against a set of Ruby fixtures.

data/VERSION

@@ -1 +1 @@
-0.3.6
+0.3.7

data/lib/ruby_lsp/document.rb

@@ -18,10 +18,11 @@ module RubyLsp
     sig { returns(T::Array[EditShape]) }
     attr_reader :syntax_error_edits
 
-    sig { params(source: String).void }
-    def initialize(source)
+    sig { params(source: String, encoding: String).void }
+    def initialize(source, encoding = "utf-8")
       @cache = T.let({}, T::Hash[Symbol, T.untyped])
       @syntax_error_edits = T.let([], T::Array[EditShape])
+      @encoding = T.let(encoding, String)
       @source = T.let(source, String)
       @parsable_source = T.let(source.dup, String)
       @unparsed_edits = T.let([], T::Array[EditShape])
@@ -83,6 +84,11 @@ module RubyLsp
       !@tree.nil?
     end
 
+    sig { returns(Scanner) }
+    def create_scanner
+      Scanner.new(@source, @encoding)
+    end
+
     private
 
     sig { params(edits: T::Array[EditShape]).void }
@@ -103,9 +109,9 @@ module RubyLsp
 
     sig { params(source: String, range: RangeShape, text: String).void }
     def apply_edit(source, range, text)
-      scanner = Scanner.new(source)
-      start_position = scanner.find_position(range[:start])
-      end_position = scanner.find_position(range[:end])
+      scanner = Scanner.new(source, @encoding)
+      start_position = scanner.find_char_position(range[:start])
+      end_position = scanner.find_char_position(range[:end])
 
       source[start_position...end_position] = text
     end
@@ -113,22 +119,49 @@ module RubyLsp
     class Scanner
       extend T::Sig
 
-      sig { params(source: String).void }
-      def initialize(source)
+      LINE_BREAK = T.let(0x0A, Integer)
+      # After character 0xFFFF, UTF-16 considers characters to have length 2 and we have to account for that
+      SURROGATE_PAIR_START = T.let(0xFFFF, Integer)
+
+      sig { params(source: String, encoding: String).void }
+      def initialize(source, encoding)
         @current_line = T.let(0, Integer)
         @pos = T.let(0, Integer)
-        @source = source
+        @source = T.let(source.codepoints, T::Array[Integer])
+        @encoding = encoding
       end
 
+      # Finds the character index inside the source string for a given line and column
       sig { params(position: PositionShape).returns(Integer) }
-      def find_position(position)
+      def find_char_position(position)
+        # Find the character index for the beginning of the requested line
         until @current_line == position[:line]
-          @pos += 1 until /\R/.match?(@source[@pos])
+          @pos += 1 until LINE_BREAK == @source[@pos]
           @pos += 1
           @current_line += 1
         end
 
-        @pos + position[:character]
+        # The final position is the beginning of the line plus the requested column. If the encoding is UTF-16, we also
+        # need to adjust for surrogate pairs
+        requested_position = @pos + position[:character]
+        requested_position -= utf_16_character_position_correction(@pos, requested_position) if @encoding == "utf-16"
+        requested_position
+      end
+
+      # Subtract 1 for each character after 0xFFFF in the current line from the column position, so that we hit the
+      # right character in the UTF-8 representation
+      sig { params(current_position: Integer, requested_position: Integer).returns(Integer) }
+      def utf_16_character_position_correction(current_position, requested_position)
+        utf16_unicode_correction = 0
+
+        until current_position == requested_position
+          codepoint = @source[current_position]
+          utf16_unicode_correction += 1 if codepoint && codepoint > SURROGATE_PAIR_START
+
+          current_position += 1
+        end
+
+        utf16_unicode_correction
       end
     end
   end

data/lib/ruby_lsp/requests/base_request.rb

@@ -79,6 +79,15 @@ module RubyLsp
           []
         end
       end
+
+      sig { params(node: T.nilable(SyntaxTree::Node), range: T.nilable(T::Range[Integer])).returns(T::Boolean) }
+      def visible?(node, range)
+        return true if range.nil?
+        return false if node.nil?
+
+        loc = node.location
+        range.cover?(loc.start_line - 1) && range.cover?(loc.end_line - 1)
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/code_actions.rb

@@ -35,7 +35,7 @@ module RubyLsp
 
       sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::CodeAction], Object)) }
       def run
-        diagnostics = Diagnostics.new(@uri, @document).run
+        diagnostics = @document.cache_fetch(:diagnostics) { Diagnostics.new(@uri, @document).run }
         corrections = diagnostics.select do |diagnostic|
           diagnostic.correctable? && T.cast(diagnostic, Support::RuboCopDiagnostic).in_range?(@range)
         end

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -30,10 +30,9 @@ module RubyLsp
         super(document)
 
         @highlights = T.let([], T::Array[LanguageServer::Protocol::Interface::DocumentHighlight])
-        position = Document::Scanner.new(document.source).find_position(position)
-
         return unless document.parsed?
 
+        position = document.create_scanner.find_char_position(position)
         @target = T.let(find(T.must(document.tree), position), T.nilable(Support::HighlightTarget))
       end
 

data/lib/ruby_lsp/requests/document_link.rb

@@ -50,9 +50,8 @@ module RubyLsp
               spec = stub.to_spec
               lookup[spec.name] = {}
               lookup[spec.name][spec.version.to_s] = {}
-              prefix_matchers = [//]
-              prefix_matchers.concat(spec.require_paths.map { |rp| Regexp.new("^#{rp}/") })
-              prefix_matcher = Regexp.union(prefix_matchers)
+              prefix_matchers = Regexp.union(spec.require_paths.map { |rp| Regexp.new("^#{rp}/") })
+              prefix_matcher = Regexp.union(prefix_matchers, //)
 
               spec.files.each do |file|
                 path = file.sub(prefix_matcher, "")

data/lib/ruby_lsp/requests/hover.rb

@@ -24,7 +24,7 @@ module RubyLsp
       def initialize(document, position)
         super(document)
 
-        @position = T.let(Document::Scanner.new(document.source).find_position(position), Integer)
+        @position = T.let(document.create_scanner.find_char_position(position), Integer)
       end
 
       sig { override.returns(T.nilable(LanguageServer::Protocol::Interface::Hover)) }

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -40,7 +40,7 @@ module RubyLsp
         return unless node.exception.nil?
 
         loc = node.location
-        return unless @range.cover?(loc.start_line - 1) && @range.cover?(loc.end_line - 1)
+        return unless visible?(node, @range)
 
         @hints << LanguageServer::Protocol::Interface::InlayHint.new(
           position: { line: loc.start_line - 1, character: loc.start_column + RESCUE_STRING_LENGTH },

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -27,9 +27,9 @@ module RubyLsp
       def initialize(document, position, trigger_character)
         super(document)
 
-        scanner = Document::Scanner.new(document.source)
-        line_begin = position[:line] == 0 ? 0 : scanner.find_position({ line: position[:line] - 1, character: 0 })
-        line_end = scanner.find_position(position)
+        scanner = document.create_scanner
+        line_begin = position[:line] == 0 ? 0 : scanner.find_char_position({ line: position[:line] - 1, character: 0 })
+        line_end = scanner.find_char_position(position)
         line = T.must(@document.source[line_begin..line_end])
 
         @indentation = T.let(find_indentation(line), Integer)

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -76,13 +76,20 @@ module RubyLsp
         const :modifier, T::Array[Integer]
       end
 
-      sig { params(document: Document, encoder: T.nilable(Support::SemanticTokenEncoder)).void }
-      def initialize(document, encoder: nil)
+      sig do
+        params(
+          document: Document,
+          range: T.nilable(T::Range[Integer]),
+          encoder: T.nilable(Support::SemanticTokenEncoder),
+        ).void
+      end
+      def initialize(document, range: nil, encoder: nil)
         super(document)
 
         @encoder = encoder
         @tokens = T.let([], T::Array[SemanticToken])
         @tree = T.let(T.must(document.tree), SyntaxTree::Node)
+        @range = range
         @special_methods = T.let(nil, T.nilable(T::Array[String]))
       end
 
@@ -105,6 +112,8 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::Call).void }
       def visit_call(node)
+        return super unless visible?(node, @range)
+
         visit(node.receiver)
 
         message = node.message
@@ -115,12 +124,16 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::Command).void }
       def visit_command(node)
+        return super unless visible?(node, @range)
+
         add_token(node.message.location, :method) unless special_method?(node.message.value)
         visit(node.arguments)
       end
 
       sig { override.params(node: SyntaxTree::CommandCall).void }
       def visit_command_call(node)
+        return super unless visible?(node, @range)
+
         visit(node.receiver)
         add_token(node.message.location, :method)
         visit(node.arguments)
@@ -128,11 +141,15 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::Const).void }
       def visit_const(node)
+        return super unless visible?(node, @range)
+
         add_token(node.location, :namespace)
       end
 
       sig { override.params(node: SyntaxTree::Def).void }
       def visit_def(node)
+        return super unless visible?(node, @range)
+
         add_token(node.name.location, :method, [:declaration])
         visit(node.params)
         visit(node.bodystmt)
@@ -140,6 +157,8 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::DefEndless).void }
       def visit_def_endless(node)
+        return super unless visible?(node, @range)
+
         add_token(node.name.location, :method, [:declaration])
         visit(node.paren)
         visit(node.operator)
@@ -148,6 +167,8 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::Defs).void }
       def visit_defs(node)
+        return super unless visible?(node, @range)
+
         visit(node.target)
         visit(node.operator)
         add_token(node.name.location, :method, [:declaration])
@@ -157,12 +178,16 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::FCall).void }
       def visit_fcall(node)
+        return super unless visible?(node, @range)
+
         add_token(node.value.location, :method) unless special_method?(node.value.value)
         visit(node.arguments)
       end
 
       sig { override.params(node: SyntaxTree::Kw).void }
       def visit_kw(node)
+        return super unless visible?(node, @range)
+
         case node.value
         when "self"
           add_token(node.location, :variable, [:default_library])
@@ -171,6 +196,8 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::Params).void }
       def visit_params(node)
+        return super unless visible?(node, @range)
+
         node.keywords.each do |keyword,|
           location = keyword.location
           add_token(location_without_colon(location), :parameter)
@@ -191,6 +218,8 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::Field).void }
       def visit_field(node)
+        return super unless visible?(node, @range)
+
         add_token(node.name.location, :method)
 
         super
@@ -198,6 +227,8 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::VarField).void }
       def visit_var_field(node)
+        return super unless visible?(node, @range)
+
         value = node.value
 
         case value
@@ -211,6 +242,8 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::VarRef).void }
       def visit_var_ref(node)
+        return super unless visible?(node, @range)
+
         value = node.value
 
         case value
@@ -224,11 +257,15 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::VCall).void }
       def visit_vcall(node)
+        return super unless visible?(node, @range)
+
         add_token(node.value.location, :method) unless special_method?(node.value.value)
       end
 
       sig { override.params(node: SyntaxTree::ClassDeclaration).void }
       def visit_class(node)
+        return super unless visible?(node, @range)
+
         add_token(node.constant.location, :class, [:declaration])
         add_token(node.superclass.location, :class) if node.superclass
         visit(node.bodystmt)
@@ -236,6 +273,8 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::ModuleDeclaration).void }
       def visit_module(node)
+        return super unless visible?(node, @range)
+
         add_token(node.constant.location, :class, [:declaration])
         visit(node.bodystmt)
       end

data/lib/ruby_lsp/server.rb

@@ -7,6 +7,8 @@ module RubyLsp
   Handler.start do
     on("initialize") do |request|
       store.clear
+      store.encoding = request.dig(:params, :capabilities, :general, :positionEncodings)
+
       initialization_options = request.dig(:params, :initializationOptions)
       enabled_features = initialization_options.fetch(:enabledFeatures, [])
 
@@ -38,10 +40,8 @@ module RubyLsp
             token_types: Requests::SemanticHighlighting::TOKEN_TYPES.keys,
             token_modifiers: Requests::SemanticHighlighting::TOKEN_MODIFIERS.keys,
           ),
-          range: false,
-          full: {
-            delta: true,
-          },
+          range: true,
+          full: { delta: false },
         )
       end
 
@@ -168,6 +168,19 @@ module RubyLsp
       end
     end
 
+    on("textDocument/semanticTokens/range", parallel: true) do |request|
+      document = store.get(request.dig(:params, :textDocument, :uri))
+      range = request.dig(:params, :range)
+      start_line = range.dig(:start, :line)
+      end_line = range.dig(:end, :line)
+
+      Requests::SemanticHighlighting.new(
+        document,
+        range: start_line..end_line,
+        encoder: Requests::Support::SemanticTokenEncoder.new,
+      ).run
+    end
+
     on("textDocument/formatting", parallel: true) do |request|
       uri = request.dig(:params, :textDocument, :uri)
 
@@ -192,13 +205,12 @@ module RubyLsp
 
     on("textDocument/codeAction", parallel: true) do |request|
       uri = request.dig(:params, :textDocument, :uri)
+      document = store.get(uri)
       range = request.dig(:params, :range)
       start_line = range.dig(:start, :line)
       end_line = range.dig(:end, :line)
 
-      store.cache_fetch(uri, :code_actions) do |document|
-        Requests::CodeActions.new(uri, document, start_line..end_line).run
-      end
+      Requests::CodeActions.new(uri, document, start_line..end_line).run
     end
 
     on("textDocument/inlayHint", parallel: true) do |request|

data/lib/ruby_lsp/store.rb

@@ -9,9 +9,13 @@ module RubyLsp
   class Store
     extend T::Sig
 
+    sig { params(encoding: String).void }
+    attr_writer :encoding
+
     sig { void }
     def initialize
       @state = T.let({}, T::Hash[String, Document])
+      @encoding = T.let("utf-8", String)
     end
 
     sig { params(uri: String).returns(Document) }
@@ -25,7 +29,7 @@ module RubyLsp
 
     sig { params(uri: String, content: String).void }
     def set(uri, content)
-      document = Document.new(content)
+      document = Document.new(content, @encoding)
       @state[uri] = document
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.3.7
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-11-11 00:00:00.000000000 Z
+date: 2022-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol