theme-check 0.8.1 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b841f4d2f809e07dec57140fd76f373e216f721903baa7ac1dce747b5ce77c82
-  data.tar.gz: b513333c296966cedb4d00345cb7ab1a3d4dcbb305b92b3eb96edc598867bba5
+  metadata.gz: 8b455dde358a80264581b4c6b62e70c071510d5e50ff8b253e98550ac64be3db
+  data.tar.gz: 5fc99066d47dd69ba0d56bea7bf60b20ccf4c67364b19999c2e5feba8cc4da12
 SHA512:
-  metadata.gz: 1d75dc49ae97db15d4622d6a59b7a12a0eab0de6a6bcf19e6e8bca3b7f6eb6f94c40c11cfcdb3ac911bbc4d93e6d08cfbb83e85de763d00cb60b6fab10bfc7bb
-  data.tar.gz: eb7c5fdb74551461de7fd643071734dc8b2442db4a5a80492b982bc392c67a100614e4a9fa3b4580e28c5f1b8321564adc8f9580618f3bcdbc36dfd4e4ab13e3
+  metadata.gz: 6ee8807bab14aa44d5d2f1722d846f2c07c58656c7aa23dcc1da7a2e0e4f8b76cf2ca862c2ad7a9c1fd88c470b7cc4517fc74684af55a31d36eba4e60b6990bd
+  data.tar.gz: fd0d6012b3f991df7de47f4f7de27348a35d9582908d8564140fd900e81da9e6203b4485c7fb13dec78ddd2201acf7829b893d0004dcd1436fea4b1ea6098767

data/config/default.yml

@@ -17,7 +17,7 @@ MissingTemplate:
 
 NestedSnippet:
   enabled: true
-  max_nesting_level: 2
+  max_nesting_level: 3
 
 RequiredLayoutThemeObject:
   enabled: true

data/data/shopify_liquid/tags.yml

@@ -8,6 +8,8 @@
 - cycle
 - decrement
 - echo
+- else
+- elsif
 - for
 - form
 - if
@@ -25,3 +27,4 @@
 - stylesheet
 - tablerow
 - unless
+- when

data/docs/checks/nested_snippet.md

@@ -45,7 +45,7 @@ The default configuration for this check is the following:
 ```yaml
 NestedSnippet:
   enabled: true
-  max_nesting_level: 2
+  max_nesting_level: 3
 ```
 
 ### `max_nesting_level`

data/docs/checks/space_inside_braces.md

@@ -21,6 +21,10 @@ This check is aimed at eliminating ugly Liquid:
 <!-- Arround filter pipelines -->
 {{ url  | asset_url | img_tag }}
 {% assign my_upcase_string = "Hello world"| upcase %}
+
+<!-- Arround symbol operators -->
+{%- if target  == product and product.price_varies -%}
+{%- if product.featured_media.width >=165 -%}
 ```
 
 :+1: Examples of **correct** code for this check:
@@ -39,6 +43,8 @@ This check is aimed at eliminating ugly Liquid:
 %}
 {{ url | asset_url | img_tag }}
 {% assign my_upcase_string = "Hello world" | upcase %}
+{%- if target == product and product.price_varies -%}
+{%- if product.featured_media.width >= 165 -%}
 ```
 
 ## Check Options
