platformos-check 0.0.1

data/lib/platformos_check/language_server/server.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'stringio'
+require 'timeout'
+
+module PlatformosCheck
+  module LanguageServer
+    class DoneStreaming < StandardError; end
+
+    class IncompatibleStream < StandardError; end
+
+    class Server
+      attr_reader :handler, :should_raise_errors
+
+      def initialize(
+        messenger:,
+        should_raise_errors: false,
+        number_of_threads: 2
+      )
+        # This is what does the IO
+        @messenger = messenger
+
+        # This is what you use to communicate with the language client
+        @bridge = Bridge.new(@messenger)
+
+        # The handler handles messages from the language client
+        @handler = Handler.new(@bridge)
+
+        # The queue holds the JSON RPC messages
+        @queue = Queue.new
+
+        # The JSON RPC thread pushes messages onto the queue
+        @json_rpc_thread = nil
+
+        # The handler threads read messages from the queue
+        @number_of_threads = number_of_threads
+        @handlers = []
+
+        # The error queue holds blocks the main thread. When filled, we exit the program.
+        @error = SizedQueue.new(number_of_threads)
+
+        @should_raise_errors = should_raise_errors
+      end
+
+      def listen
+        start_handler_threads
+        start_json_rpc_thread
+        err = @error.pop
+        status_code = status_code_from_error(err)
+
+        if status_code > 0
+          # For a reason I can't comprehend, this hangs but prints
+          # anyway. So it's wrapped in this ugly timeout...
+          Timeout.timeout(1) do
+            warn err.full_message
+          end
+
+          # Warn user of error, otherwise server might restart
+          # without telling you.
+          @bridge.send_notification("window/showMessage", {
+                                      type: 1,
+                                      message: "A platformos-check-language-server error has occurred, search OUTPUT logs for details."
+                                    })
+        end
+
+        cleanup(status_code)
+      rescue SignalException
+        0
+      rescue StandardError
+        2
+      end
+
+      def start_json_rpc_thread
+        @json_rpc_thread = Thread.new do
+          loop do
+            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
+          end
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          @bridge.log("rescuing #{e.class} in jsonrpc thread")
+          @error << e
+        end
+      end
+
+      def start_handler_threads
+        @number_of_threads.times do
+          @handlers << Thread.new do
+            handle_messages
+          end
+        end
+      end
+
+      def handle_messages
+        loop do
+          message = @queue.pop
+          return if @queue.closed? && @queue.empty?
+
+          handle_message(message)
+        end
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        @bridge.log("rescuing #{e} in handler thread")
+        @error << e
+      end
+
+      def status_code_from_error(e)
+        raise e
+
+      # support ctrl+c and stuff
+      rescue SignalException, DoneStreaming
+        0
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        raise e if should_raise_errors
+
+        @bridge.log("Fatal #{e.class}")
+        2
+      end
+
+      private
+
+      def handle_message(message)
+        id = message[:id]
+        method_name = message[:method]
+        method_name &&= "on_#{to_snake_case(method_name)}"
+        params = message[:params]
+
+        @handler.send(method_name, id, params) if @handler.respond_to?(method_name)
+      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.send_internal_error(id, e)
+      end
+
+      def handle_response(message)
+        id = message[:id]
+        result = message[:result]
+        @bridge.receive_response(id, result)
+      end
+
+      def to_snake_case(method_name)
+        StringHelpers.underscore(method_name.gsub(/[^\w]/, '_'))
+      end
+
+      def cleanup(status_code)
+        @bridge.log("Closing server... status code = #{status_code}")
+        # Stop listenting to RPC calls
+        @messenger.close_input
+        # Wait for rpc loop to close
+        @json_rpc_thread&.join if @json_rpc_thread&.alive?
+        # Close the queue
+        @queue.close unless @queue.closed?
+        # 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
+        @messenger.close_output
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/tokens.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  Token = Struct.new(
+    :content,
+    :start, # inclusive
+    :end # exclusive
+  )
+
+  TAG_START = Liquid::TagStart
+  TAG_END = Liquid::TagEnd
+  VARIABLE_START = Liquid::VariableStart
+  VARIABLE_END = Liquid::VariableEnd
+  SPLITTER = %r{
+    (?=(?:#{TAG_START}|#{VARIABLE_START}))| # positive lookahead on tag/variable start
+    (?<=(?:#{TAG_END}|#{VARIABLE_END}))     # positive lookbehind on tag/variable end
+  }xom
+
+  # Implemented as an Enumerable so we stop iterating on the find once
+  # we have what we want. Kind of a perf thing.
+  class Tokens
+    include Enumerable
+
+    def initialize(buffer)
+      @buffer = buffer
+    end
+
+    def each(&block)
+      return to_enum(:each) unless block
+
+      chunks = @buffer.split(SPLITTER)
+      chunks.shift if chunks[0] && chunks[0].empty?
+
+      prev = Token.new('', 0, 0)
+      curr = Token.new('', 0, 0)
+
+      while (content = chunks.shift)
+
+        curr.start = prev.end
+        curr.end = curr.start + content.size
+
+        yield(Token.new(
+          content,
+          curr.start,
+          curr.end
+        ))
+
+        # recycling structs
+        tmp = prev
+        prev = curr
+        curr = tmp
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/type_helper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    module TypeHelper
+      def input_type_of(literal)
+        case literal
+        when String
+          'string'
+        when Numeric
+          'number'
+        when TrueClass, FalseClass
+          'boolean'
+        when NilClass
+          'nil'
+        else
+          'untyped'
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/uri_helper.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "benchmark"
+require "uri"
+require "cgi"
+
+module PlatformosCheck
+  module LanguageServer
+    module URIHelper
+      # Will URI.encode a string the same way VS Code would. There are two things
+      # to watch out for:
+      #
+      # 1. VS Code still uses the outdated '%20' for spaces
+      # 2. VS Code prefixes Windows paths with / (so /C:/Users/... is expected)
+      #
+      # Exists because of https://github.com/Platform-OS/platformos-lsp/issues/360
+      def file_uri(absolute_path)
+        return if absolute_path.nil?
+
+        "file://" + absolute_path
+                    .to_s
+                    .split('/')
+                    .map { |x| CGI.escape(x).gsub('+', '%20') }
+                    .join('/')
+                    .sub(%r{^/?}, '/') # Windows paths should be prefixed by /c:
+      end
+
+      def file_path(uri_string)
+        return if uri_string.nil?
+
+        uri = URI(uri_string)
+        path = CGI.unescape(uri.path)
+        # On Windows, VS Code sends the URLs as file:///C:/...
+        # /C:/1234 is not a valid path in ruby. So we strip the slash.
+        path.sub(%r{^/([a-z]:/)}i, '\1')
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/variable_lookup_finder/assignments_finder/node_handler.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    module VariableLookupFinder
+      class AssignmentsFinder
+        class NodeHandler
+          def on_assign(node, scope)
+            # When a variable is redefined in a new scope we
+            # no longer can guarantee the type in the global scope
+            #
+            # Example:
+            # ```liquid
+            # {%- liquid
+            #   assign var1 = some_value
+            #
+            #   if condition
+            #     assign var1 = another_value
+            #            ^^^^ from here we no longer can guarantee
+            #                 the type of `var1` in the global scope
+            # -%}
+            # ```
+            p_scope = scope
+            while (p_scope = p_scope.parent)
+              p_scope.variables.delete(node.value.to)
+            end
+
+            scope << node
+            scope
+          end
+
+          def on_function(node, scope)
+            # When a variable is redefined in a new scope we
+            # no longer can guarantee the type in the global scope
+            #
+            # Example:
+            # ```liquid
+            # {%- liquid
+            #   assign var1 = some_value
+            #
+            #   if condition
+            #     function var1 = 'another_value'
+            #            ^^^^ from here we no longer can guarantee
+            #                 the type of `var1` in the global scope
+            # -%}
+            # ```
+            p_scope = scope
+            while (p_scope = p_scope.parent)
+              p_scope.variables.delete(node.value.to)
+            end
+
+            scope << node
+            scope
+          end
+
+          ##
+          # Table row tags do not rely on blocks to define scopes,
+          # so we index their value here
+          def on_table_row(node, scope)
+            scope = scope.new_child
+
+            scope << node
+            scope
+          end
+
+          ##
+          # Define a new scope every time a new block is created
+          def on_block_body(node, scope)
+            scope = scope.new_child
+
+            ##
+            # 'for' tags handle blocks flattenly and differently
+            # than the other tags (if, unless, case).
+            #
+            # The scope of 'for' tags exists only in the first
+            # block, as the following one refers to the else
+            # statement of the iteration.
+            parent = node.parent
+
+            scope << parent if parent.type_name == :for && parent.children.first == node
+            scope
+          end
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/variable_lookup_finder/assignments_finder/scope.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    module VariableLookupFinder
+      class AssignmentsFinder
+        class Scope < Struct.new(:variables, :parent)
+          include TypeHelper
+
+          def new_child
+            child_scope = dup
+            child_scope.variables = variables.dup
+            child_scope.parent = self
+            child_scope
+          end
+
+          def <<(node)
+            tag = node.value
+
+            case tag
+            when Liquid::Assign
+              variable_name = tag.to
+              variables[variable_name] = as_potential_lookup(tag.from.name)
+            when Liquid::For, Liquid::TableRow
+              variable_name = tag.variable_name
+              variables[variable_name] = as_potential_lookup(tag.collection_name, ['first'])
+            end
+          end
+
+          private
+
+          def as_potential_lookup(variable_lookup, default_lookups = [])
+            case variable_lookup
+            when Liquid::VariableLookup
+              potential_lookup(variable_lookup, default_lookups)
+            when Liquid::RangeLookup
+              as_potential_lookup(variable_lookup.start_obj)
+            when Enumerable
+              as_potential_lookup(variable_lookup.first)
+            else
+              literal_lookup(variable_lookup)
+            end
+          end
+
+          def literal_lookup(variable_lookup)
+            name = input_type_of(variable_lookup)
+            PotentialLookup.new(name, [], variables)
+          end
+
+          def potential_lookup(variable_lookup, default_lookups)
+            name = variable_lookup.name
+            lookups = variable_lookup.lookups.concat(default_lookups)
+
+            PotentialLookup.new(name, lookups, variables)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/variable_lookup_finder/assignments_finder/scope_visitor.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    module VariableLookupFinder
+      class AssignmentsFinder
+        class ScopeVisitor
+          SCOPE_UNAWARE_NODES = %i[range range_lookup variable variable_lookup]
+
+          attr_reader :global_scope, :current_scope
+
+          def initialize
+            @node_handler = NodeHandler.new
+            @global_scope = Scope.new({})
+            @current_scope = Scope.new({})
+          end
+
+          def visit_template(template)
+            return unless template
+
+            visit(liquid_node(template), global_scope)
+          end
+
+          private
+
+          def visit(node, scope)
+            return if SCOPE_UNAWARE_NODES.include?(node.type_name)
+
+            method = :"on_#{node.type_name}"
+            scope = @node_handler.send(method, node, scope) if @node_handler.respond_to?(method)
+
+            @current_scope = scope
+
+            node.children.each { |child| visit(child, scope) }
+          end
+
+          def liquid_node(template)
+            LiquidNode.new(template.root, nil, template)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/variable_lookup_finder/assignments_finder.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    module VariableLookupFinder
+      class AssignmentsFinder
+        include RegexHelpers
+
+        attr_reader :content, :scope_visitor
+
+        def initialize(content)
+          @content = close_tag(content)
+          @scope_visitor = ScopeVisitor.new
+        end
+
+        def find!
+          template = parse(content)
+
+          if template
+            visit_template(template)
+            return
+          end
+
+          liquid_tags.each do |tag|
+            visit_template(last_line_parse(tag))
+          end
+        end
+
+        def assignments
+          current_scope = scope_visitor.current_scope
+          current_scope.variables
+        end
+
+        private
+
+        def visit_template(template)
+          scope_visitor.visit_template(template)
+        end
+
+        def liquid_tags
+          matches(content, LIQUID_TAG_OR_VARIABLE)
+            .flat_map { |match| match[0] }
+        end
+
+        def parse(content)
+          regular_parse(content) || tolerant_parse(content)
+        end
+
+        def regular_parse(content)
+          Liquid::Template.parse(content)
+        rescue Liquid::SyntaxError
+          # Ignore syntax errors at the regular parse phase
+        end
+
+        def tolerant_parse(content)
+          TolerantParser::Template.parse(content)
+        rescue StandardError
+          # Ignore any error at the tolerant parse phase
+        end
+
+        def last_line_parse(content)
+          parsable_content = LiquidFixer.new(content).parsable
+
+          regular_parse(parsable_content)
+        end
+
+        def close_tag(content)
+          lines = content.lines
+          end_tag = VARIABLE_START.match?(lines.last) ? ' }}' : ' %}'
+
+          content + end_tag
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/variable_lookup_finder/constants.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    module VariableLookupFinder
+      module Constants
+        ANY_STARTING_TAG = /\s*#{Liquid::AnyStartingTag}/
+        ANY_ENDING_TAG = /#{Liquid::TagEnd}|#{Liquid::VariableEnd}\s*^/om
+
+        UNCLOSED_SQUARE_BRACKET = /\[[^\]]*\Z/
+        ENDS_IN_BRACKET_POSITION_THAT_CANT_BE_COMPLETED = /
+          (
+            # quotes not preceded by a [
+            (?<!\[)['"]|
+            # closing ]
+            \]|
+            # opening [
+            \[
+          )$
+        /x
+
+        VARIABLE_START = /\s*#{Liquid::VariableStart}/
+        VARIABLE_LOOKUP_CHARACTERS = /[a-z0-9_.'"\]\[]/i
+        VARIABLE_LOOKUP = /#{VARIABLE_LOOKUP_CHARACTERS}+/o
+        SYMBOLS_PRECEDING_POTENTIAL_LOOKUPS = /
+          (?:
+            \s(?:
+              if|elsif|unless|and|or|#{Liquid::Condition.operators.keys.join("|")}
+              |echo
+              |paginate
+              |case|when
+              |cycle
+              |in
+            )
+            |[:,=]
+          )
+          \s+
+        /omix
+        ENDS_WITH_BLANK_POTENTIAL_LOOKUP = /#{SYMBOLS_PRECEDING_POTENTIAL_LOOKUPS}$/oimx
+        ENDS_WITH_POTENTIAL_LOOKUP = /#{SYMBOLS_PRECEDING_POTENTIAL_LOOKUPS}#{VARIABLE_LOOKUP}$/oimx
+      end
+    end
+  end
+end