theme-check 0.1.2 → 0.3.2

data/lib/theme_check/checks/missing_enable_comment.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module ThemeCheck
+  class MissingEnableComment < LiquidCheck
+    severity :error
+
+    # Don't allow this check to be disabled with a comment,
+    # as we need to be able to check for disabled checks.
+    can_disable false
+
+    def on_document(_node)
+      @disabled_checks = DisabledChecks.new
+    end
+
+    def on_comment(node)
+      @disabled_checks.update(node)
+    end
+
+    def after_document(node)
+      return if @disabled_checks.full_document_disabled?
+      return unless @disabled_checks.any?
+
+      message = if @disabled_checks.all_disabled?
+        "All checks were"
+      else
+        @disabled_checks.all.join(', ') + " " + (@disabled_checks.all.size == 1 ? "was" : "were")
+      end
+
+      add_offense("#{message} disabled but not re-enabled with theme-check-enable", node: node)
+    end
+  end
+end

data/lib/theme_check/checks/parser_blocking_javascript.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+module ThemeCheck
+  # Reports errors when trying to use parser-blocking script tags
+  class ParserBlockingJavaScript < LiquidCheck
+    severity :error
+    category :liquid
+
+    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
+      (?:(?!defer|async|type=["']module['"]).)*? # Find tags that don't have defer|async|type="module"
+      >
+    }xim
+    SCRIPT_TAG_FILTER = /\{\{[^}]+script_tag\s+\}\}/
+
+    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
+
+    # 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]
+
+        add_offense(
+          message,
+          node: @node,
+          markup: script,
+          line_number: @source[0...i].count("\n") + 1
+        )
+
+        i += script.size
+      end
+    end
+  end
+end

data/lib/theme_check/checks/space_inside_braces.rb

@@ -11,6 +11,7 @@ module ThemeCheck
 
     def on_node(node)
       return unless node.markup
+      return if :assign == node.type_name
 
       outside_of_strings(node.markup) do |chunk|
         chunk.scan(/([,:])  +/) do |_match|
@@ -45,13 +46,24 @@ module ThemeCheck
     def on_variable(node)
       return if @ignore
       if node.markup[0] != " "
-        add_offense("Space missing after '{{'", node: node)
-      elsif node.markup[-1] != " "
-        add_offense("Space missing before '}}'", node: node)
-      elsif node.markup[1] == " "
-        add_offense("Too many spaces after '{{'", node: node)
-      elsif node.markup[-2] == " "
-        add_offense("Too many spaces before '}}'", node: node)
+        add_offense("Space missing after '{{'", node: node) do |corrector|
+          corrector.insert_before(node, " ")
+        end
+      end
+      if node.markup[-1] != " "
+        add_offense("Space missing before '}}'", node: node) do |corrector|
+          corrector.insert_after(node, " ")
+        end
+      end
+      if node.markup[0] == " " && node.markup[1] == " "
+        add_offense("Too many spaces after '{{'", node: node) do |corrector|
+          corrector.replace(node, " #{node.markup.lstrip}")
+        end
+      end
+      if node.markup[-1] == " " && node.markup[-2] == " "
+        add_offense("Too many spaces before '}}'", node: node) do |corrector|
+          corrector.replace(node, "#{node.markup.rstrip} ")
+        end
       end
     end
   end

data/lib/theme_check/checks/template_length.rb

@@ -4,12 +4,20 @@ module ThemeCheck
     severity :suggestion
     category :liquid
 
-    def initialize(max_length: 200)
+    def initialize(max_length: 200, exclude_schema: true)
       @max_length = max_length
+      @exclude_schema = exclude_schema
+      @excluded_lines = 0
     end
 
-    def on_document(node)
-      lines = node.template.source.count("\n")
+    def on_schema(node)
+      if @exclude_schema
+        @excluded_lines += node.value.nodelist.join.count("\n")
+      end
+    end
+
+    def after_document(node)
+      lines = node.template.source.count("\n") - @excluded_lines
       if lines > @max_length
         add_offense("Template has too many lines [#{lines}/#{@max_length}]", template: node.template)
       end

data/lib/theme_check/checks/undefined_object.rb

@@ -11,76 +11,159 @@ module ThemeCheck
         @all_assigns = {}
         @all_captures = {}
         @all_forloops = {}
+        @all_renders = {}
       end
 
-      attr_reader :all_variable_lookups, :all_assigns, :all_captures, :all_forloops
-      def all
+      attr_reader :all_assigns, :all_captures, :all_forloops
+
+      def add_render(name:, node:)
+        @all_renders[name] = node
+      end
+
+      def add_variable_lookup(name:, node:)
+        line_number = node.parent.line_number
+        key = [name, line_number]
+        @all_variable_lookups[key] = node
+      end
+
+      def all_variables
         all_assigns.keys + all_captures.keys + all_forloops.keys
       end
