theme-check 1.11.0 → 1.12.1

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  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 = lines.last =~ VARIABLE_START ? ' }}' : ' %}'
+
+          content + end_tag
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  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 = %r{
+          (
+            # 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 = %r{
+          (?:
+            \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

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  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 @markup =~ UNCLOSED_SQUARE_BRACKET
+
+            @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 =~ 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
+          @markup =~ VARIABLE_START ? ' }}' : ' %}'
+        end
+
+        def tag_regex(tag_name)
+          ShopifyLiquid::Tag.tag_regex(tag_name)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  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
+
+          class Paginate < Liquid::Tag
+            include TolerantBlockBody
+          end
+
+          class Form < Liquid::Tag
+            include TolerantBlockBody
+          end
+
+          class Style < Liquid::Tag
+            include TolerantBlockBody
+          end
+
+          class Stylesheet < Liquid::Tag
+            include TolerantBlockBody
+          end
+
+          def initialize(standard_tags)
+            @standard_tags = standard_tags
+            @tolerant_tags = {
+              'case' => Case,
+              'for' => For,
+              'form' => Form,
+              'if' => If,
+              'paginate' => Paginate,
+              'style' => Style,
+              'stylesheet' => Stylesheet,
+              'tablerow' => TableRow,
+              'unless' => Unless,
+            }
+          end
+
+          def [](key)
+            @tolerant_tags[key] || @standard_tags[key]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/theme_check/language_server/variable_lookup_finder.rb

@@ -1,53 +1,67 @@
 # frozen_string_literal: true
 
+require 'ostruct'
+
 module ThemeCheck
   module LanguageServer
     module VariableLookupFinder
+      include Constants
+      include TypeHelper
       extend self
 
-      UNCLOSED_SQUARE_BRACKET = /\[[^\]]*\Z/
-      ENDS_IN_BRACKET_POSITION_THAT_CANT_BE_COMPLETED = %r{
-        (
-          # quotes not preceded by a [
-          (?<!\[)['"]|
-          # closing ]
-          \]|
-          # opening [
-          \[
-        )$
-      }x
-
-      VARIABLE_LOOKUP_CHARACTERS = /[a-z0-9_.'"\]\[]/i
-      VARIABLE_LOOKUP = /#{VARIABLE_LOOKUP_CHARACTERS}+/o
-      SYMBOLS_PRECEDING_POTENTIAL_LOOKUPS = %r{
-        (?:
-          \s(?:
-            if|elsif|unless|and|or|#{Liquid::Condition.operators.keys.join("|")}
-            |echo
-            |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
+      def lookup(context)
+        content = context.content
+        cursor = context.cursor
 
-      def lookup(content, cursor)
         return if cursor_is_on_bracket_position_that_cant_be_completed(content, cursor)
-        potential_lookup = lookup_liquid_variable(content, cursor) || lookup_liquid_tag(content, cursor)
 
-        # And we only return it if it's parsed by Liquid as VariableLookup
-        return unless potential_lookup.is_a?(Liquid::VariableLookup)
-        potential_lookup
+        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: 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[0..cursor - 1] =~ ENDS_IN_BRACKET_POSITION_THAT_CANT_BE_COMPLETED
+        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)
@@ -65,6 +79,7 @@ module ThemeCheck
 
       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
 
@@ -78,14 +93,14 @@ module ThemeCheck
         markup = content[start_index..end_index]
 
         # Early return for incomplete variables
-        return empty_lookup if markup =~ /\s+$/
+        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 markup =~ UNCLOSED_SQUARE_BRACKET
+        markup += "]" if UNCLOSED_SQUARE_BRACKET.match?(markup)
 
         variable = variable_from_markup(markup)
 
@@ -122,12 +137,12 @@ module ThemeCheck
         return unless cursor_is_on_liquid_tag_lookup_position(content, cursor)
 
         markup = parseable_markup(content, cursor)
-        return empty_lookup if markup == :empty_lookup_markup
+        return empty_lookup if markup.empty?
 
         template = Liquid::Template.parse(markup)
         current_tag = template.root.nodelist[0]
 
-        case current_tag.tag_name
+        case current_tag&.tag_name
         when "if", "unless"
           variable_lookup_for_if_tag(current_tag)
         when "case"
@@ -144,70 +159,16 @@ module ThemeCheck
           variable_lookup_for_assign_tag(current_tag)
         when "echo"
           variable_lookup_for_echo_tag(current_tag)
+        else
+          empty_lookup
         end
-
-      # rubocop:disable Style/RedundantReturn
       rescue Liquid::SyntaxError
         # We don't complete variable for liquid syntax errors
-        return
+        empty_lookup
       end
-      # rubocop:enable Style/RedundantReturn
-
-      def parseable_markup(content, cursor)
-        start_index = 0
-        end_index = cursor - 1
-        markup = content[start_index..end_index]
 
-        # Welcome to Hackcity
-        markup += "'" if markup.count("'").odd?
-        markup += '"' if markup.count('"').odd?
-        markup += "]" if markup =~ UNCLOSED_SQUARE_BRACKET
-
-        # Now check if it's a liquid tag
-        is_liquid_tag = markup =~ tag_regex('liquid')
-        ends_with_blank_potential_lookup = markup =~ ENDS_WITH_BLANK_POTENTIAL_LOOKUP
-        last_line = markup.rstrip.lines.last
-        markup = "{% #{last_line}" if is_liquid_tag
-
-        # Close the tag
-        markup += ' %}'
-
-        # if statements
-        is_if_tag = markup =~ tag_regex('if')
-        return :empty_lookup_markup if is_if_tag && ends_with_blank_potential_lookup
-        markup += '{% endif %}' if is_if_tag
-
-        # unless statements
-        is_unless_tag = markup =~ tag_regex('unless')
-        return :empty_lookup_markup if is_unless_tag && ends_with_blank_potential_lookup
-        markup += '{% endunless %}' if is_unless_tag
-
-        # elsif statements
-        is_elsif_tag = markup =~ tag_regex('elsif')
-        return :empty_lookup_markup if is_elsif_tag && ends_with_blank_potential_lookup
-        markup = '{% if x %}' + markup + '{% endif %}' if is_elsif_tag
-
-        # case statements
-        is_case_tag = markup =~ tag_regex('case')
-        return :empty_lookup_markup if is_case_tag && ends_with_blank_potential_lookup
-        markup += "{% endcase %}" if is_case_tag
-
-        # when
-        is_when_tag = markup =~ tag_regex('when')
-        return :empty_lookup_markup if is_when_tag && ends_with_blank_potential_lookup
-        markup = "{% case x %}" + markup + "{% endcase %}" if is_when_tag
-
-        # for statements
-        is_for_tag = markup =~ tag_regex('for')
-        return :empty_lookup_markup if is_for_tag && ends_with_blank_potential_lookup
-        markup += "{% endfor %}" if is_for_tag
-
-        # tablerow statements
-        is_tablerow_tag = markup =~ tag_regex('tablerow')
-        return :empty_lookup_markup if is_tablerow_tag && ends_with_blank_potential_lookup
-        markup += "{% endtablerow %}" if is_tablerow_tag
-
-        markup
+      def parseable_markup(content, cursor = nil)
+        LiquidFixer.new(content, cursor).parsable
       end
 
       def variable_lookup_for_if_tag(if_tag)
@@ -218,11 +179,13 @@ module ThemeCheck
       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
 
@@ -243,7 +206,8 @@ module ThemeCheck
       end
 
       def variable_lookup_for_render_tag(render_tag)
-        return empty_lookup if render_tag.raw =~ /:\s*$/
+        return empty_lookup if /:\s*$/.match?(render_tag.raw)
+
         render_tag.attributes.values.last
       end
 
@@ -265,8 +229,10 @@ module ThemeCheck
           last_filter_argument(variable.filters)
         elsif variable.name.nil?
           empty_lookup
-        else
+        elsif variable.name.is_a?(Liquid::VariableLookup)
           variable.name
+        else
+          PotentialLookup.new(input_type_of(variable.name), [])
         end
       end
 
@@ -280,6 +246,7 @@ module ThemeCheck
         filter = filters.last
         return filter[2].values.last if filter.size == 3
         return filter[1].last if filter.size == 2
+
         nil
       end
 

data/lib/theme_check/language_server/variable_lookup_traverser.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  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)
+        ShopifyLiquid::SourceIndex
+          .objects
+          .find { |entry| entry.name == object_name }
+      end
+    end
+  end
+end