theme-check 0.5.0 → 0.7.3

data/lib/theme_check/checks/matching_translations.rb

@@ -11,7 +11,7 @@ module ThemeCheck
     end
 
     def on_file(file)
-      return unless file.name.starts_with?("locales/")
+      return unless file.name.start_with?("locales/")
       return unless file.content.is_a?(Hash)
       return if file.name == @theme.default_locale_json&.name
 

data/lib/theme_check/checks/parser_blocking_javascript.rb

@@ -2,15 +2,16 @@
 module ThemeCheck
   # Reports errors when trying to use parser-blocking script tags
   class ParserBlockingJavaScript < LiquidCheck
+    include RegexHelpers
     severity :error
     categories :liquid, :performance
     doc docs_url(__FILE__)
 
     PARSER_BLOCKING_SCRIPT_TAG = %r{
       <script                                    # Find the start of a script tag
-      (?=(?:[^>]|\n|\r)+?src=)+?                 # Make sure src= is in the script with a lookahead
+      (?=[^>]+?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+\}\}/
 
@@ -33,23 +34,14 @@ module ThemeCheck
       )
     end
 
-    # The trickiness here is matching on scripts that are defined on
-    # multiple lines (or repeat matches). This makes the line_number
-    # calculation a bit weird. So instead, we traverse the string in
-    # a very imperative way.
     def record_offenses_from_regex(regex: nil, message: nil)
-      i = 0
-      while (i = @source.index(regex, i))
-        script = @source.match(regex, i)[0]
-
+      matches(@source, regex).each do |match|
         add_offense(
           message,
           node: @node,
-          markup: script,
-          line_number: @source[0...i].count("\n") + 1
+          markup: match[0],
+          line_number: @source[0...match.begin(0)].count("\n") + 1
         )
-
-        i += script.size
       end
     end
   end