@@ -50,6 +56,22 @@ SpaceInsideBraces:
   enabled: true
 ```
 
+## Auto-correction
+
+This check can automatically trim or add spaces around `{{ ... }}`.
+
+```liquid
+{{ x}}
+{{x}}
+{{  x  }}
+```
+
+Can all be auto-corrected with the `--auto-correct` option to:
+
+```liquid
+{{ x }}
+```
+
 ## When Not To Use It
 
 If you don't care about the look of your code.

data/lib/theme_check.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require "liquid"
 
+require_relative "theme_check/bug"
 require_relative "theme_check/exceptions"
 require_relative "theme_check/analyzer"
 require_relative "theme_check/check"

data/lib/theme_check/bug.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  BUG_POSTAMBLE = <<~EOS
+    Theme Check Version: #{VERSION}
+    Ruby Version: #{RUBY_VERSION}
+    Platform: #{RUBY_PLATFORM}
+    Muffin mode: activated
+
+    ------------------------
+    Whoops! It looks like you found a bug in Theme Check.
+    Please report it at https://github.com/Shopify/theme-check/issues, and include the message above.
+    Or cross your fingers real hard, and try again.
+  EOS
+
+  def self.bug(message)
+    abort(message + BUG_POSTAMBLE)
+  end
+end

data/lib/theme_check/checks.rb

@@ -1,16 +1,53 @@
 # frozen_string_literal: true
+require "pp"
+require "timeout"
+
 module ThemeCheck
   class Checks < Array
+    CHECK_METHOD_TIMEOUT = 5 # sec
+
     def call(method, *args)
       each do |check|
-        if check.respond_to?(method) && !check.ignored?
-          check.send(method, *args)
-        end
+        call_check_method(check, method, *args)
       end
     end
 
     def disableable
       self.class.new(select(&:can_disable?))
     end
+
+    private
+
+    def call_check_method(check, method, *args)
+      return unless check.respond_to?(method) && !check.ignored?
+
+      Timeout.timeout(CHECK_METHOD_TIMEOUT) do
+        check.send(method, *args)
+      end
+    rescue Liquid::Error
+      # Pass-through Liquid errors
+      raise
+    rescue => e
+      node = args.first
+      template = node.respond_to?(:template) ? node.template.relative_path : "?"
+      markup = node.respond_to?(:markup) ? node.markup : ""
+      node_class = node.respond_to?(:value) ? node.value.class : "?"
+
+      ThemeCheck.bug(<<~EOS)
+        Exception while running `#{check.code_name}##{method}`:
+        ```
+        #{e.class}: #{e.message}
+          #{e.backtrace.join("\n  ")}
+        ```
+
+        Template: `#{template}`
+        Node: `#{node_class}`
+        Markup:
+        ```
+        #{markup}
+        ```
+        Check options: `#{check.options.pretty_inspect}`
+      EOS
+    end
   end
 end

data/lib/theme_check/checks/nested_snippet.rb

@@ -20,7 +20,7 @@ module ThemeCheck
       end
     end
 
-    def initialize(max_nesting_level: 2)
+    def initialize(max_nesting_level: 3)
       @max_nesting_level = max_nesting_level
       @templates = {}
     end

data/lib/theme_check/checks/space_inside_braces.rb

@@ -15,17 +15,17 @@ module ThemeCheck
       return if :assign == node.type_name
 
       outside_of_strings(node.markup) do |chunk|
-        chunk.scan(/([,:|])  +/) do |_match|
+        chunk.scan(/([,:|]|==|<>|<=|>=|<|>|!=)  +/) do |_match|
           add_offense("Too many spaces after '#{Regexp.last_match(1)}'", node: node, markup: Regexp.last_match(0))
         end
-        chunk.scan(/([,:|])\S/) do |_match|
+        chunk.scan(/([,:|]|==|<>|<=|>=|<\b|>\b|!=)(\S|\z)/) do |_match|
           add_offense("Space missing after '#{Regexp.last_match(1)}'", node: node, markup: Regexp.last_match(0))
         end
-        chunk.scan(/  ([|])+/) do |_match|
+        chunk.scan(/  (\||==|<>|<=|>=|<|>|!=)+/) do |_match|
           add_offense("Too many spaces before '#{Regexp.last_match(1)}'", node: node, markup: Regexp.last_match(0))
         end
-        chunk.scan(/\A(?<pipe>\|)|\S(?<pipe>\|)/) do |_match|
-          add_offense("Space missing before '#{Regexp.last_match(:pipe)}'", node: node, markup: Regexp.last_match(:pipe))
+        chunk.scan(/(\A|\S)(?<match>\||==|<>|<=|>=|<|\b>|!=)/) do |_match|
+          add_offense("Space missing before '#{Regexp.last_match(1)}'", node: node, markup: Regexp.last_match(0))
         end
       end
     end

data/lib/theme_check/language_server.rb

