theme-check 1.7.0 → 1.9.0

data/lib/theme_check/language_server/server.rb

@@ -13,30 +13,18 @@ module ThemeCheck
       attr_reader :should_raise_errors
 
       def initialize(
-        in_stream: STDIN,
-        out_stream: STDOUT,
-        err_stream: STDERR,
+        messenger:,
         should_raise_errors: false,
         number_of_threads: 2
       )
-        validate!([in_stream, out_stream, err_stream])
+        # This is what does the IO
+        @messenger = messenger
 
-        @handler = Handler.new(self)
-        @in = in_stream
-        @out = out_stream
-        @err = err_stream
+        # This is what you use to communicate with the language client
+        @bridge = Bridge.new(@messenger)
 
-        # Because programming is fun,
-        #
-        # Ruby on Windows turns \n into \r\n. Which means that \r\n
-        # gets turned into \r\r\n. Which means that the protocol
-        # breaks on windows unless we turn STDOUT into binary mode.
-        #
-        # Hours wasted: 9.
-        @out.binmode
-
-        @out.sync = true # do not buffer
-        @err.sync = true # do not buffer
+        # The handler handles messages from the language client
+        @handler = Handler.new(@bridge)
 
         # The queue holds the JSON RPC messages
         @queue = Queue.new
@@ -48,12 +36,8 @@ module ThemeCheck
         @number_of_threads = number_of_threads
         @handlers = []
 
-        # The messenger permits requests to be made from the handler
-        # to the language client and for those messages to be resolved in place.
-        @messenger = Messenger.new
-
         # The error queue holds blocks the main thread. When filled, we exit the program.
-        @error = SizedQueue.new(1)
+        @error = SizedQueue.new(number_of_threads)
 
         @should_raise_errors = should_raise_errors
       end
@@ -61,19 +45,23 @@ module ThemeCheck
       def listen
         start_handler_threads
         start_json_rpc_thread
-        status_code_from_error(@error.pop)
+        status_code = status_code_from_error(@error.pop)
+        cleanup(status_code)
       rescue SignalException
         0
-      ensure
-        cleanup
       end
 
       def start_json_rpc_thread
         @json_rpc_thread = Thread.new do
           loop do
-            message = read_json_rpc_message
-            if message['method'] == 'initialize'
+            message = @bridge.read_message
+            if message[:method] == 'initialize'
               handle_message(message)
+            elsif message.key?(:result)
+              # Responses are handled on the main thread to prevent
+              # a potential deadlock caused by all handlers waiting
+              # for a responses.
+              handle_response(message)
             else
               @queue << message
             end
@@ -106,103 +94,46 @@ module ThemeCheck
 
       rescue Exception => e # rubocop:disable Lint/RescueException
         raise e if should_raise_errors
-        log(e)
-        log(e.backtrace)
+        @bridge.log("#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}")
         2
       end
 
-      def request(&block)
-        @messenger.request(&block)
-      end
-
-      def send_message(message)
-        message_body = JSON.dump(message)
-        log(JSON.pretty_generate(message)) if $DEBUG
-
-        @out.write("Content-Length: #{message_body.bytesize}\r\n")
-        @out.write("\r\n")
-        @out.write(message_body)
-        @out.flush
-      end
-
-      def log(message)
-        @err.puts(message)
-        @err.flush
-      end
-
       private
 
-      def supported_io_classes
-        [IO, StringIO]
-      end
-
-      def validate!(streams = [])
-        streams.each do |stream|
-          unless supported_io_classes.find { |klass| stream.is_a?(klass) }
-            raise IncompatibleStream, incompatible_stream_message
-          end
-        end
-      end
-
-      def incompatible_stream_message
-        'if provided, in_stream, out_stream, and err_stream must be a kind of '\
-        "one of the following: #{supported_io_classes.join(', ')}"
-      end
-
-      def read_json_rpc_message
-        message_body = read_new_content
-        message_json = JSON.parse(message_body)
-        log(JSON.pretty_generate(message_json)) if $DEBUG
-        message_json
-      end
-
       def handle_message(message)
-        id = message['id']
-        method_name = message['method']
+        id = message[:id]
+        method_name = message[:method]
         method_name &&= "on_#{to_snake_case(method_name)}"
