theme-check 0.1.0

data/lib/theme_check/checks/template_length.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module ThemeCheck
+  class TemplateLength < LiquidCheck
+    severity :suggestion
+    category :liquid
+
+    def initialize(max_length: 200)
+      @max_length = max_length
+    end
+
+    def on_document(node)
+      lines = node.template.source.count("\n")
+      if lines > @max_length
+        add_offense("Template has too many lines [#{lines}/#{@max_length}]", template: node.template)
+      end
+    end
+  end
+end

data/lib/theme_check/checks/translation_key_exists.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module ThemeCheck
+  class TranslationKeyExists < LiquidCheck
+    severity :error
+    category :translation
+
+    def on_variable(node)
+      return unless @theme.default_locale_json&.content&.is_a?(Hash)
+
+      return unless node.value.filters.any? { |name, _| name == "t" || name == "translate" }
+      return unless (key_node = node.children.first)
+      return unless key_node.value.is_a?(String)
+
+      unless key_exists?(key_node.value)
+        add_offense(
+          "'#{key_node.value}' does not have a matching entry in '#{@theme.default_locale_json.relative_path}'",
+          node: node,
+          markup: key_node.value,
+        )
+      end
+    end
+
+    private
+
+    def key_exists?(key)
+      pointer = @theme.default_locale_json.content
+      key.split(".").each do |token|
+        return false unless pointer.key?(token)
+        pointer = pointer[token]
+      end
+
+      true
+    end
+  end
+end