@@ -4,6 +4,7 @@ require_relative "language_server/constants"
 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/completion_helper"
 require_relative "language_server/completion_provider"
 require_relative "language_server/completion_engine"

data/lib/theme_check/language_server/completion_providers/object_completion_provider.rb

@@ -4,18 +4,20 @@ module ThemeCheck
   module LanguageServer
     class ObjectCompletionProvider < CompletionProvider
       def completions(content, cursor)
-        return [] unless can_complete?(content, cursor)
-        partial = first_word(content) || ''
+        return [] unless (variable_lookup = variable_lookup_at_cursor(content, cursor))
+        return [] unless variable_lookup.lookups.empty?
+        return [] if content[cursor - 1] == "."
         ShopifyLiquid::Object.labels
-          .select { |w| w.start_with?(partial) }
+          .select { |w| w.start_with?(partial(variable_lookup)) }
           .map { |object| object_to_completion(object) }
       end
 
-      def can_complete?(content, cursor)
-        content.match?(Liquid::VariableStart) && (
-          cursor_on_first_word?(content, cursor) ||
-          cursor_on_start_content?(content, cursor, Liquid::VariableStart)
-        )
+      def variable_lookup_at_cursor(content, cursor)
+        VariableLookupFinder.lookup(content, cursor)
+      end
+
+      def partial(variable_lookup)
+        variable_lookup.name || ''
       end
 
       private

data/lib/theme_check/language_server/variable_lookup_finder.rb

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  module LanguageServer
+    module VariableLookupFinder
+      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(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
+      end
+
+      private
+
+      def cursor_is_on_bracket_position_that_cant_be_completed(content, cursor)
+        content[0..cursor - 1] =~ 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 markup =~ /\s+$/
+
+        # 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
+
+        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_lookup_markup
+
+        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)
+        end
+
+      # rubocop:disable Style/RedundantReturn
+      rescue Liquid::SyntaxError
+        # We don't complete variable for liquid syntax errors
+        return
+      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
+      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 render_tag.raw =~ /:\s*$/
+        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
+        else
+          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)
+        ShopifyLiquid::Tag.tag_regex(tag)
+      end
+    end
+  end
+end

data/lib/theme_check/shopify_liquid/tag.rb

@@ -8,6 +8,19 @@ module ThemeCheck
 
       def labels
         @tags ||= YAML.load(File.read("#{__dir__}/../../../data/shopify_liquid/tags.yml"))
+          .to_set
+      end
+
+      def tag_regex(tag)
+        return unless labels.include?(tag)
+        @tag_regexes ||= {}
+        @tag_regexes[tag] ||= /\A#{Liquid::TagStart}-?\s*#{tag}/m
+      end
+
+      def liquid_tag_regex(tag)
+        return unless labels.include?(tag)
+        @tag_liquid_regexes ||= {}
+        @tag_liquid_regexes[tag] ||= /^\s*#{tag}/m
       end
     end
   end

data/lib/theme_check/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module ThemeCheck
-  VERSION = "0.8.1"
+  VERSION = "0.8.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: theme-check
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.2
 platform: ruby
 authors:
 - Marc-André Cournoyer
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-04-22 00:00:00.000000000 Z
+date: 2021-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: liquid
@@ -104,6 +104,7 @@ files:
 - lib/theme_check.rb
 - lib/theme_check/analyzer.rb
 - lib/theme_check/asset_file.rb
+- lib/theme_check/bug.rb
 - lib/theme_check/check.rb
 - lib/theme_check/checks.rb
 - lib/theme_check/checks/asset_size_css.rb
@@ -160,6 +161,7 @@ files:
 - lib/theme_check/language_server/protocol.rb
 - lib/theme_check/language_server/server.rb
 - lib/theme_check/language_server/tokens.rb
+- lib/theme_check/language_server/variable_lookup_finder.rb
 - lib/theme_check/liquid_check.rb
 - lib/theme_check/locale_diff.rb
 - lib/theme_check/node.rb
@@ -206,7 +208,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.2.17
 signing_key: 
 specification_version: 4
 summary: A Shopify Theme Linter