theme-check 0.2.2 → 0.3.0

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

@@ -12,6 +12,7 @@ module ThemeCheck
         -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
@@ -33,6 +34,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"
@@ -68,9 +71,14 @@ 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

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

data/lib/theme_check/corrector.rb

@@ -9,27 +9,23 @@ module ThemeCheck
     def insert_after(node, content)
       line = @template.full_line(node.line_number)
       line.insert(node.range[1] + 1, content)
-      @template.update!
     end
 
     def insert_before(node, content)
       line = @template.full_line(node.line_number)
       line.insert(node.range[0], content)
-      @template.update!
     end
 
     def replace(node, content)
       line = @template.full_line(node.line_number)
       line[node.range[0]..node.range[1]] = content
       node.markup = content
-      @template.update!
     end
 
     def wrap(node, insert_before, insert_after)
       line = @template.full_line(node.line_number)
       line.insert(node.range[0], insert_before)
       line.insert(node.range[1] + 1 + insert_before.length, insert_after)
-      @template.update!
     end
   end
 end

data/lib/theme_check/disabled_checks.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  class DisabledChecks
+    DISABLE_START = 'theme-check-disable'
+    DISABLE_END = 'theme-check-enable'
+    DISABLE_PREFIX_PATTERN = /#{DISABLE_START}|#{DISABLE_END}/
+
+    ACTION_DISABLE_CHECKS = :disable
+    ACTION_ENABLE_CHECKS = :enable
+    ACTION_UNRELATED_COMMENT = :unrelated
+
+    def initialize
+      @disabled = []
+      @all_disabled = false
+      @full_document_disabled = false
+    end
+
+    def update(node)
+      text = comment_text(node)
+
+      if start_disabling?(text)
+        @disabled = checks_from_text(text)
+        @all_disabled = @disabled.empty?
+
+        if node&.line_number == 1
+          @full_document_disabled = true
+        end
+      elsif stop_disabling?(text)
+        checks = checks_from_text(text)
+        @disabled = checks.empty? ? [] : @disabled - checks
+
+        @all_disabled = false
+      end
+    end
+
+    # Whether any checks are currently disabled
+    def any?
+      !@disabled.empty? || @all_disabled
+    end
+
+    # Whether all checks should be disabled
+    def all_disabled?
+      @all_disabled
+    end
+
+    # Get a list of all the individual disabled checks
+    def all
+      @disabled
+    end
+
+    # If the first line of the document is a theme-check-disable comment
+    def full_document_disabled?
+      @full_document_disabled
+    end
+
+    private
+
+    def comment_text(node)
+      node.value.nodelist.join
+    end
+
+    def start_disabling?(text)
+      text.strip.starts_with?(DISABLE_START)
+    end
+
+    def stop_disabling?(text)
+      text.strip.starts_with?(DISABLE_END)
+    end
+
+    # Return a list of checks from a theme-check-disable comment
+    # Returns [] if all checks are meant to be disabled
+    def checks_from_text(text)
+      text.gsub(DISABLE_PREFIX_PATTERN, '').strip.split(',').map(&:strip)
+    end
+  end
+end

data/lib/theme_check/file_system_storage.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+require "pathname"
+
+module ThemeCheck
+  class FileSystemStorage < Storage
+    attr_reader :root
+
+    def initialize(root, ignored_patterns: [])
+      @root = Pathname.new(root)
+      @ignored_patterns = ignored_patterns
+      @files = {}
+    end
+
+    def path(relative_path)
+      @root.join(relative_path)
+    end
+
+    def read(relative_path)
+      file(relative_path).read
+    end
+
+    def write(relative_path, content)
+      file(relative_path).write(content)
+    end
+
+    def files
+      @file_array ||= glob("**/*")
+        .map { |path| path.relative_path_from(@root).to_s }
+    end
+
+    def directories
+      @directories ||= glob('*')
+        .select { |f| File.directory?(f) }
+        .map { |f| f.relative_path_from(@root).to_s }
+    end
+
+    private
+
+    def glob(pattern)
+      @root.glob(pattern).reject do |path|
+        relative_path = path.relative_path_from(@root)
+        @ignored_patterns.any? { |ignored| relative_path.fnmatch?(ignored) }
+      end
+    end
+
+    def file(name)
+      return @files[name] if @files[name]
+      @files[name] = root.join(name)
+    end
+  end
+end

data/lib/theme_check/in_memory_storage.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# An in-memory storage is not written to disk. The reasons why you'd
+# want to do that are your own. The idea is to not write to disk
+# something that doesn't need to be there. If you have your template
+# as a big hash already, leave it like that and save yourself some IO.
+module ThemeCheck
+  class InMemoryStorage < Storage
+    def initialize(files)
+      @files = files
+    end
+
+    def path(name)
+      name
+    end
+
+    def read(name)
+      @files[name]
+    end
+
+    def write(name, content)
+      @files[name] = content
+    end
+
+    def files
+      @values ||= @files.keys
+    end
+
+    def directories
+      @directories ||= @files
+        .keys
+        .flat_map { |relative_path| Pathname.new(relative_path).ascend.to_a }
+        .map(&:to_s)
+        .uniq
+    end
+  end
+end

data/lib/theme_check/json_file.rb

@@ -4,22 +4,20 @@ require "pathname"
 
 module ThemeCheck
   class JsonFile
-    attr_reader :path
-
-    def initialize(path, root)
-      @path = Pathname(path)
-      @root = Pathname(root)
+    def initialize(relative_path, storage)
+      @relative_path = relative_path
+      @storage = storage
       @loaded = false
       @content = nil
       @parser_error = nil
     end
 
-    def relative_path
-      @path.relative_path_from(@root)
+    def path
+      @storage.path(@relative_path)
     end
 
-    def name
-      relative_path.sub_ext('').to_s
+    def relative_path
+      @relative_pathname ||= Pathname.new(@relative_path)
     end
 
     def content
@@ -32,12 +30,16 @@ module ThemeCheck
       @parser_error
     end
 
+    def name
+      relative_path.sub_ext('').to_s
+    end
+
     private
 
     def load!
       return if @loaded
 
-      @content = JSON.parse(File.read(@path))
+      @content = JSON.parse(@storage.read(@relative_path))
     rescue JSON::ParserError => e
       @parser_error = e
     ensure