data/lib/theme_check/checks/undefined_object.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+module ThemeCheck
+  class UndefinedObject < LiquidCheck
+    category :liquid
+    doc "https://shopify.dev/docs/themes/liquid/reference/objects"
+    severity :error
+
+    class TemplateInfo
+      def initialize
+        @all_variable_lookups = {}
+        @all_assigns = {}
+        @all_captures = {}
+        @all_forloops = {}
+      end
+
+      attr_reader :all_variable_lookups, :all_assigns, :all_captures, :all_forloops
+      def all
+        all_assigns.keys + all_captures.keys + all_forloops.keys
+      end
+    end
+
+    def initialize
+      @templates = {}
+      @used_snippets = {}
+    end
+
+    def on_document(node)
+      @templates[node.template.name] = TemplateInfo.new
+    end
+
+    def on_assign(node)
+      @templates[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
+    end
+
+    def on_for(node)
+      @templates[node.template.name].all_forloops[node.value.variable_name] = node
+    end
+
+    def on_include(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
+    end
+
+    def on_variable_lookup(node)
+      @templates[node.template.name].all_variable_lookups[node.value.name] = 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
+        else
+          all = info.all
+          all += ['email'] if 'templates/customers/reset_password' == template_name
+          check_object(info.all_variable_lookups, all)
+        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)
+
+        parent = node.parent
+        parent = parent.parent if :variable_lookup == parent.type_name
+        add_offense("Undefined object `#{name}`", node: parent)
+      end
+    end
+    private :check_object
+  end
+end

data/lib/theme_check/checks/unknown_filter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module ThemeCheck
+  #
+  # Unwanted:
+  #
+  # {{ x | some_unknown_filter }}
+  #
+  # Wanted:
+  #
+  # {{ x | upcase }}
+  #
+  class UnknownFilter < LiquidCheck
+    severity :error
+    category :liquid
+
+    def on_variable(node)
+      used_filters = node.value.filters.map { |name, *_rest| name }
+      undefined_filters = used_filters - ShopifyLiquid::Filter.labels
+
+      undefined_filters.each do |undefined_filter|
+        add_offense("Undefined filter `#{undefined_filter}`", node: node)
+      end
+    end
+  end
+end

data/lib/theme_check/checks/unused_assign.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+module ThemeCheck
+  # Checks unused {% assign x = ... %}
+  class UnusedAssign < LiquidCheck
+    severity :suggestion
+    category :liquid
+
+    class TemplateInfo < Struct.new(:used_assigns, :assign_nodes, :includes)
+      def collect_used_assigns(templates)
+        collected = used_assigns
+        # Check recursively inside included snippets for use
+        includes.each do |name|
+          if templates[name]
+            collected += templates[name].collect_used_assigns(templates)
+          end
+        end
+        collected
+      end
+    end
+
+    def initialize
+      @templates = {}
+    end
+
+    def on_document(node)
+      @templates[node.template.name] = TemplateInfo.new(Set.new, {}, Set.new)
+    end
+
+    def on_assign(node)
+      @templates[node.template.name].assign_nodes[node.value.to] = node
+    end
+
+    def on_include(node)
+      if node.value.template_name_expr.is_a?(String)
+        @templates[node.template.name].includes << "snippets/#{node.value.template_name_expr}"
+      end
+    end
+
+    def on_variable_lookup(node)
+      @templates[node.template.name].used_assigns << node.value.name
+    end
+
+    def on_end
+      @templates.each_pair do |_, info|
+        used = info.collect_used_assigns(@templates)
+        info.assign_nodes.each_pair do |name, node|
+          unless used.include?(name)
+            add_offense("`#{name}` is never used", node: node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/theme_check/checks/unused_snippet.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require "set"
+
+module ThemeCheck
+  class UnusedSnippet < LiquidCheck
+    severity :suggestion
+    category :liquid
+
+    def initialize
+      @used_templates = Set.new
+    end
+
+    def on_include(node)
+      if node.value.template_name_expr.is_a?(String)
+        @used_templates << "snippets/#{node.value.template_name_expr}"
+      else
+        # Can't reliably track unused snippets if an expression is used, ignore this check
+        @used_templates.clear
+        ignore!
+      end
+    end
+    alias_method :on_render, :on_include
+
+    def on_end
+      missing_snippets.each do |template|
+        add_offense("This template is not used", template: template)
+      end
+    end
+
+    def missing_snippets
+      theme.snippets.reject { |t| @used_templates.include?(t.name) }
+    end
+  end
+end

data/lib/theme_check/checks/valid_html_translation.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'nokogumbo'
+
+module ThemeCheck
+  class ValidHTMLTranslation < JsonCheck
+    severity :suggestion
+
+    def on_file(file)
+      return unless file.name.starts_with?("locales/")
+      return unless file.content.is_a?(Hash)
+
+      visit_nested(file.content)
+    end
+
+    private
+
+    def html_key?(keys)
+      pluralized_key = keys[-2] if keys.length > 1
+      keys[-1].end_with?('_html') || pluralized_key.end_with?('_html')
+    end
+
+    def parse_and_add_offence(key, value)
+      return unless value.is_a?(String)
+
+      html = Nokogiri::HTML5.fragment(value, max_errors: -1)
+      unless html.errors.empty?
+        err_msg = html.errors.join("\n")
+        add_offense("'#{key}' contains invalid HTML:\n#{err_msg}")
+      end
+    end
+
+    def visit_nested(value, keys = [])
+      if value.is_a?(Hash)
+        value.each do |k, v|
+          visit_nested(v, keys + [k])
+        end
+      elsif html_key?(keys)
+        parse_and_add_offence(keys.join('.'), value)
+      end
+    end
+  end
+end

data/lib/theme_check/checks/valid_json.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module ThemeCheck
+  class ValidJson < JsonCheck
+    severity :error
+    category :json
+
+    def on_file(file)
+      if file.parse_error
+        message = format_json_parse_error(file.parse_error)
+        add_offense(message, template: file)
+      end
+    end
+  end
+end

data/lib/theme_check/checks/valid_schema.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module ThemeCheck
+  class ValidSchema < LiquidCheck
+    severity :suggestion
+    category :json
+
+    def on_schema(node)
+      JSON.parse(node.value.nodelist.join)
+    rescue JSON::ParserError => e
+      add_offense(format_json_parse_error(e), node: node)
+    end
+  end
+end

data/lib/theme_check/checks_tracking.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module ThemeCheck
+  module ChecksTracking
+    def inherited(klass)
+      Check.all << klass
+    end
+  end
+end

data/lib/theme_check/cli.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+module ThemeCheck
+  class Cli
+    class Abort < StandardError; end
+
+    USAGE = <<~END
+      Usage: theme-check [options] /path/to/your/theme
+
+      Options:
+        -c, [--category]          # Only run this category of checks
+        -x, [--exclude-category]  # Exclude this category of checks
+        -l, [--list]              # List enabled checks
+        -h, [--help]              # Show this. Hi!
+
+      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.
+    END
+
+    def run(argv)
+      path = "."
+
+      command = :check
+      only_categories = []
+      exclude_categories = []
+
+      args = argv.dup
+      while (arg = args.shift)
+        case arg
+        when "--help", "-h"
+          raise Abort, USAGE
+        when "--category", "-c"
+          only_categories << args.shift.to_sym
+        when "--exclude-category", "-x"
+          exclude_categories << args.shift.to_sym
+        when "--list", "-l"
+          command = :list
+        else
+          path = arg
+        end
+      end
+
+      @config = ThemeCheck::Config.from_path(path)
+      @config.only_categories = only_categories
+      @config.exclude_categories = exclude_categories
+
+      send(command)
+    end
+
+    def run!(argv)
+      run(argv)
+    rescue Abort => e
+      if e.message.empty?
+        exit(1)
+      else
+        abort(e.message)
+      end
+    end
+
+    def list
+      puts @config.enabled_checks
+    end
+
+    def check
+      puts "Checking #{@config.root} ..."
+      theme = ThemeCheck::Theme.new(@config.root)
+      if theme.all.empty?
+        raise Abort, "No templates found.\n#{USAGE}"
+      end
+      analyzer = ThemeCheck::Analyzer.new(theme, @config.enabled_checks)
+      analyzer.analyze_theme
+      ThemeCheck::Printer.new.print(theme, analyzer.offenses)
+      raise Abort, "" if analyzer.offenses.any?
+    end
+  end
+end

data/lib/theme_check/config.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  class Config
+    DOTFILE = '.theme-check.yml'
+    DEFAULT_CONFIG = "#{__dir__}/../../config/default.yml"
+
+    attr_reader :root
+    attr_accessor :only_categories, :exclude_categories
+
+    class << self
+      def from_path(path)
+        if (filename = find(path))
+          new(filename.dirname, load_file(filename))
+        else
+          # No configuration file
+          new(path)
+        end
+      end
+
+      def find(root, needle = DOTFILE)
+        Pathname.new(root).descend.reverse_each do |path|
+          pathname = path.join(needle)
+          return pathname if pathname.exist?
+        end
+        nil
+      end
+
+      def load_file(absolute_path)
+        YAML.load_file(absolute_path)
+      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"))
+      end
+      @only_categories = []
+      @exclude_categories = []
+      resolve_requires
+    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
+
+        next if properties.delete('enabled') == false
+
+        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
+
+      checks
+    end
+
+    private
+
+    def default_configuration
+      @default_configuration ||= Config.load_file(DEFAULT_CONFIG)
+    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
+          end
+        end
+      end
+    end
+
+    def valid_check_configuration(check_name)
+      default_properties = default_configuration[check_name]
+
+      valid = {}
+
+      @checks[check_name].each do |property, value|
+        if !default_properties.key?(property)
+          warn("#{check_name} does not support #{property} parameter.")
+        else
+          valid[property] = value
+        end
+      end
+
+      valid
+    end
+  end
+end