theme-check 0.8.3 → 0.10.2

data/lib/theme_check/check.rb

@@ -6,7 +6,7 @@ module ThemeCheck
     include JsonHelpers
 
     attr_accessor :theme
-    attr_accessor :options
+    attr_accessor :options, :ignored_patterns
     attr_writer :offenses
 
     SEVERITIES = [
@@ -18,7 +18,7 @@ module ThemeCheck
     CATEGORIES = [
       :liquid,
       :translation,
-      :performance,
+      :html,
       :json,
       :performance,
     ]
@@ -67,12 +67,23 @@ module ThemeCheck
         end
         defined?(@can_disable) ? @can_disable : true
       end
+
+      def single_file(single_file = nil)
+        unless single_file.nil?
+          @single_file = single_file
+        end
+        defined?(@single_file) ? @single_file : !method_defined?(:on_end)
+      end
     end
 
     def offenses
       @offenses ||= []
     end
 
+    def add_offense(message, node: nil, template: node&.template, markup: nil, line_number: nil, &block)
+      offenses << Offense.new(check: self, message: message, template: template, node: node, markup: markup, line_number: line_number, correction: block)
+    end
+
     def severity
       self.class.severity
     end
@@ -93,10 +104,6 @@ module ThemeCheck
       @ignored = true
     end
 
-    def unignore!
-      @ignored = false
-    end
-
     def ignored?
       defined?(@ignored) && @ignored
     end
@@ -105,9 +112,27 @@ module ThemeCheck
       self.class.can_disable
     end
 
+    def single_file?
+      self.class.single_file
+    end
+
+    def whole_theme?
+      !single_file?
+    end
+
+    def ==(other)
+      other.is_a?(Check) && code_name == other.code_name
+    end
+    alias_method :eql?, :==
+
     def to_s
       s = +"#{code_name}:\n"
-      properties = { severity: severity, categories: categories, doc: doc }.merge(options)
+      properties = {
+        severity: severity,
+        categories: categories,
+        doc: doc,
+        ignored_patterns: ignored_patterns,
+      }.merge(options)
       properties.each_pair do |name, value|
         s << "  #{name}: #{value}\n" if value
       end

data/lib/theme_check/checks.rb

@@ -13,7 +13,15 @@ module ThemeCheck
     end
 
     def disableable
-      self.class.new(select(&:can_disable?))
+      @disableable ||= self.class.new(select(&:can_disable?))
+    end
+
+    def whole_theme
+      @whole_theme ||= self.class.new(select(&:whole_theme?))
+    end
+
+    def single_file
+      @single_file ||= self.class.new(select(&:single_file?))
     end
 
     private

data/lib/theme_check/checks/TEMPLATE.rb.erb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module ThemeCheck
+  # TODO: inherit from HtmlCheck or JsonCheck if working on a non-Liquid check
+  class <%= class_name %> < LiquidCheck
+    severity :suggestion
+    category :liquid
+    doc docs_url(__FILE__)
+
+    # TODO: def on_<NODE_TYPE>
+  end
+end

data/lib/theme_check/checks/asset_url_filters.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+module ThemeCheck
+  class AssetUrlFilters < LiquidCheck
+    severity :suggestion
+    categories :liquid, :performance
+    doc docs_url(__FILE__)
+
+    HTML_FILTERS = [
+      'stylesheet_tag',
+      'script_tag',
+      'img_tag',
+    ]
+    ASSET_URL_FILTERS = [
+      'asset_url',
+      'asset_img_url',
+      'file_img_url',
+      'file_url',
+      'global_asset_url',
+      'img_url',
+      'payment_type_img_url',
+      'shopify_asset_url',
+    ]
+
+    def on_variable(node)
+      record_variable_offense(node)
+    end
+
+    private
+
+    def record_variable_offense(variable_node)
+      # We flag HTML tags with URLs not hosted by Shopify
+      return if !html_resource_drop?(variable_node) || variable_hosted_by_shopify?(variable_node)
+      add_offense("Use one of the asset_url filters to serve assets", node: variable_node)
+    end
+
+    def html_resource_drop?(variable_node)
+      variable_node.value.filters
+        .any? { |(filter_name, *_filter_args)| HTML_FILTERS.include?(filter_name) }
+    end
+
+    def variable_hosted_by_shopify?(variable_node)
+      variable_node.value.filters
+        .any? { |(filter_name, *_filter_args)| ASSET_URL_FILTERS.include?(filter_name) }
+    end
+  end
+end

data/lib/theme_check/checks/content_for_header_modification.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+module ThemeCheck
+  class ContentForHeaderModification < LiquidCheck
+    severity :error
+    category :liquid
+    doc docs_url(__FILE__)
+
+    def initialize
+      @in_assign = false
+      @in_capture = false
+    end
+
+    def on_variable(node)
+      return unless node.value.name.is_a?(Liquid::VariableLookup)
+      return unless node.value.name.name == "content_for_header"
+
+      if @in_assign || @in_capture || node.value.filters.any?
+        add_offense(
+          "Do not rely on the content of `content_for_header`",
+          node: node,
+        )
+      end
+    end
+
+    def on_assign(_node)
+      @in_assign = true
+    end
+
+    def after_assign(_node)
+      @in_assign = false
+    end
+
+    def on_capture(_node)
+      @in_capture = true
+    end
+
+    def after_capture(_node)
+      @in_capture = false
+    end
+  end
+end

data/lib/theme_check/checks/html_parsing_error.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module ThemeCheck
+  class HtmlParsingError < HtmlCheck
+    severity :error
+    category :html
+    doc docs_url(__FILE__)
+
+    def on_parse_error(exception, template)
+      add_offense("HTML in this template can not be parsed: #{exception.message}", template: template)
+    end
+  end
+end

data/lib/theme_check/checks/img_lazy_loading.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module ThemeCheck
+  class ImgLazyLoading < HtmlCheck
+    severity :suggestion
+    categories :html, :performance
+    doc docs_url(__FILE__)
+
+    ACCEPTED_LOADING_VALUES = %w[lazy eager]
+
+    def on_img(node)
+      loading = node.attributes["loading"]&.value&.downcase
+      return if ACCEPTED_LOADING_VALUES.include?(loading)
+
+      class_list = node.attributes["class"]&.value&.split(" ")
+
+      if class_list&.include?("lazyload")
+        add_offense("Use the native loading=\"lazy\" attribute instead of lazysizes", node: node)
+      elsif loading == "auto"
+        add_offense("Prefer loading=\"lazy\" to defer loading of images", node: node)
+      else
+        add_offense("Add a loading=\"lazy\" attribute to defer loading of images", node: node)
+      end
+    end
+  end
+end

data/lib/theme_check/checks/img_width_and_height.rb

@@ -1,41 +1,21 @@
 # frozen_string_literal: true
 module ThemeCheck
   # Reports errors when trying to use parser-blocking script tags
-  class ImgWidthAndHeight < LiquidCheck
-    include RegexHelpers
+  class ImgWidthAndHeight < HtmlCheck
     severity :error
-    categories :liquid, :performance
+    categories :html, :performance
     doc docs_url(__FILE__)
 
-    # Not implemented with lookbehinds and lookaheads because performance was shit!
-    IMG_TAG = %r{<img#{HTML_ATTRIBUTES}/?>}oxim
-    SRC_ATTRIBUTE = /\s(src)=(#{QUOTED_LIQUID_ATTRIBUTE})/oxim
-    WIDTH_ATTRIBUTE = /\s(width)=(#{QUOTED_LIQUID_ATTRIBUTE})/oxim
-    HEIGHT_ATTRIBUTE = /\s(height)=(#{QUOTED_LIQUID_ATTRIBUTE})/oxim
-
-    FIELDS = [WIDTH_ATTRIBUTE, HEIGHT_ATTRIBUTE]
     ENDS_IN_CSS_UNIT = /(cm|mm|in|px|pt|pc|em|ex|ch|rem|vw|vh|vmin|vmax|%)$/i
 
-    def on_document(node)
-      @source = node.template.source
-      @node = node
-      record_offenses
-    end
+    def on_img(node)
+      width = node.attributes["width"]&.value
+      height = node.attributes["height"]&.value
 
-    private
+      record_units_in_field_offenses("width", width, node: node)
+      record_units_in_field_offenses("height", height, node: node)
 
-    def record_offenses
-      matches(@source, IMG_TAG).each do |img_match|
-        next unless img_match[0] =~ SRC_ATTRIBUTE
-        record_missing_field_offenses(img_match)
-        record_units_in_field_offenses(img_match)
-      end
-    end
-
-    def record_missing_field_offenses(img_match)
-      width = WIDTH_ATTRIBUTE.match(img_match[0])
-      height = HEIGHT_ATTRIBUTE.match(img_match[0])
-      return if width && height
+      return if node.attributes["src"].nil? || (width && height)
       missing_width = width.nil?
       missing_height = height.nil?
       error_message = if missing_width && missing_height
@@ -46,29 +26,18 @@ module ThemeCheck
         "Missing height attribute"
       end
 
-      add_offense(
-        error_message,
-        node: @node,
-        markup: img_match[0],
-        line_number: @source[0...img_match.begin(0)].count("\n") + 1
-      )
+      add_offense(error_message, node: node)
     end
 
-    def record_units_in_field_offenses(img_match)
-      FIELDS.each do |field|
-        field_match = field.match(img_match[0])
-        next if field_match.nil?
-        value = field_match[2].gsub(START_OR_END_QUOTE, '')
-        next unless value =~ ENDS_IN_CSS_UNIT
-        value_without_units = value.gsub(ENDS_IN_CSS_UNIT, '')
-        start = img_match.begin(0) + field_match.begin(2)
-        add_offense(
-          "The #{field_match[1]} attribute does not take units. Replace with \"#{value_without_units}\".",
-          node: @node,
-          markup: value,
-          line_number: @source[0...start].count("\n") + 1
-        )
-      end
+    private
+
+    def record_units_in_field_offenses(attribute, value, node:)
+      return unless value =~ ENDS_IN_CSS_UNIT
+      value_without_units = value.gsub(ENDS_IN_CSS_UNIT, '')
+      add_offense(
+        "The #{attribute} attribute does not take units. Replace with \"#{value_without_units}\".",
+        node: node,
+      )
     end
   end
 end

data/lib/theme_check/checks/missing_template.rb

@@ -5,6 +5,7 @@ module ThemeCheck
     severity :suggestion
     category :liquid
     doc docs_url(__FILE__)
+    single_file false
 
     def on_include(node)
       template = node.value.template_name_expr

data/lib/theme_check/checks/parser_blocking_javascript.rb

@@ -1,48 +1,16 @@
 # frozen_string_literal: true
 module ThemeCheck
   # Reports errors when trying to use parser-blocking script tags
-  class ParserBlockingJavaScript < LiquidCheck
-    include RegexHelpers
+  class ParserBlockingJavaScript < HtmlCheck
     severity :error
-    categories :liquid, :performance
+    categories :html, :performance
     doc docs_url(__FILE__)
 
-    PARSER_BLOCKING_SCRIPT_TAG = %r{
-      <script                                    # Find the start of a script tag
-      (?=[^>]+?src=)                             # Make sure src= is in the script with a lookahead
-      (?:(?!defer|async|type=["']module['"]).)*? # Find tags that don't have defer|async|type="module"
-      /?>
-    }xim
-    SCRIPT_TAG_FILTER = /\{\{[^}]+script_tag\s+\}\}/
+    def on_script(node)
+      return unless node.attributes["src"]
+      return if node.attributes["defer"] || node.attributes["async"] || node.attributes["type"]&.value == "module"
 
-    def on_document(node)
-      @source = node.template.source
-      @node = node
-      record_offenses
-    end
-
-    private
-
-    def record_offenses
-      record_offenses_from_regex(
-        message: "Missing async or defer attribute on script tag",
-        regex: PARSER_BLOCKING_SCRIPT_TAG,
-      )
-      record_offenses_from_regex(
-        message: "The script_tag filter is parser-blocking. Use a script tag with the async or defer attribute for better performance",
-        regex: SCRIPT_TAG_FILTER,
-      )
-    end
-
-    def record_offenses_from_regex(regex: nil, message: nil)
-      matches(@source, regex).each do |match|
-        add_offense(
-          message,
-          node: @node,
-          markup: match[0],
-          line_number: @source[0...match.begin(0)].count("\n") + 1
-        )
-      end
+      add_offense("Missing async or defer attribute on script tag", node: node)
     end
   end
 end

data/lib/theme_check/checks/parser_blocking_script_tag.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+module ThemeCheck
+  # Reports errors when trying to use parser-blocking script tags
+  class ParserBlockingScriptTag < LiquidCheck
+    severity :error
+    categories :liquid, :performance
+    doc docs_url(__FILE__)
+
+    def on_variable(node)
+      used_filters = node.value.filters.map { |name, *_rest| name }
+      if used_filters.include?("script_tag")
+        add_offense(
+          "The script_tag filter is parser-blocking. Use a script tag with the async or defer " \
+          "attribute for better performance",
+          node: node
+        )
+      end
+    end
+  end
+end

data/lib/theme_check/checks/remote_asset.rb

@@ -1,99 +1,41 @@
 # frozen_string_literal: true
 module ThemeCheck
-  class RemoteAsset < LiquidCheck
-    include RegexHelpers
+  class RemoteAsset < HtmlCheck
     severity :suggestion
-    categories :liquid, :performance
+    categories :html, :performance
     doc docs_url(__FILE__)
 
-    OFFENSE_MESSAGE = "Asset should be served by the Shopify CDN for better performance."
-
-    HTML_FILTERS = [
-      'stylesheet_tag',
-      'script_tag',
-      'img_tag',
-    ]
-    ASSET_URL_FILTERS = [
-      'asset_url',
-      'asset_img_url',
-      'file_img_url',
-      'file_url',
-      'global_asset_url',
-      'img_url',
-      'payment_type_img_url',
-      'shopify_asset_url',
-    ]
-
-    RESOURCE_TAG = %r{<(?<tag_name>img|script|link|source)#{HTML_ATTRIBUTES}/?>}oim
-    RESOURCE_URL = /\s(?:src|href)=(?<resource_url>#{QUOTED_LIQUID_ATTRIBUTE})/oim
-    ASSET_URL_FILTER = /[\|\s]*(#{ASSET_URL_FILTERS.join('|')})/omi
+    TAGS = %w[img script link source]
     PROTOCOL = %r{(https?:)?//}
     ABSOLUTE_PATH = %r{\A/[^/]}im
     RELATIVE_PATH = %r{\A(?!#{PROTOCOL})[^/\{]}oim
-    REL = /\srel=(?<rel>#{QUOTED_LIQUID_ATTRIBUTE})/oim
-
-    def on_variable(node)
-      record_variable_offense(node)
-    end
 
-    def on_document(node)
-      source = node.template.source
-      record_html_offenses(node, source)
-    end
+    def on_element(node)
+      return unless TAGS.include?(node.name)
 
-    private
+      resource_url = node.attributes["src"]&.value || node.attributes["href"]&.value
+      return if resource_url.nil? || resource_url.empty?
 
-    def record_variable_offense(variable_node)
-      # We flag HTML tags with URLs not hosted by Shopify
-      return if !html_resource_drop?(variable_node) || variable_hosted_by_shopify?(variable_node)
-      add_offense(OFFENSE_MESSAGE, node: variable_node)
-    end
+      # Ignore if URL is Liquid, taken care of by AssetUrlFilters check
+      return if resource_url =~ ABSOLUTE_PATH
+      return if resource_url =~ RELATIVE_PATH
+      return if url_hosted_by_shopify?(resource_url)
 
-    def html_resource_drop?(variable_node)
-      variable_node.value.filters
-        .any? { |(filter_name, *_filter_args)| HTML_FILTERS.include?(filter_name) }
-    end
+      # Ignore non-stylesheet rel tags
+      rel = node.attributes["rel"]
+      return if rel && rel.value != "stylesheet"
 
-    def variable_hosted_by_shopify?(variable_node)
-      variable_node.value.filters
-        .any? { |(filter_name, *_filter_args)| ASSET_URL_FILTERS.include?(filter_name) }
+      add_offense(
+        "Asset should be served by the Shopify CDN for better performance.",
+        node: node,
+      )
     end
 
-    # This part is slightly more complicated because we don't have an
-    # HTML AST. We have to resort to looking at the HTML with regexes
-    # to figure out if we have a resource (stylesheet, script, or media)
-    # that points to a remote domain.
-    def record_html_offenses(node, source)
-      matches(source, RESOURCE_TAG).each do |match|
-        tag = match[0]
-
-        # We don't flag stuff without URLs
-        next unless tag =~ RESOURCE_URL
-        resource_match = Regexp.last_match
-        resource_url = resource_match[:resource_url].gsub(START_OR_END_QUOTE, '')
-
-        next if non_stylesheet_link?(tag)
-        next if url_hosted_by_shopify?(resource_url)
-        next if resource_url =~ ABSOLUTE_PATH
-        next if resource_url =~ RELATIVE_PATH
-        next if resource_url.empty?
-
-        start = match.begin(0) + resource_match.begin(:resource_url)
-        add_offense(
-          OFFENSE_MESSAGE,
-          node: node,
-          markup: resource_url,
-          line_number: source[0...start].count("\n") + 1,
-        )
-      end
-    end
-
-    def non_stylesheet_link?(tag)
-      tag =~ REL && !(Regexp.last_match[:rel] =~ /\A['"]stylesheet['"]\Z/)
-    end
+    private
 
     def url_hosted_by_shopify?(url)
-      url =~ /\A#{VARIABLE}\Z/oim && url =~ ASSET_URL_FILTER
+      url.start_with?(Liquid::VariableStart) &&
+        AssetUrlFilters::ASSET_URL_FILTERS.any? { |filter| url.include?(filter) }
     end
   end
 end