-        params = message['params']
-        result = message['result']
+        params = message[:params]
 
-        if message.key?('result')
-          @messenger.respond(id, result)
-        elsif @handler.respond_to?(method_name)
+        if @handler.respond_to?(method_name)
           @handler.send(method_name, id, params)
         end
-      end
 
-      def to_snake_case(method_name)
-        StringHelpers.underscore(method_name.gsub(/[^\w]/, '_'))
+      rescue DoneStreaming => e
+        raise e
+      rescue StandardError => e
+        is_request = id
+        raise e unless is_request
+        # Errors obtained in request handlers should be sent
+        # back as internal errors instead of closing the program.
+        @bridge.log("#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}")
+        @bridge.send_internal_error(id, e)
       end
 
-      def initial_line
-        # Scanning for lines that fit the protocol.
-        while true
-          initial_line = @in.gets
-          # gets returning nil means the stream was closed.
-          raise DoneStreaming if initial_line.nil?
-
-          if initial_line.match(/Content-Length: (\d+)/)
-            break
-          end
-        end
-        initial_line
+      def handle_response(message)
+        id = message[:id]
+        result = message[:result]
+        @bridge.receive_response(id, result)
       end
 
-      def read_new_content
-        length = initial_line.match(/Content-Length: (\d+)/)[1].to_i
-        content = ''
-        while content.length < length + 2
-          # Why + 2? Because \r\n
-          content += @in.read(length + 2)
-          raise DoneStreaming if @in.closed?
-        end
-
-        content
+      def to_snake_case(method_name)
+        StringHelpers.underscore(method_name.gsub(/[^\w]/, '_'))
       end
 
-      def cleanup
+      def cleanup(status_code)
         # Stop listenting to RPC calls
-        @in.close unless @in.closed?
+        @messenger.close_input
         # Wait for rpc loop to close
         @json_rpc_thread&.join if @json_rpc_thread&.alive?
         # Close the queue
@@ -210,9 +141,22 @@ module ThemeCheck
         # Give 10 seconds for the handlers to wrap up what they were
         # doing/emptying the queue. 👀 unit tests.
         @handlers.each { |thread| thread.join(10) if thread.alive? }
+
+        # Hijack the status_code if an error occurred while cleaning up.
+        # 👀 unit tests.
+        until @error.empty?
+          code = status_code_from_error(@error.pop)
+          # Promote the status_code to ERROR if one of the threads
+          # resulted in an error, otherwise leave the status_code as
+          # is. That's because one thread could end successfully in a
+          # DoneStreaming error while the other failed with an
+          # internal error. If we had an internal error, we should
+          # return with a status_code that fits.
+          status_code = code if code > status_code
+        end
+        status_code
       ensure
-        @err.close
-        @out.close
+        @messenger.close_output
       end
     end
   end

data/lib/theme_check/language_server/uri_helper.rb

@@ -15,6 +15,7 @@ module ThemeCheck
       #
       # Exists because of https://github.com/Shopify/theme-check/issues/360
       def file_uri(absolute_path)
+        return if absolute_path.nil?
         "file://" + absolute_path
           .to_s
           .split('/')

data/lib/theme_check/language_server/versioned_in_memory_storage.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  class VersionedInMemoryStorage < InMemoryStorage
+    Version = Struct.new(:id, :version)
+
+    attr_reader :versions
+
+    def initialize(files, root = "/dev/null")
+      super(files, root)
+      @versions = {}
+      @mutex = Mutex.new
+    end
+
+    # Motivations:
+    #   - Need way for LanguageServer to know on which version of a file
+    #     the check was run on, because we need to know where the
+    #     TextEdit goes. If the text changed, our TextEdit might not be
+    #     in the right spot. e.g.
+    #
+    #     Example:
+    #
+    #     ```
+    #     Hi
+    #     {{world}}
+    #     ```
+    #
+    #     Would produce two "SpaceInsideBrace" errors:
+    #
+    #     - One after {{ at index 5 to 6
+    #     - One before }} at index 10 to 11
+    #
+    #     If the user goes in and changes Hi to Sup, and _then_
+    #     right clicks to apply the code edit at index 5 to 6, he'd
+    #     get the following:
+    #
+    #     ```
+    #     Sup
+    #     { {world}}
+    #     ```
+    #
+    #     Which is not a fix at all.
+    #
+    # Solution:
+    #   - Have the LanguageServer store the version on textDocument/did{Open,Change,Close}
+    #   - Have ThemeFile store the version right after @storage.read.
+    #   - Add version to the diagnostic meta data
+    #   - Use diagnostic meta data to determine if we can make a code edit or not
+    #   - Only offer fixes on "clean" files (or offer the change but specify the version so the editor knows what to do with it)
+    def write(relative_path, content, version)
+      @mutex.synchronize do
+        @versions[relative_path] = version
+        super(relative_path, content)
+      end
+    end
+
+    def read_version(relative_path)
+      @mutex.synchronize { [read(relative_path), version(relative_path)] }
+    end
+
+    def versioned?
+      true
+    end
+
+    def version(relative_path)
+      @versions[relative_path.to_s]
+    end
+  end
+end