+
+      def each_snippet
+        @all_renders.each do |(name, info)|
+          yield [name, info]
+        end
+      end
+
+      def each_variable_lookup(unique_keys = false)
+        seen = Set.new
+        @all_variable_lookups.each do |(key, info)|
+          name, _line_number = key
+
+          next if unique_keys && seen.include?(name)
+          seen << name
+
+          yield [key, info]
+        end
+      end
     end
 
-    def initialize
-      @templates = {}
-      @used_snippets = {}
+    def initialize(exclude_snippets: false)
+      @exclude_snippets = exclude_snippets
+      @files = {}
     end
 
     def on_document(node)
-      @templates[node.template.name] = TemplateInfo.new
+      return if ignore?(node)
+      @files[node.template.name] = TemplateInfo.new
     end
 
     def on_assign(node)
-      @templates[node.template.name].all_assigns[node.value.to] = node
+      return if ignore?(node)
+      @files[node.template.name].all_assigns[node.value.to] = node
     end
 
     def on_capture(node)
-      @templates[node.template.name].all_captures[node.value.instance_variable_get('@to')] = node
+      return if ignore?(node)
+      @files[node.template.name].all_captures[node.value.instance_variable_get('@to')] = node
     end
 
     def on_for(node)
-      @templates[node.template.name].all_forloops[node.value.variable_name] = node
+      return if ignore?(node)
+      @files[node.template.name].all_forloops[node.value.variable_name] = node
     end
 
-    def on_include(node)
+    def on_include(_node)
+      # NOOP: we purposely do nothing on `include` since it is deprecated
+      #   https://shopify.dev/docs/themes/liquid/reference/tags/deprecated-tags#include
+    end
+
+    def on_render(node)
+      return if ignore?(node)
       return unless node.value.template_name_expr.is_a?(String)
-      name = "snippets/#{node.value.template_name_expr}"
-      @used_snippets[name] ||= Set.new
-      @used_snippets[name] << node.template.name
+
+      snippet_name = "snippets/#{node.value.template_name_expr}"
+      @files[node.template.name].add_render(
+        name: snippet_name,
+        node: node,
+      )
     end
 
     def on_variable_lookup(node)
-      @templates[node.template.name].all_variable_lookups[node.value.name] = node
+      return if ignore?(node)
+      @files[node.template.name].add_variable_lookup(
+        name: node.value.name,
+        node: node,
+      )
     end
 
     def on_end
-      foster_snippets = theme.snippets
-        .reject { |t| @used_snippets.include?(t.name) }
-        .map(&:name)
-
-      @templates.each do |(template_name, info)|
-        next if foster_snippets.include?(template_name)
-        if (all_including_templates = @used_snippets[template_name])
-          all_including_templates.each do |including_template|
-            including_template_info = @templates[including_template]
-            check_object(info.all_variable_lookups, including_template_info.all)
-          end
+      all_global_objects = ThemeCheck::ShopifyLiquid::Object.labels
+      all_global_objects.freeze
+
+      shopify_plus_objects = ThemeCheck::ShopifyLiquid::Object.plus_labels
+      shopify_plus_objects.freeze
+
+      each_template do |(name, info)|
+        if 'templates/customers/reset_password' == name
+          # NOTE: `email` is exceptionally exposed as a theme object in
+          #       the customers' reset password template
+          check_object(info, all_global_objects + ['email'])
+        elsif 'layout/checkout' == name
+          # NOTE: Shopify Plus has exceptionally exposed objects in
+          #       the checkout template
+          # https://shopify.dev/docs/themes/theme-templates/checkout-liquid#optional-objects
+          check_object(info, all_global_objects + shopify_plus_objects)
         else
-          all = info.all
-          all += ['email'] if 'templates/customers/reset_password' == template_name
-          check_object(info.all_variable_lookups, all)
+          check_object(info, all_global_objects)
         end
       end
     end
 
