platformos-check 0.0.1

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    module VariableLookupFinder
+      ##
+      # Attempt to turn the code of the token until the cursor position into
+      # valid liquid code.
+      #
+      class LiquidFixer
+        include Constants
+
+        attr_reader :content, :cursor
+
+        def initialize(content, cursor = nil)
+          @content = content
+          @cursor = cursor || content.size
+        end
+
+        def parsable
+          # Welcome to Hackcity
+          @markup = content[0...cursor]
+
+          catch(:empty_lookup_markup) do
+            # close open delimiters
+            @markup += "'" if @markup.count("'").odd?
+            @markup += '"' if @markup.count('"').odd?
+            @markup += "]" if UNCLOSED_SQUARE_BRACKET.match?(@markup)
+
+            @ends_with_blank_potential_lookup = @markup =~ ENDS_WITH_BLANK_POTENTIAL_LOOKUP
+            @markup = last_line if liquid_tag?
+
+            @markup = "{% #{@markup}" unless has_start_tag?
+
+            # close the tag
+            @markup += tag_end unless has_end_tag?
+
+            # close if statements
+            @markup += '{% endif %}' if tag?('if')
+
+            # close unless statements
+            @markup += '{% endunless %}' if tag?('unless')
+
+            # close elsif statements
+            @markup = "{% if x %}#{@markup}{% endif %}" if tag?('elsif')
+
+            # close case statements
+            @markup += '{% endcase %}' if tag?('case')
+
+            # close when statements
+            @markup = "{% case x %}#{@markup}{% endcase %}" if tag?('when')
+
+            # close for statements
+            @markup += '{% endfor %}' if tag?('for')
+
+            # close tablerow statements
+            @markup += '{% endtablerow %}' if tag?('tablerow')
+
+            @markup
+          end
+        end
+
+        private
+
+        def tag?(tag_name)
+          if @markup&.match?(tag_regex(tag_name))
+            throw(:empty_lookup_markup, '') if @ends_with_blank_potential_lookup
+            true
+          else
+            false
+          end
+        end
+
+        def last_line
+          lines = @markup.rstrip.lines
+
+          last_line = lines.pop.lstrip while last_line.nil? || last_line =~ ANY_ENDING_TAG
+          last_line
+        end
+
+        def liquid_tag?
+          @markup =~ tag_regex('liquid')
+        end
+
+        def has_start_tag?
+          @markup =~ ANY_STARTING_TAG
+        end
+
+        def has_end_tag?
+          @markup =~ ANY_ENDING_TAG
+        end
+
+        def tag_end
+          VARIABLE_START.match?(@markup) ? ' }}' : ' %}'
+        end
+
+        def tag_regex(tag_name)
+          PlatformosLiquid::Tag.tag_regex(tag_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    module VariableLookupFinder
+      class PotentialLookup < Struct.new(:name, :lookups, :scope)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    module VariableLookupFinder
+      module TolerantParser
+        class Template
+          class << self
+            def parse(content)
+              ##
+              # The tolerant parser relies on a tolerant custom parse
+              # context to creates a new 'Template' object, even when
+              # a block is not closed.
+              Liquid::Template.parse(content, custom_parse_context)
+            end
+
+            private
+
+            def custom_parse_context
+              ParseContext.new
+            end
+          end
+        end
+
+        class ParseContext < Liquid::ParseContext
+          def new_block_body
+            BlockBody.new
+          end
+        end
+
+        class BlockBody < Liquid::BlockBody
+          ##
+          # The tags are statically defined and referenced at the
+          # 'Liquid::Template', so the TolerantParser just uses the
+          # redefined tags at this custom block body. Thus, there's
+          # no side-effects between the regular and the tolerant parsers.
+          def registered_tags
+            Tags.new(super)
+          end
+        end
+
+        class Tags
+          module TolerantBlockBody
+            ##
+            # This module defines the tolerant parse body that doesn't
+            # raise syntax errors when a block is not closed. Thus, the
+            # tolerant parser can build the AST for templates with this
+            # kind of error, which is quite common in language servers.
+            def parse_body(body, tokens)
+              super
+            rescue StandardError
+              false
+            end
+          end
+
+          class Case < Liquid::Case
+            include TolerantBlockBody
+          end
+
+          class For < Liquid::For
+            include TolerantBlockBody
+          end
+
+          class If < Liquid::If
+            include TolerantBlockBody
+          end
+
+          class TableRow < Liquid::TableRow
+            include TolerantBlockBody
+          end
+
+          class Unless < Liquid::Unless
+            include TolerantBlockBody
+          end
+
+          def initialize(standard_tags)
+            @standard_tags = standard_tags
+            @tolerant_tags = {
+              'case' => Case,
+              'for' => For,
+              'if' => If,
+              'tablerow' => TableRow,
+              'unless' => Unless
+            }
+          end
+
+          def [](key)
+            @tolerant_tags[key] || @standard_tags[key]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/variable_lookup_finder.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+module PlatformosCheck
+  module LanguageServer
+    module VariableLookupFinder
+      include Constants
+      include TypeHelper
+      extend self
+
+      def lookup(context)
+        content = context.content
+        cursor = context.cursor
+
+        return if cursor_is_on_bracket_position_that_cant_be_completed(content, cursor)
+
+        variable_lookup = lookup_liquid_variable(content, cursor) || lookup_liquid_tag(content, cursor)
+
+        return variable_lookup if variable_lookup.is_a?(PotentialLookup)
+        return unless variable_lookup.is_a?(Liquid::VariableLookup)
+
+        potential_lookup(variable_lookup, context)
+      end
+
+      def lookup_literal(context)
+        lookup_liquid_variable(context.content, context.cursor)
+      end
+
+      private
+
+      def potential_lookup(variable, context)
+        return as_potential_lookup(variable) if context.buffer.nil? || context.buffer.empty?
+
+        buffer = context.buffer[0...context.absolute_cursor]
+        lookups = variable.lookups
+        assignments = find_assignments(buffer)
+        assignments_path = []
+
+        while assignments[variable.name] && !assignments_path.include?(assignments[variable.name])
+          variable = assignments[variable.name]
+          lookups = variable.lookups + lookups
+
+          assignments_path << variable
+        end
+
+        as_potential_lookup(variable, lookups:)
+      end
+
+      def find_assignments(buffer)
+        finder = AssignmentsFinder.new(buffer)
+        finder.find!
+        finder.assignments
+      end
+
+      def as_potential_lookup(variable, lookups: nil)
+        PotentialLookup.new(variable.name, lookups || variable.lookups)
+      end
+
+      def cursor_is_on_bracket_position_that_cant_be_completed(content, cursor)
+        content_before_cursor = content[0..cursor - 1]
+        return false unless /[\[\]]/.match?(content_before_cursor)
+
+        content_before_cursor =~ ENDS_IN_BRACKET_POSITION_THAT_CANT_BE_COMPLETED
+      end
+
+      def cursor_is_on_liquid_variable_lookup_position(content, cursor)
+        previous_char = content[cursor - 1]
+        is_liquid_variable = content =~ Liquid::VariableStart
+        is_in_variable_segment = previous_char =~ VARIABLE_LOOKUP_CHARACTERS
+        is_on_blank_variable_lookup_position = content[0..cursor - 1] =~ /[{:,-]\s+$/
+        (
+          is_liquid_variable && (
+            is_in_variable_segment ||
+            is_on_blank_variable_lookup_position
+          )
+        )
+      end
+
+      def lookup_liquid_variable(content, cursor)
+        return unless cursor_is_on_liquid_variable_lookup_position(content, cursor)
+
+        start_index = content.match(/#{Liquid::VariableStart}-?/o).end(0) + 1
+        end_index = cursor - 1
+
+        # We take the following content
+        # - start after the first two {{
+        # - end at cursor position
+        #
+        # That way, we'll have a partial liquid variable that
+        # can be parsed such that the "last" variable_lookup
+        # will be the one we're trying to complete.
+        markup = content[start_index..end_index]
+
+        # Early return for incomplete variables
+        return empty_lookup if /\s+$/.match?(markup)
+
+        # Now we go to hack city... The cursor might be in the middle
+        # of a string/square bracket lookup. We need to close those
+        # otherwise the variable parse won't work.
+        markup += "'" if markup.count("'").odd?
+        markup += '"' if markup.count('"').odd?
+        markup += "]" if UNCLOSED_SQUARE_BRACKET.match?(markup)
+
+        variable = variable_from_markup(markup)
+
+        variable_lookup_for_liquid_variable(variable)
+      end
+
+      def cursor_is_on_liquid_tag_lookup_position(content, cursor)
+        markup = content[0..cursor - 1]
+        is_liquid_tag = content.match?(Liquid::TagStart)
+        is_in_variable_segment = markup =~ ENDS_WITH_POTENTIAL_LOOKUP
+        is_on_blank_variable_lookup_position = markup =~ ENDS_WITH_BLANK_POTENTIAL_LOOKUP
+        (
+          is_liquid_tag && (
+            is_in_variable_segment ||
+            is_on_blank_variable_lookup_position
+          )
+        )
+      end
+
+      # Context:
+      #
+      # We know full well that the code as it is being typed is probably not
+      # something that can be parsed by liquid.
+      #
+      # How this works:
+      #
+      # 1. Attempt to turn the code of the token until the cursor position into
+      #    valid liquid code with some hacks.
+      # 2. If the code ends in space at a "potential lookup" spot
+      #   a. Then return an empty variable lookup
+      # 3. Parse the valid liquid code
+      # 4. Attempt to extract a VariableLookup from Liquid::Template
+      def lookup_liquid_tag(content, cursor)
+        return unless cursor_is_on_liquid_tag_lookup_position(content, cursor)
+
+        markup = parseable_markup(content, cursor)
+        return empty_lookup if markup.empty?
+
+        template = Liquid::Template.parse(markup)
+        current_tag = template.root.nodelist[0]
+
+        case current_tag&.tag_name
+        when "if", "unless"
+          variable_lookup_for_if_tag(current_tag)
+        when "case"
+          variable_lookup_for_case_tag(current_tag)
+        when "cycle"
+          variable_lookup_for_cycle_tag(current_tag)
+        when "for"
+          variable_lookup_for_for_tag(current_tag)
+        when "tablerow"
+          variable_lookup_for_tablerow_tag(current_tag)
+        when "render"
+          variable_lookup_for_render_tag(current_tag)
+        when "assign"
+          variable_lookup_for_assign_tag(current_tag)
+        when "echo"
+          variable_lookup_for_echo_tag(current_tag)
+        else
+          empty_lookup
+        end
+      rescue Liquid::SyntaxError
+        # We don't complete variable for liquid syntax errors
+        empty_lookup
+      end
+
+      def parseable_markup(content, cursor = nil)
+        LiquidFixer.new(content, cursor).parsable
+      end
+
+      def variable_lookup_for_if_tag(if_tag)
+        condition = if_tag.blocks.last
+        variable_lookup_for_condition(condition)
+      end
+
+      def variable_lookup_for_condition(condition)
+        return variable_lookup_for_condition(condition.child_condition) if condition.child_condition
+        return condition.right if condition.right
+
+        condition.left
+      end
+
+      def variable_lookup_for_case_tag(case_tag)
+        return variable_lookup_for_case_block(case_tag.blocks.last) unless case_tag.blocks.empty?
+
+        case_tag.left
+      end
+
+      def variable_lookup_for_case_block(condition)
+        condition.right
+      end
+
+      def variable_lookup_for_cycle_tag(cycle_tag)
+        cycle_tag.variables.last
+      end
+
+      def variable_lookup_for_for_tag(for_tag)
+        for_tag.collection_name
+      end
+
+      def variable_lookup_for_tablerow_tag(tablerow_tag)
+        tablerow_tag.collection_name
+      end
+
+      def variable_lookup_for_render_tag(render_tag)
+        return empty_lookup if /:\s*$/.match?(render_tag.raw)
+
+        render_tag.attributes.values.last
+      end
+
+      def variable_lookup_for_assign_tag(assign_tag)
+        variable_lookup_for_liquid_variable(assign_tag.from)
+      end
+
+      def variable_lookup_for_echo_tag(echo_tag)
+        variable_lookup_for_liquid_variable(echo_tag.variable)
+      end
+
+      def variable_lookup_for_liquid_variable(variable)
+        has_filters = !variable.filters.empty?
+
+        # Can complete after trailing comma or :
+        if has_filters && variable.raw =~ /[:,]\s*$/
+          empty_lookup
+        elsif has_filters
+          last_filter_argument(variable.filters)
+        elsif variable.name.nil?
+          empty_lookup
+        elsif variable.name.is_a?(Liquid::VariableLookup)
+          variable.name
+        else
+          PotentialLookup.new(input_type_of(variable.name), [])
+        end
+      end
+
+      def empty_lookup
+        Liquid::VariableLookup.parse('')
+      end
+
+      # We want the last thing in variable.filters which is at most
+      # an array that looks like [name, positional_args, hash_arg]
+      def last_filter_argument(filters)
+        filter = filters.last
+        return filter[2].values.last if filter.size == 3
+        return filter[1].last if filter.size == 2
+
+        nil
+      end
+
+      def variable_from_markup(markup, parse_context = Liquid::ParseContext.new)
+        Liquid::Variable.new(markup, parse_context)
+      end
+
+      def tag_regex(tag)
+        PlatformosLiquid::Tag.tag_regex(tag)
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/variable_lookup_traverser.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    module VariableLookupTraverser
+      extend self
+
+      def lookup_object_and_property(potential_lookup)
+        object, generic_type = find_object_and_generic_type(potential_lookup)
+        property = nil
+
+        potential_lookup.lookups.each do |name|
+          prop = find_property(object, name)
+
+          next unless prop
+
+          generic_type = generic_type(prop) if generic_type?(prop)
+
+          property = prop
+          property.return_type = generic_type if prop.generic_type?
+          object = find_object(prop.return_type)
+        end
+
+        [object, property]
+      end
+
+      def find_object_and_generic_type(potential_lookup)
+        generic_type = nil
+        object = find_object(potential_lookup.name)
+
+        # Objects like 'product' are a complex structure with fields
+        # and their return type is not present.
+        #
+        # However, we also handle objects that have simple built-in types,
+        # like 'current_tags', which is an 'array'. So, we follow them until
+        # the source type:
+        while object&.return_type
+          generic_type = generic_type(object) if generic_type?(object)
+          object = find_object(object.return_type)
+        end
+
+        [object, generic_type]
+      end
+
+      # Currently, we're handling generic types only for arrays,
+      # so we get the array type
+      def generic_type(object)
+        object.array_type
+      end
+
+      # Currently, we're handling generic types only for arrays,
+      # so we check if it's an array type
+      def generic_type?(object)
+        object.array_type?
+      end
+
+      def find_property(object, property_name)
+        object
+          &.properties
+          &.find { |property| property.name == property_name }
+      end
+
+      def find_object(object_name)
+        PlatformosLiquid::SourceIndex
+          .objects
+          .find { |entry| entry.name == object_name }
+      end
+    end
+  end
+end

data/lib/platformos_check/language_server/versioned_in_memory_storage.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class VersionedInMemoryStorage < InMemoryStorage
+    Version = Struct.new(:id, :version)
+
+    attr_reader :versions
+
+    def initialize(files, root = "/dev/null")
+      super(files, root)
+      @versions = {} # Hash<relative_path, number>
+      @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 AppFile 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
+        if version.nil?
+          @versions.delete(relative_path)
+        else
+          @versions[relative_path] = version
+        end
+        super(relative_path, content)
+      end
+    end
+
+    def read_version(relative_path)
+      @mutex.synchronize { [read(relative_path), version(relative_path)] }
+    end
+
+    def remove(relative_path)
+      @mutex.synchronize do
+        @versions.delete(relative_path)
+        super(relative_path)
+      end
+    end
+
+    def versioned?
+      true
+    end
+
+    def version(relative_path)
+      @versions[relative_path.to_s]
+    end
+
+    def opened_files
+      @versions.keys
+    end
+  end
+end

data/lib/platformos_check/language_server.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "language_server/protocol"
+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/type_helper"
+require_relative "language_server/server"
+require_relative "language_server/tokens"
+require_relative "language_server/variable_lookup_finder/potential_lookup"
+require_relative "language_server/variable_lookup_finder/tolerant_parser"
+require_relative "language_server/variable_lookup_finder/assignments_finder/node_handler"
+require_relative "language_server/variable_lookup_finder/assignments_finder/scope_visitor"
+require_relative "language_server/variable_lookup_finder/assignments_finder/scope"
+require_relative "language_server/variable_lookup_finder/assignments_finder"
+require_relative "language_server/variable_lookup_finder/constants"
+require_relative "language_server/variable_lookup_finder/liquid_fixer"
+require_relative "language_server/variable_lookup_finder"
+require_relative "language_server/variable_lookup_traverser"
+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_context"
+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/hover_provider"
+require_relative "language_server/hover_engine"
+Dir[__dir__ + "/language_server/hover_providers/*.rb"].each do |file|
+  require file
+end
+
+require_relative "language_server/document_link_provider"
+require_relative "language_server/document_link_engine"
+Dir[__dir__ + "/language_server/document_link_providers/*.rb"].each do |file|
+  require file
+end
+
+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
+
+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 PlatformosCheck
+  module LanguageServer
+    def self.start
+      Server.new(messenger: IOMessenger.new).listen
+    end
+  end
+end