data/lib/theme_check/language_server.rb

@@ -1,31 +1,53 @@
 # frozen_string_literal: true
 require_relative "language_server/protocol"
-require_relative "language_server/messenger"
 require_relative "language_server/constants"
+require_relative "language_server/configuration"
+require_relative "language_server/channel"
+require_relative "language_server/messenger"
+require_relative "language_server/io_messenger"
+require_relative "language_server/bridge"
 require_relative "language_server/uri_helper"
-require_relative "language_server/handler"
 require_relative "language_server/server"
 require_relative "language_server/tokens"
 require_relative "language_server/variable_lookup_finder"
+require_relative "language_server/diagnostic"
+require_relative "language_server/diagnostics_manager"
+require_relative "language_server/diagnostics_engine"
+require_relative "language_server/document_change_corrector"
+require_relative "language_server/versioned_in_memory_storage"
+require_relative "language_server/client_capabilities"
+
 require_relative "language_server/completion_helper"
 require_relative "language_server/completion_provider"
 require_relative "language_server/completion_engine"
+Dir[__dir__ + "/language_server/completion_providers/*.rb"].each do |file|
+  require file
+end
+
 require_relative "language_server/document_link_provider"
 require_relative "language_server/document_link_engine"
-require_relative "language_server/diagnostics_tracker"
+Dir[__dir__ + "/language_server/document_link_providers/*.rb"].each do |file|
+  require file
+end
 
-Dir[__dir__ + "/language_server/completion_providers/*.rb"].each do |file|
+require_relative "language_server/execute_command_provider"
+require_relative "language_server/execute_command_engine"
+Dir[__dir__ + "/language_server/execute_command_providers/*.rb"].each do |file|
   require file
 end
 
-Dir[__dir__ + "/language_server/document_link_providers/*.rb"].each do |file|
+require_relative "language_server/code_action_provider"
+require_relative "language_server/code_action_engine"
+Dir[__dir__ + "/language_server/code_action_providers/*.rb"].each do |file|
   require file
 end
 
+require_relative "language_server/handler"
+
 module ThemeCheck
   module LanguageServer
     def self.start
-      Server.new.listen
+      Server.new(messenger: IOMessenger.new).listen
     end
   end
 end

data/lib/theme_check/liquid_node.rb

@@ -45,11 +45,47 @@ module ThemeCheck
     def markup
       if tag?
         tag_markup
+      elsif literal?
+        value.to_s
       elsif @value.instance_variable_defined?(:@markup)
         @value.instance_variable_get(:@markup)
       end
     end
 
+    # The original source code of the node. Does contain wrapping braces.
+    def outer_markup
+      if literal?
+        markup
+      elsif variable_lookup?
+        ''
+      elsif variable?
+        start_token + markup + end_token
+      elsif tag? && block?
+        start_index = block_start_start_index
+        end_index = block_start_end_index
+        end_index += inner_markup.size
+        end_index = find_block_delimiter(end_index)&.end(0)
+        source[start_index...end_index]
+      elsif tag?
+        source[block_start_start_index...block_start_end_index]
+      else
+        inner_markup
+      end
+    end
+
+    def inner_markup
+      return '' unless block?
+      @inner_markup ||= source[block_start_end_index...block_end_start_index]
+    end
+
+    def inner_json
+      return nil unless schema?
+      @inner_json ||= JSON.parse(inner_markup)
+    rescue JSON::ParserError
+      # Handled by ValidSchema
+      @inner_json = nil
+    end
+
     def markup=(markup)
       if @value.instance_variable_defined?(:@markup)
         @value.instance_variable_set(:@markup, markup)