data/lib/theme_check/checks/remote_asset.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+module ThemeCheck
+  class RemoteAsset < LiquidCheck
+    include RegexHelpers
+    severity :suggestion
+    categories :liquid, :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
+    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
+
+    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(OFFENSE_MESSAGE, 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
+
+    # 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
+
+    def url_hosted_by_shopify?(url)
+      url =~ /\A#{VARIABLE}\Z/oim && url =~ ASSET_URL_FILTER
+    end
+  end
+end

data/lib/theme_check/checks/translation_key_exists.rb

@@ -1,5 +1,17 @@
 # frozen_string_literal: true
 module ThemeCheck
+  module SystemTranslations
+    extend self
+
+    def translations
+      @translations ||= YAML.load(File.read("#{__dir__}/../../../data/shopify_translation_keys.yml")).to_set
+    end
+
+    def include?(key)
+      translations.include?(key)
+    end
+  end
+
   class TranslationKeyExists < LiquidCheck
     severity :error
     category :translation
@@ -12,7 +24,7 @@ module ThemeCheck
       return unless (key_node = node.children.first)
       return unless key_node.value.is_a?(String)
 
-      unless key_exists?(key_node.value)
+      unless key_exists?(key_node.value) || SystemTranslations.include?(key_node.value)
         add_offense(
           "'#{key_node.value}' does not have a matching entry in '#{@theme.default_locale_json.relative_path}'",
           node: node,

data/lib/theme_check/checks/undefined_object.rb

@@ -135,7 +135,7 @@ module ThemeCheck
 
     def each_template
       @files.each do |(name, info)|
-        next if name.starts_with?('snippets/')
+        next if name.start_with?('snippets/')
         yield [name, info]
       end
     end

data/lib/theme_check/checks/valid_html_translation.rb

@@ -8,7 +8,7 @@ module ThemeCheck
     doc docs_url(__FILE__)
 
     def on_file(file)
-      return unless file.name.starts_with?("locales/")
+      return unless file.name.start_with?("locales/")
       return unless file.content.is_a?(Hash)
 
       visit_nested(file.content)

data/lib/theme_check/cli.rb

@@ -1,69 +1,104 @@
 # frozen_string_literal: true
+require "optparse"
+
 module ThemeCheck
   class Cli
     class Abort < StandardError; end
 
-    USAGE = <<~END
-      Usage: theme-check [options] /path/to/your/theme
+    attr_accessor :path
 
-      Options:
-        -c, [--category]          # Only run this category of checks
-        -x, [--exclude-category]  # Exclude this category of checks
-        -l, [--list]              # List enabled checks
-        -a, [--auto-correct]      # Automatically fix offenses
-        --init                    # Generate a .theme-check.yml file in the current directory
-        -h, [--help]              # Show this. Hi!
-        -v, [--version]           # Print Theme Check version
+    def initialize
+      @path = "."
+      @command = :check
+      @only_categories = []
+      @exclude_categories = []
+      @auto_correct = false
+      @config_path = nil
+    end
 
-      Description:
-        Theme Check helps you follow Shopify Themes & Liquid best practices by analyzing the
-        Liquid & JSON inside your theme.
+    def option_parser(parser = OptionParser.new, help: true)
+      return @option_parser if @option_parser
+      @option_parser = parser
+      @option_parser.banner = "Usage: theme-check [options] [/path/to/your/theme]"
 
-        You can configure checks in the .theme-check.yml file of your theme root directory.
-    END
+      @option_parser.separator("")
+      @option_parser.separator("Basic Options:")
+      @option_parser.on(
+        "-C", "--config PATH",
+        "Use the config provided, overriding .theme-check.yml if present"
+      ) { |path| @config_path = path }
+      @option_parser.on(
+        "-c", "--category CATEGORY",
+        "Only run this category of checks"
+      ) { |category| @only_categories << category.to_sym }
+      @option_parser.on(
+        "-x", "--exclude-category CATEGORY",
+        "Exclude this category of checks"
+      ) { |category| @exclude_categories << category.to_sym }
+      @option_parser.on(
+        "-a", "--auto-correct",
+        "Automatically fix offenses"
+      ) { @auto_correct = true }
 
-    def run(argv)
-      @path = "."
+      @option_parser.separator("")
+      @option_parser.separator("Miscellaneous:")
+      @option_parser.on(
+        "--init",
+        "Generate a .theme-check.yml file"
+      ) { @command = :init }
+      @option_parser.on(
+        "--print",
+        "Output active config to STDOUT"
+      ) { @command = :print }
+      @option_parser.on(
+        "-h", "--help",
+        "Show this. Hi!"
+      ) { @command = :help } if help
+      @option_parser.on(
+        "-l", "--list",
+        "List enabled checks"
+      ) { @command = :list }
+      @option_parser.on(
+        "-v", "--version",
+        "Print Theme Check version"
+      ) { @command = :version }
+
+      @option_parser.separator("")
+      @option_parser.separator(<<~EOS)
+        Description:
+            Theme Check helps you follow Shopify Themes & Liquid best practices by analyzing the
+            Liquid & JSON inside your theme.
+
+            You can configure checks in the .theme-check.yml file of your theme root directory.
+      EOS
+
+      @option_parser
+    end
+
+    def parse(argv)
+      @path = option_parser.parse(argv).first || "."
+    end
 
-      command = :check
-      only_categories = []
-      exclude_categories = []
-      auto_correct = false
-
-      args = argv.dup
-      while (arg = args.shift)
-        case arg
-        when "--help", "-h"
-          raise Abort, USAGE
-        when "--version", "-v"
-          command = :version
-        when "--category", "-c"
-          only_categories << args.shift.to_sym
-        when "--exclude-category", "-x"
-          exclude_categories << args.shift.to_sym
-        when "--list", "-l"
-          command = :list
-        when "--auto-correct", "-a"
-          auto_correct = true
-        when "--init"
-          command = :init
+    def run!
+      unless [:version, :init, :help].include?(@command)
+        @config = if @config_path
+          ThemeCheck::Config.new(
+            root: @path,
+            configuration: ThemeCheck::Config.load_file(@config_path)
+          )
         else
-          @path = arg
+          ThemeCheck::Config.from_path(@path)
         end
+        @config.only_categories = @only_categories
+        @config.exclude_categories = @exclude_categories
+        @config.auto_correct = @auto_correct
       end
 
-      unless [:version, :init].include?(command)
-        @config = ThemeCheck::Config.from_path(@path)
-        @config.only_categories = only_categories
-        @config.exclude_categories = exclude_categories
-        @config.auto_correct = auto_correct
-      end
-
-      send(command)
+      send(@command)
     end
 
-    def run!(argv)
-      run(argv)
+    def run
+      run!
     rescue Abort => e
       if e.message.empty?
         exit(1)
@@ -72,6 +107,18 @@ module ThemeCheck
       end
     end
 
+    def self.parse_and_run!(argv)
+      cli = new
+      cli.parse(argv)
+      cli.run!
+    end
+
+    def self.parse_and_run(argv)
+      cli = new
+      cli.parse(argv)
+      cli.run
+    end
+
     def list
       puts @config.enabled_checks
     end
@@ -91,12 +138,20 @@ module ThemeCheck
       end
     end
 
+    def print
+      puts YAML.dump(@config.to_h)
+    end
+
+    def help
+      puts option_parser.to_s
+    end
+
     def check
       puts "Checking #{@config.root} ..."
       storage = ThemeCheck::FileSystemStorage.new(@config.root, ignored_patterns: @config.ignored_patterns)
       theme = ThemeCheck::Theme.new(storage)
       if theme.all.empty?
-        raise Abort, "No templates found.\n#{USAGE}"
+        raise Abort, "No templates found."
       end
       analyzer = ThemeCheck::Analyzer.new(theme, @config.enabled_checks, @config.auto_correct)
       analyzer.analyze_theme

data/lib/theme_check/config.rb

@@ -10,6 +10,8 @@ module ThemeCheck
     attr_accessor :only_categories, :exclude_categories, :auto_correct
 
     class << self
+      attr_reader :last_loaded_config
+
       def from_path(path)
         if (filename = find(path))
           new(root: filename.dirname, configuration: load_file(filename))
@@ -36,6 +38,7 @@ module ThemeCheck
       end
 
       def load_file(absolute_path)
+        @last_loaded_config = absolute_path
         YAML.load_file(absolute_path)
       end
 

data/lib/theme_check/disabled_checks.rb

@@ -61,11 +61,11 @@ module ThemeCheck
     end
 
     def start_disabling?(text)
-      text.strip.starts_with?(DISABLE_START)
+      text.strip.start_with?(DISABLE_START)
     end
 
     def stop_disabling?(text)
-      text.strip.starts_with?(DISABLE_END)
+      text.strip.start_with?(DISABLE_END)
     end
 
     # Return a list of checks from a theme-check-disable comment

data/lib/theme_check/in_memory_storage.rb

@@ -6,24 +6,25 @@
 # as a big hash already, leave it like that and save yourself some IO.
 module ThemeCheck
   class InMemoryStorage < Storage
-    def initialize(files = {})
+    def initialize(files = {}, root = "/dev/null")
       @files = files
+      @root = Pathname.new(root)
     end
 
-    def path(name)
-      name
+    def path(relative_path)
+      @root.join(relative_path)
     end
 
-    def read(name)
-      @files[name]
+    def read(relative_path)
+      @files[relative_path]
     end
 
-    def write(name, content)
-      @files[name] = content
+    def write(relative_path, content)
+      @files[relative_path] = content
     end
 
     def files
-      @values ||= @files.keys
+      @files.keys
     end
 
     def directories
@@ -33,5 +34,9 @@ module ThemeCheck
         .map(&:to_s)
         .uniq
     end
+
+    def relative_path(absolute_path)
+      Pathname.new(absolute_path).relative_path_from(@root).to_s
+    end
   end
 end