-    def check_object(variable_lookups, all)
-      variable_lookups.each do |(name, node)|
-        next if all.include?(name)
-        next if ThemeCheck::ShopifyLiquid::Object.labels.include?(name)
+    private
+
+    def ignore?(node)
+      @exclude_snippets && node.template.snippet?
+    end
+
+    def each_template
+      @files.each do |(name, info)|
+        next if name.starts_with?('snippets/')
+        yield [name, info]
+      end
+    end
+
+    def check_object(info, all_global_objects, render_node = nil)
+      check_undefined(info, all_global_objects, render_node)
+
+      info.each_snippet do |(snippet_name, node)|
+        snippet_info = @files[snippet_name]
+        next unless snippet_info # NOTE: undefined snippet
+
+        snippet_variables = node.value.attributes.keys +
+          Array[node.value.instance_variable_get("@alias_name")]
+        check_object(snippet_info, all_global_objects + snippet_variables, node)
+      end
+    end
+
+    def check_undefined(info, all_global_objects, render_node)
+      all_variables = info.all_variables
 
-        parent = node.parent
-        parent = parent.parent if :variable_lookup == parent.type_name
-        add_offense("Undefined object `#{name}`", node: parent)
+      info.each_variable_lookup(!!render_node) do |(key, node)|
+        name, _line_number = key
+        next if all_variables.include?(name)
+        next if all_global_objects.include?(name)
+
+        node = node.parent
+        node = node.parent if %i(condition variable_lookup).include?(node.type_name)
+
+        if render_node
+          add_offense("Missing argument `#{name}`", node: render_node)
+        else
+          add_offense("Undefined object `#{name}`", node: node)
+        end
       end
     end
-    private :check_object
   end
 end

data/lib/theme_check/checks/valid_html_translation.rb

@@ -20,7 +20,7 @@ module ThemeCheck
       keys[-1].end_with?('_html') || pluralized_key.end_with?('_html')
     end
 
-    def parse_and_add_offence(key, value)
+    def parse_and_add_offense(key, value)
       return unless value.is_a?(String)
 
       html = Nokogiri::HTML5.fragment(value, max_errors: -1)
@@ -36,7 +36,7 @@ module ThemeCheck
           visit_nested(v, keys + [k])
         end
       elsif html_key?(keys)
-        parse_and_add_offence(keys.join('.'), value)
+        parse_and_add_offense(keys.join('.'), value)
       end
     end
   end

data/lib/theme_check/cli.rb

@@ -10,7 +10,9 @@ module ThemeCheck
         -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
         -h, [--help]              # Show this. Hi!
+        -v, [--version]           # Print Theme Check version
 
       Description:
         Theme Check helps you follow Shopify Themes & Liquid best practices by analyzing the
@@ -25,18 +27,23 @@ module ThemeCheck
       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
         else
           path = arg
         end
@@ -45,6 +52,7 @@ module ThemeCheck
       @config = ThemeCheck::Config.from_path(path)
       @config.only_categories = only_categories
       @config.exclude_categories = exclude_categories
+      @config.auto_correct = auto_correct
 
       send(command)
     end
@@ -63,16 +71,22 @@ module ThemeCheck
       puts @config.enabled_checks
     end
 
+    def version
+      puts ThemeCheck::VERSION
+    end
+
     def check
       puts "Checking #{@config.root} ..."
-      theme = ThemeCheck::Theme.new(@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}"
       end
-      analyzer = ThemeCheck::Analyzer.new(theme, @config.enabled_checks)
+      analyzer = ThemeCheck::Analyzer.new(theme, @config.enabled_checks, @config.auto_correct)
       analyzer.analyze_theme
-      ThemeCheck::Printer.new.print(theme, analyzer.offenses)
-      raise Abort, "" if analyzer.offenses.any?
+      analyzer.correct_offenses
+      ThemeCheck::Printer.new.print(theme, analyzer.offenses, @config.auto_correct)
+      raise Abort, "" if analyzer.uncorrectable_offenses.any?
     end
   end
 end

data/lib/theme_check/config.rb

@@ -4,20 +4,29 @@ module ThemeCheck
   class Config
     DOTFILE = '.theme-check.yml'
     DEFAULT_CONFIG = "#{__dir__}/../../config/default.yml"
+    BOOLEAN = [true, false]
 
     attr_reader :root
-    attr_accessor :only_categories, :exclude_categories
+    attr_accessor :only_categories, :exclude_categories, :auto_correct
 
     class << self
       def from_path(path)
         if (filename = find(path))
-          new(filename.dirname, load_file(filename))
+          new(root: filename.dirname, configuration: load_file(filename))
         else
           # No configuration file
-          new(path)
+          new(root: path)
         end
       end
 
+      def from_string(config)
+        new(configuration: YAML.load(config), should_resolve_requires: false)
+      end
+
+      def from_hash(config)
+        new(configuration: config, should_resolve_requires: false)
+      end
+
       def find(root, needle = DOTFILE)
         Pathname.new(root).descend.reverse_each do |path|
           pathname = path.join(needle)