@@ -70,10 +106,26 @@ module ThemeCheck
       position.start_index
     end
 
+    def start_row
+      position.start_row
+    end
+
+    def start_column
+      position.start_column
+    end
+
     def end_index
       position.end_index
     end
 
+    def end_row
+      position.end_row
+    end
+
+    def end_column
+      position.end_column
+    end
+
     # Literals are hard-coded values in the liquid file.
     def literal?
       @value.is_a?(String) || @value.is_a?(Integer)
@@ -88,6 +140,14 @@ module ThemeCheck
       @value.is_a?(Liquid::Variable)
     end
 
+    def assigned_or_echoed_variable?
+      variable? && start_token == ""
+    end
+
+    def variable_lookup?
+      @value.is_a?(Liquid::VariableLookup)
+    end
+
     # A {% comment %} block node?
     def comment?
       @value.is_a?(Liquid::Comment)
@@ -114,6 +174,10 @@ module ThemeCheck
       block_tag? || block_body? || document?
     end
 
+    def schema?
+      @value.is_a?(ThemeCheck::Tags::Schema)
+    end
+
     # The `:under_score_name` of this type of node. Used to dispatch to the `on_<type_name>`
     # and `after_<type_name>` check methods.
     def type_name
@@ -124,6 +188,86 @@ module ThemeCheck
       theme_file&.source
     end
 
+    def block_start_markup
+      source[block_start_start_index...block_start_end_index]
+    end
+
+    def block_start_start_index
+      @block_start_start_index ||= if inside_liquid_tag?
+        backtrack_on_whitespace(source, start_index, /[ \t]/)
+      elsif tag?
+        backtrack_on_whitespace(source, start_index) - start_token.length
+      else
+        position.start_index - start_token.length
+      end
+    end
+
+    def block_start_end_index
+      @block_start_end_index ||= position.end_index + end_token.size
+    end
+
+    def block_end_markup
+      source[block_end_start_index...block_end_end_index]
+    end
+
+    def block_end_start_index
+      return block_start_end_index unless tag? && block?
+      @block_end_start_index ||= block_end_match&.begin(0) || block_start_end_index
+    end
+
+    def block_end_end_index
+      return block_end_start_index unless tag? && block?
+      @block_end_end_index ||= block_end_match&.end(0) || block_start_end_index
+    end
+
+    def outer_markup_start_index
+      outer_markup_position.start_index
+    end
+
+    def outer_markup_end_index
+      outer_markup_position.end_index
+    end
+
+    def outer_markup_start_row
+      outer_markup_position.start_row
+    end
+
+    def outer_markup_start_column
+      outer_markup_position.start_column
+    end
+
+    def outer_markup_end_row
+      outer_markup_position.end_row
+    end
+
+    def outer_markup_end_column
+      outer_markup_position.end_column
+    end
+
+    def inner_markup_start_index
+      inner_markup_position.start_index
+    end
+
+    def inner_markup_end_index
+      inner_markup_position.end_index
+    end
+
+    def inner_markup_start_row
+      inner_markup_position.start_row
+    end
+
+    def inner_markup_start_column
+      inner_markup_position.start_column
+    end
+
+    def inner_markup_end_row
+      inner_markup_position.end_row
+    end
+
+    def inner_markup_end_column
+      inner_markup_position.end_column
+    end
+
     WHITESPACE = /\s/
 
     # Is this node inside a `{% liquid ... %}` block?
@@ -165,21 +309,37 @@ module ThemeCheck
     end
 
     def start_token
