theme-check 0.2.2 → 0.4.0

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|

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

@@ -49,23 +49,28 @@ module ThemeCheck
       end
     end
 
-    def initialize
+    def initialize(exclude_snippets: false)
+      @exclude_snippets = exclude_snippets
       @files = {}
     end
 
     def on_document(node)
+      return if ignore?(node)
       @files[node.template.name] = TemplateInfo.new
     end
 
     def on_assign(node)
+      return if ignore?(node)
       @files[node.template.name].all_assigns[node.value.to] = node
     end
 
     def on_capture(node)
+      return if ignore?(node)
       @files[node.template.name].all_captures[node.value.instance_variable_get('@to')] = node
     end
 
     def on_for(node)
+      return if ignore?(node)
       @files[node.template.name].all_forloops[node.value.variable_name] = node
     end
 
@@ -75,6 +80,7 @@ module ThemeCheck
     end
 
     def on_render(node)
+      return if ignore?(node)
       return unless node.value.template_name_expr.is_a?(String)
 
       snippet_name = "snippets/#{node.value.template_name_expr}"
@@ -85,6 +91,7 @@ module ThemeCheck
     end
 
     def on_variable_lookup(node)
+      return if ignore?(node)
       @files[node.template.name].add_variable_lookup(
         name: node.value.name,
         node: node,
@@ -95,26 +102,39 @@ module ThemeCheck
       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
           check_object(info, all_global_objects)
         end
       end
     end
 
+    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
-    private :each_template
 
-    def check_object(info, all_global_objects, render_node = nil)
+    def check_object(info, all_global_objects, render_node = nil, visited_snippets = Set.new)
       check_undefined(info, all_global_objects, render_node)
 
       info.each_snippet do |(snippet_name, node)|
@@ -123,10 +143,12 @@ module ThemeCheck
 
         snippet_variables = node.value.attributes.keys +
           Array[node.value.instance_variable_get("@alias_name")]
-        check_object(snippet_info, all_global_objects + snippet_variables, node)
+        unless visited_snippets.include?(snippet_name)
+          visited_snippets << snippet_name
+          check_object(snippet_info, all_global_objects + snippet_variables, node, visited_snippets)
+        end
       end
     end
-    private :check_object
 
     def check_undefined(info, all_global_objects, render_node)
       all_variables = info.all_variables
@@ -146,6 +168,5 @@ module ThemeCheck
         end
       end
     end
-    private :check_undefined
   end
 end

data/lib/theme_check/checks/unused_assign.rb

@@ -6,12 +6,13 @@ module ThemeCheck
     category :liquid
 
     class TemplateInfo < Struct.new(:used_assigns, :assign_nodes, :includes)
-      def collect_used_assigns(templates)
+      def collect_used_assigns(templates, visited = Set.new)
         collected = used_assigns
         # Check recursively inside included snippets for use
         includes.each do |name|
-          if templates[name]
-            collected += templates[name].collect_used_assigns(templates)
+          if templates[name] && !visited.include?(name)
+            visited << name
+            collected += templates[name].collect_used_assigns(templates, visited)
           end
         end
         collected

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

@@ -11,7 +11,9 @@ module ThemeCheck
         -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
 
       Description:
         Theme Check helps you follow Shopify Themes & Liquid best practices by analyzing the
@@ -21,7 +23,7 @@ module ThemeCheck
     END
 
     def run(argv)
-      path = "."
+      @path = "."
 
       command = :check
       only_categories = []
@@ -33,6 +35,8 @@ module ThemeCheck
         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"
@@ -41,15 +45,19 @@ module ThemeCheck
           command = :list
         when "--auto-correct", "-a"
           auto_correct = true
+        when "--init"
+          command = :init
         else
-          path = arg
+          @path = arg
         end
       end
 
-      @config = ThemeCheck::Config.from_path(path)
-      @config.only_categories = only_categories
-      @config.exclude_categories = exclude_categories
-      @config.auto_correct = auto_correct
+      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)
     end
@@ -68,9 +76,25 @@ module ThemeCheck
       puts @config.enabled_checks
     end
 
+    def version
+      puts ThemeCheck::VERSION
+    end
+
+    def init
+      dotfile_path = ThemeCheck::Config.find(@path)
+      if dotfile_path.nil?
+        File.write(File.join(@path, ThemeCheck::Config::DOTFILE), File.read(ThemeCheck::Config::DEFAULT_CONFIG))
+
+        puts "Writing new #{ThemeCheck::Config::DOTFILE} to #{@path}"
+      else
+        raise Abort, "#{ThemeCheck::Config::DOTFILE} already exists at #{@path}."
+      end
+    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

data/lib/theme_check/config.rb

@@ -4,6 +4,7 @@ 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, :auto_correct
@@ -11,13 +12,21 @@ module ThemeCheck
     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,81 +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 = []
       @auto_correct = false
-      resolve_requires
+
+      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