@@ -29,80 +38,124 @@ module ThemeCheck
       def load_file(absolute_path)
         YAML.load_file(absolute_path)
       end
+
+      def default
+        @default ||= load_file(DEFAULT_CONFIG)
+      end
     end
 
-    def initialize(root, configuration = nil)
-      @configuration = configuration || {}
-      @checks = @configuration.dup
-      @root = Pathname.new(root)
-      if @checks.key?("root")
-        @root = @root.join(@checks.delete("root"))
+    def initialize(root: nil, configuration: nil, should_resolve_requires: true)
+      @configuration = if configuration
+        validate_configuration(configuration)
+      else
+        {}
+      end
+      merge_with_default_configuration!(@configuration)
+
+      @root = if root && @configuration.key?("root")
+        Pathname.new(root).join(@configuration["root"])
+      elsif root
+        Pathname.new(root)
       end
+
       @only_categories = []
       @exclude_categories = []
-      resolve_requires
+      @auto_correct = false
+
+      resolve_requires if @root && should_resolve_requires
+    end
+
+    def [](name)
+      @configuration[name]
     end
 
     def to_h
       @configuration
     end
 
-    def enabled_checks
-      checks = []
-
-      default_configuration.merge(@checks).each do |check_name, properties|
-        if @checks[check_name] && !default_configuration[check_name].nil?
-          valid_properties = valid_check_configuration(check_name)
-          properties = properties.merge(valid_properties)
-        end
+    def check_configurations
+      @check_configurations ||= @configuration.select { |name, _| check_name?(name) }
+    end
 
-        next if properties.delete('enabled') == false
+    def enabled_checks
+      @enabled_checks ||= check_configurations.map do |check_name, options|
+        next unless options["enabled"]
 
-        options = properties.transform_keys(&:to_sym)
         check_class = ThemeCheck.const_get(check_name)
+
         next if exclude_categories.include?(check_class.category)
         next if only_categories.any? && !only_categories.include?(check_class.category)
 
-        check = check_class.new(**options)
-        check.options = options
-        checks << check
-      end
+        options_for_check = options.transform_keys(&:to_sym)
+        options_for_check.delete(:enabled)
+        check = check_class.new(**options_for_check)
+        check.options = options_for_check
+        check
+      end.compact
+    end
 
-      checks
+    def ignored_patterns
+      self["ignore"] || []
     end
 
     private
 
-    def default_configuration
-      @default_configuration ||= Config.load_file(DEFAULT_CONFIG)
+    def check_name?(name)
+      name.start_with?(/[A-Z]/)
     end
 
-    def resolve_requires
-      if @checks.key?("require")
-        @checks.delete("require").tap do |paths|
-          paths.each do |path|
-            if path.start_with?('.')
-              require(File.join(@root, path))
-            end
+    def validate_configuration(configuration, default_configuration = self.class.default, parent_keys = [])
+      valid_configuration = {}
+
+      configuration.each do |key, value|
+        # No validation possible unless we have a default to compare to
+        unless default_configuration
+          valid_configuration[key] = value
+          next
+        end
+
+        default = default_configuration[key]
+        keys = parent_keys + [key]
+        name = keys.join(".")
+
+        if check_name?(key)
+          if value.is_a?(Hash)
+            valid_configuration[key] = validate_configuration(value, default, keys)
+          else
+            warn("bad configuration type for #{name}: expected a Hash, got #{value.inspect}")
           end
+        elsif default.nil?
+          warn("unknown configuration: #{name}")
+        elsif BOOLEAN.include?(default) && !BOOLEAN.include?(value)
+          warn("bad configuration type for #{name}: expected true or false, got #{value.inspect}")
+        elsif !BOOLEAN.include?(default) && default.class != value.class
+          warn("bad configuration type for #{name}: expected a #{default.class}, got #{value.inspect}")
+        else
+          valid_configuration[key] = value
         end
       end
-    end
 
-    def valid_check_configuration(check_name)
-      default_properties = default_configuration[check_name]
+      valid_configuration
+    end
 
-      valid = {}
+    def merge_with_default_configuration!(configuration, default_configuration = self.class.default)
+      default_configuration.each do |key, default|
+        value = configuration[key]
 
-      @checks[check_name].each do |property, value|
-        if !default_properties.key?(property)
-          warn("#{check_name} does not support #{property} parameter.")
-        else
-          valid[property] = value
+        case value
+        when Hash
+          merge_with_default_configuration!(value, default)
+        when nil
+          configuration[key] = default
         end
       end
+      configuration
+    end
 
-      valid
+    def resolve_requires
+      self["require"]&.each do |path|
+        require(File.join(@root, path))
+      end
     end
   end
 end