-      return "" if inside_liquid_tag?
-      output = ""
-      output += "{{" if variable?
-      output += "{%" if tag?
-      output += "-" if whitespace_trimmed_start?
-      output
+      if inside_liquid_tag?
+        ""
+      elsif variable? && source[start_index - 3..start_index - 1] == "{{-"
+        "{{-"
+      elsif variable? && source[start_index - 2..start_index - 1] == "{{"
+        "{{"
+      elsif tag? && whitespace_trimmed_start?
+        "{%-"
+      elsif tag?
+        "{%"
+      else
+        ""
+      end
     end
 
     def end_token
-      return "" if inside_liquid_tag?
-      output = ""
-      output += "-" if whitespace_trimmed_end?
-      output += "}}" if variable?
-      output += "%}" if tag?
-      output
+      if inside_liquid_tag? && source[end_index] == "\n"
+        "\n"
+      elsif inside_liquid_tag?
+        ""
+      elsif variable? && source[end_index...end_index + 3] == "-}}"
+        "-}}"
+      elsif variable? && source[end_index...end_index + 2] == "}}"
+        "}}"
+      elsif tag? && whitespace_trimmed_end?
+        "-%}"
+      elsif tag?
+        "%}"
+      else # this could happen because we're in an assign statement (variable)
+        ""
+      end
     end
 
     private
@@ -192,6 +352,22 @@ module ThemeCheck
       )
     end
 
+    def outer_markup_position
+      @outer_markup_position ||= StrictPosition.new(
+        outer_markup,
+        source,
+        block_start_start_index,
+      )
+    end
+
+    def inner_markup_position
+      @inner_markup_position ||= StrictPosition.new(
+        inner_markup,
+        source,
+        block_start_end_index,
+      )
+    end
+
     # Here we're hacking around a glorious bug in Liquid that makes it so the
     # line_number and markup of a tag is wrong if there's whitespace
     # between the tag_name and the markup of the tag.
@@ -287,5 +463,72 @@ module ThemeCheck
       # return the real raw content
       @tag_markup = source[tag_start...markup_end]
     end
+
+    # Returns the index of the leftmost consecutive whitespace
+    # starting from start going backwards.
+    #
+    # e.g. backtrack_on_whitespace("01  45", 4) would return 2.
+    # e.g. backtrack_on_whitespace("{%   render %}", 5) would return 2.
+    def backtrack_on_whitespace(string, start, whitespace = WHITESPACE)
+      i = start
+      i -= 1 while string[i - 1] =~ whitespace && i > 0
+      i
+    end
+
+    def find_block_delimiter(start_index)
+      return nil unless tag? && block?
+
+      tag_start, tag_end = if inside_liquid_tag?
+        [
+          /^\s*#{@value.tag_name}\s*/,
+          /^\s*end#{@value.tag_name}\s*/,
+        ]
+      else
+        [
+          /#{Liquid::TagStart}-?\s*#{@value.tag_name}/mi,
+          /#{Liquid::TagStart}-?\s*end#{@value.tag_name}\s*-?#{Liquid::TagEnd}/mi,
+        ]
+      end
+
+      # This little algorithm below find the _correct_ block delimiter
+      # (endif, endcase, endcomment) for the current tag. What do I
+      # mean by correct? It means the one you'd expect. Making sure
+      # that we don't do the naive regex find. Since you can have
+      # nested ifs, fors, etc.
+      #
+      # It works by having a stack, pushing onto the stack when we
+      # open a tag of our type_name. And popping when we find a
+      # closing tag of our type_name.
+      #
+      # When the stack is empty, we return the end tag match.
+      index = start_index
+      stack = []
+      stack.push("open")
+      loop do
+        tag_start_match = tag_start.match(source, index)
+        tag_end_match = tag_end.match(source, index)
+
+        return nil unless tag_end_match
+
+        # We have found a tag_start and it appeared _before_ the
+        # tag_end that we found, thus we push it onto the stack.
+        if tag_start_match && tag_start_match.end(0) < tag_end_match.end(0)
+          stack.push("open")
+        end
+
+        # We have found a tag_end, therefore we pop
+        stack.pop
+
+        # Nothing left on the stack, we're done.
+        break tag_end_match if stack.empty?
+
+        # We keep looking from the end of the end tag we just found.
+        index = tag_end_match.end(0)
+      end
+    end
+
+    def block_end_match
+      @block_end_match ||= find_block_delimiter(block_start_end_index)
+    end
   end
 end