theme-check 1.8.0 → 1.9.0

data/lib/theme_check/checks/remote_asset.rb

@@ -22,6 +22,7 @@ module ThemeCheck
       return if resource_url =~ ABSOLUTE_PATH
       return if resource_url =~ RELATIVE_PATH
       return if url_hosted_by_shopify?(resource_url)
+      return if url_is_setting_variable?(resource_url)
 
       # Ignore non-stylesheet link tags
       rel = node.attributes["rel"]
@@ -39,5 +40,9 @@ module ThemeCheck
       url.start_with?(Liquid::VariableStart) &&
         AssetUrlFilters::ASSET_URL_FILTERS.any? { |filter| url.include?(filter) }
     end
+
+    def url_is_setting_variable?(url)
+      url.start_with?(Liquid::VariableStart) && url =~ /settings\./
+    end
   end
 end

data/lib/theme_check/checks/required_directories.rb

@@ -19,7 +19,7 @@ module ThemeCheck
 
     def add_missing_directories_offense(directory)
       add_offense("Theme is missing '#{directory}' directory") do |corrector|
-        corrector.mkdir(@theme, directory)
+        corrector.mkdir(@theme.storage, directory)
       end
     end
   end

data/lib/theme_check/checks/schema_json_format.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module ThemeCheck
+  class SchemaJsonFormat < LiquidCheck
+    severity :style
+    category :liquid
+    doc docs_url(__FILE__)
+
+    def initialize(start_level: 0, indent: '  ')
+      @pretty_json_opts = {
+        indent: indent,
+        start_level: start_level,
+      }
+    end
+
+    def on_schema(node)
+      schema = node.inner_json
+      return if schema.nil?
+      pretty_schema = pretty_json(schema, **@pretty_json_opts)
+      if pretty_schema != node.inner_markup
+        add_offense(
+          "JSON formatting could be improved",
+          node: node,
+        ) do |corrector|
+          corrector.replace_inner_json(node, schema, **@pretty_json_opts)
+        end
+      end
+    end
+  end
+end

data/lib/theme_check/checks/space_inside_braces.rb

@@ -6,115 +6,160 @@ module ThemeCheck
     category :liquid
     doc docs_url(__FILE__)
 
-    def initialize
-      @ignore = false
-    end
-
     def on_node(node)
       return unless node.markup
-      return if :assign == node.type_name
+      return if node.literal?
+      return if node.assigned_or_echoed_variable?
 
       outside_of_strings(node.markup) do |chunk, chunk_start|
-        chunk.scan(/([,:|]|==|<>|<=|>=|<|>|!=)(  +)/) do |_match|
-          add_offense(
-            "Too many spaces after '#{Regexp.last_match(1)}'",
-            node: node,
-            markup: Regexp.last_match(2),
-            node_markup_offset: chunk_start + Regexp.last_match.begin(2)
-          )
+        chunk.scan(/(?<token>[,:|]|==|<>|<=|>=|<|>|!=)(?<offense>  +)/) do |_match|
+          add_too_many_spaces_after_offense(Regexp.last_match, node, chunk_start)
         end
-        chunk.scan(/([,:|]|==|<>|<=|>=|<\b|>\b|!=)(\S|\z)/) do |_match|
-          add_offense(
-            "Space missing after '#{Regexp.last_match(1)}'",
-            node: node,
-            markup: Regexp.last_match(1),
-            node_markup_offset: chunk_start + Regexp.last_match.begin(0),
-          )
+        chunk.scan(/(?<offense>(?<token>[,:|]|==|<>|<=|>=|<\b|>\b|!=)(\S|\z))/) do |_match|
+          add_space_missing_after_offense(Regexp.last_match, node, chunk_start)
         end
-        chunk.scan(/(  +)(\||==|<>|<=|>=|<|>|!=)+/) do |_match|
-          add_offense(
-            "Too many spaces before '#{Regexp.last_match(2)}'",
-            node: node,
-            markup: Regexp.last_match(1),
-            node_markup_offset: chunk_start + Regexp.last_match.begin(1)
-          )
+        chunk.scan(/(?<offense>\s{2,})(?<token>\||==|<>|<=|>=|<|>|!=)+/) do |_match|
+          unless Regexp.last_match(:offense).include?("\n")
+            add_too_many_spaces_before_offense(Regexp.last_match, node, chunk_start)
+          end
         end
-        chunk.scan(/(\A|\S)(?<match>\||==|<>|<=|>=|<|\b>|!=)/) do |_match|
-          add_offense(
-            "Space missing before '#{Regexp.last_match(1)}'",
-            node: node,
-            markup: Regexp.last_match(:match),
-            node_markup_offset: chunk_start + Regexp.last_match.begin(:match)
-          )
+        chunk.scan(/(\A|\S)(?<offense>(?<token>\||==|<>|<=|>=|<|\b>|!=))/) do |_match|
+          add_space_missing_before_offense(Regexp.last_match, node, chunk_start)
         end
       end
     end
 
+    BlockMarkup = Struct.new(:markup, :node_markup_offset)
+
     def on_tag(node)
-      unless node.inside_liquid_tag?
-        if node.markup[-1] != " " && node.markup[-1] != "\n"
-          add_offense(
-            "Space missing before '#{node.end_token}'",
-            node: node,
-            markup: node.markup[-1],
-            node_markup_offset: node.markup.size - 1,
-          )
-        elsif node.markup =~ /(\n?)(  +)\z/m && Regexp.last_match(1) != "\n"
-          add_offense(
-            "Too many spaces before '#{node.end_token}'",
-            node: node,
-            markup: Regexp.last_match(2),
-            node_markup_offset: node.markup.size - Regexp.last_match(2).size
-          )
+      return if node.inside_liquid_tag?
+
+      # Both the start and end tags
+      blocks = [
+        BlockMarkup.new(node.block_start_markup, node.block_start_start_index - node.start_index),
+        BlockMarkup.new(node.block_end_markup, node.block_end_start_index - node.start_index),
+      ]
+
+      blocks.each do |block|
+        # Looking at spaces after the start token
+        if block.markup =~ /^(?<token>{%-?)(?<offense>[^ \n\t-])/
+          add_space_missing_after_offense(Regexp.last_match, node, block.node_markup_offset)
+        end
+
+        if block.markup =~ /^(?<token>{%-?)(?<offense> {2,})\S/
+          add_too_many_spaces_after_offense(Regexp.last_match, node, block.node_markup_offset)
+        end
+
+        # Looking at spaces before the end token
+        if block.markup =~ /(?<offense>[^ \n\t-])(?<token>-?%})$/
+          add_space_missing_before_offense(Regexp.last_match, node, block.node_markup_offset)
         end
+
+        if block.markup =~ /\S(?<offense> {2,})(?<token>-?%})$/
+          add_too_many_spaces_before_offense(Regexp.last_match, node, block.node_markup_offset)
+        end
+
+        next
       end
-      @ignore = true
     end
 
-    def after_tag(_node)
-      @ignore = false
+    def on_variable(node)
+      return if node.markup.empty?
+      return if node.assigned_or_echoed_variable?
+
+      block_start_offset = node.block_start_start_index - node.start_index
+
+      # Looking at spaces after the start token
+      if node.block_start_markup =~ /^(?<token>{{-?)(?<offense>[^ \n\t-])/
+        add_space_missing_after_offense(Regexp.last_match, node, block_start_offset)
+      end
+
+      if node.block_start_markup =~ /^(?<token>{{-?)(?<offense> {2,})\S/
+        add_too_many_spaces_after_offense(Regexp.last_match, node, block_start_offset)
+      end
+
+      # Looking at spaces before the end token
+      if node.block_start_markup =~ /(?<offense>[^ \n\t-])(?<token>-?}})$/
+        add_space_missing_before_offense(Regexp.last_match, node, block_start_offset)
+      end
+
+      if node.block_start_markup =~ /\S(?<offense> {2,})(?<token>-?}})$/
+        add_too_many_spaces_before_offense(Regexp.last_match, node, block_start_offset)
+      end
     end
 
-    def on_variable(node)
-      return if @ignore || node.markup.empty?
-      if node.markup[0] != " "
-        add_offense(
-          "Space missing after '#{node.start_token}'",
-          node: node,
-          markup: node.markup[0]
-        ) do |corrector|
-          corrector.insert_before(node, " ")
-        end
+    def add_space_missing_after_offense(match, node, source_offset)
+      add_offense_for_match(
+        "Space missing after '#{match[:token]}'",
+        match,
+        node,
+        source_offset
+      ) do |corrector|
+        corrector.insert_after(
+          node,
+          ' ',
+          (node.start_index + source_offset + match.begin(:token))...
+          (node.start_index + source_offset + match.end(:token))
+        )
       end
-      if node.markup[-1] != " " && node.markup[-1] != "\n"
-        add_offense(
-          "Space missing before '#{node.end_token}'",
-          node: node,
-          markup: node.markup[-1],
-          node_markup_offset: node.markup.size - 1,
-        ) do |corrector|
-          corrector.insert_after(node, " ")
-        end
+    end
+
+    def add_too_many_spaces_after_offense(match, node, source_offset)
+      add_offense_for_match(
+        "Too many spaces after '#{match[:token]}'",
+        match,
+        node,
+        source_offset
+      ) do |corrector|
+        corrector.replace(
+          node,
+          ' ',
+          (node.start_index + source_offset + match.begin(:offense))...
+          (node.start_index + source_offset + match.end(:offense))
+        )
       end
-      if node.markup =~ /\A(  +)/m
-        add_offense(
-          "Too many spaces after '#{node.start_token}'",
-          node: node,
-          markup: Regexp.last_match(1),
-        ) do |corrector|
-          corrector.replace(node, " #{node.markup.lstrip}")
-        end
+    end
+
+    def add_space_missing_before_offense(match, node, source_offset)
+      add_offense_for_match(
+        "Space missing before '#{match[:token]}'",
+        match,
+        node,
+        source_offset
+      ) do |corrector|
+        corrector.insert_before(
+          node,
+          ' ',
+          (node.start_index + source_offset + match.begin(:token))...
+          (node.start_index + source_offset + match.end(:token))
+        )
       end
-      if node.markup =~ /(\n?)(  +)\z/m && Regexp.last_match(1) != "\n"
-        add_offense(
-          "Too many spaces before '#{node.end_token}'",
-          node: node,
-          markup: Regexp.last_match(2),
-          node_markup_offset: node.markup.size - Regexp.last_match(2).size
-        ) do |corrector|
-          corrector.replace(node, "#{node.markup.rstrip} ")
-        end
+    end
+
+    def add_too_many_spaces_before_offense(match, node, source_offset)
+      add_offense_for_match(
+        "Too many spaces before '#{match[:token]}'",
+        match,
+        node,
+        source_offset
+      ) do |corrector|
+        corrector.replace(
+          node,
+          ' ',
+          (node.start_index + source_offset + match.begin(:offense))...
+          (node.start_index + source_offset + match.end(:offense))
+        )
       end
     end
+
+    def add_offense_for_match(message, match, node, source_offset, &block)
+      add_offense(
+        message,
+        node: node,
+        markup: match[:offense],
+        node_markup_offset: source_offset + match.begin(:offense),
+        &block
+      )
+    end
   end
 end

data/lib/theme_check/checks/translation_key_exists.rb

@@ -5,28 +5,48 @@ module ThemeCheck
     category :translation
     doc docs_url(__FILE__)
 
+    def initialize
+      @schema_locales = {}
+      @nodes = {}
+    end
+
+    def on_document(node)
+      @nodes[node.theme_file.name] = []
+    end
+
     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) || ShopifyLiquid::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,
-          markup: key_node.value,
-        ) do |corrector|
-          corrector.add_default_translation_key(@theme.default_locale_json, key_node.value.split("."), "TODO")
+
+      @nodes[node.theme_file.name] << node
+    end
+
+    def on_schema(node)
+      if (schema_locales = node.inner_json&.dig("locales", @theme.default_locale))
+        @schema_locales = schema_locales
+      end
+    end
+
+    def on_end
+      @nodes.each_pair do |_file_name, file_nodes|
+        file_nodes.each do |node|
+          next unless (key_node = node.children.first)
+          next unless key_node.value.is_a?(String)
+          next if key_exists?(key_node.value, @theme.default_locale_json.content) || key_exists?(key_node.value, @schema_locales) || ShopifyLiquid::SystemTranslations.include?(key_node.value)
+          add_offense(
+            @schema_locales.empty? ? "'#{key_node.value}' does not have a matching entry in '#{@theme.default_locale_json.relative_path}'" : "'#{key_node.value}' does not have a matching entry in '#{@theme.default_locale_json.relative_path}' or '#{node.theme_file.relative_path}'",
+            node: node,
+            markup: key_node.value
+          ) do |corrector|
+            corrector.add_translation(@theme.default_locale_json, key_node.value.split("."), "TODO")
+          end
         end
       end
     end
 
     private
 
-    def key_exists?(key)
-      pointer = @theme.default_locale_json.content
+    def key_exists?(key, pointer)
       key.split(".").each do |token|
         return false unless pointer.key?(token)
         pointer = pointer[token]

data/lib/theme_check/checks/unused_snippet.rb

@@ -25,7 +25,7 @@ module ThemeCheck
     def on_end
       missing_snippets.each do |theme_file|
         add_offense("This snippet is not used", theme_file: theme_file) do |corrector|
-          corrector.remove_file(@theme, theme_file.relative_path.to_s)
+          corrector.remove_file(@theme.storage, theme_file.relative_path.to_s)
         end
       end
     end

data/lib/theme_check/checks/valid_html_translation.rb

@@ -19,7 +19,7 @@ module ThemeCheck
 
     def html_key?(keys)
       pluralized_key = keys[-2] if keys.length > 1
-      keys[-1].end_with?('_html') || pluralized_key.end_with?('_html')
+      keys[-1].end_with?('_html') || pluralized_key&.end_with?('_html')
     end
 
     def parse_and_add_offense(key, value)

data/lib/theme_check/checks/valid_schema.rb

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

data/lib/theme_check/corrector.rb

@@ -2,89 +2,63 @@
 
 module ThemeCheck
   class Corrector
+    include JsonHelpers
+
     def initialize(theme_file:)
       @theme_file = theme_file
     end
 
-    def insert_after(node, content)
-      @theme_file.rewriter.insert_after(node, content)
+    def insert_after(node, content, character_range = nil)
+      @theme_file.rewriter.insert_after(node, content, character_range)
     end
 
-    def insert_before(node, content)
-      @theme_file.rewriter.insert_before(node, content)
+    def insert_before(node, content, character_range = nil)
+      @theme_file.rewriter.insert_before(node, content, character_range)
     end
 
     def remove(node)
       @theme_file.rewriter.remove(node)
     end
 
-    def replace(node, content)
-      @theme_file.rewriter.replace(node, content)
+    def replace(node, content, character_range = nil)
+      @theme_file.rewriter.replace(node, content, character_range)
       node.markup = content
     end
 
-    def replace_block_body(node, content)
-      content = "\n  #{JSON.pretty_generate(content, array_nl: "\n  ", object_nl: "\n  ")}\n" if content.is_a?(Hash)
-      @theme_file.rewriter.replace_body(node, content)
-    end
-
-    def wrap(node, insert_before, insert_after)
-      @theme_file.rewriter.wrap(node, insert_before, insert_after)
-    end
-
-    def create(theme, relative_path, content)
-      theme.storage.write(relative_path, content)
+    def replace_inner_markup(node, content)
+      @theme_file.rewriter.replace_inner_markup(node, content)
     end
 
-    def create_default_locale_json(theme)
-      create(theme, "locales/#{theme.default_locale}.default.json", {})
-      theme.default_locale_json = JsonFile.new("locales/#{theme.default_locale}.default.json", theme.storage)
+    def replace_inner_json(node, json, **pretty_json_opts)
+      replace_inner_markup(node, pretty_json(json, **pretty_json_opts))
     end
 
-    def remove_file(theme, relative_path)
-      theme.storage.remove(relative_path)
+    def wrap(node, insert_before, insert_after)
+      @theme_file.rewriter.wrap(node, insert_before, insert_after)
     end
 
-    def mkdir(theme, relative_path)
-      theme.storage.mkdir(relative_path)
+    def create_file(storage, relative_path, content)
+      storage.write(relative_path, content)
     end
 
-    def add_default_translation_key(file, key, value)
-      hash = file.content
-      add_key(hash, key, value)
-      file.update_contents(hash)
+    def remove_file(storage, relative_path)
+      storage.remove(relative_path)
     end
 
-    def remove_key(hash, key)
-      key.reduce(hash) do |pointer, token|
-        return pointer.delete(token) if token == key.last
-        pointer[token]
-      end
+    def mkdir(storage, relative_path)
+      storage.mkdir(relative_path)
     end
 
-    def add_key(hash, key, value)
-      key.reduce(hash) do |pointer, token|
-        return pointer[token] = value if token == key.last
-        pointer[token] = {} unless pointer.key?(token)
-        pointer[token]
-      end
+    def add_translation(json_file, path, value)
+      hash = json_file.content
+      SchemaHelper.set(hash, path, value)
+      json_file.update_contents(hash)
     end
 
-    def schema_corrector(schema, key, value)
-      return unless schema.is_a?(Hash)
-      key.reduce(schema) do |pointer, token|
-        case pointer
-        when Array
-          pointer.each do |item|
-            schema_corrector(item, key.drop(1), value)
-          end
-
-        when Hash
-          return pointer[token] = value if token == key.last
-          pointer[token] = {} unless pointer.key?(token) || pointer.key?("id")
-          pointer[token].nil? && pointer["id"] == token ? pointer : pointer[token]
-        end
-      end
+    def remove_translation(json_file, path)
+      hash = json_file.content
+      SchemaHelper.delete(hash, path)
+      json_file.update_contents(hash)
     end
   end
 end

data/lib/theme_check/file_system_storage.rb

@@ -36,13 +36,14 @@ module ThemeCheck
     end
 
     def mkdir(relative_path)
-      reset_memoizers unless file_exists?(relative_path)
-
-      file(relative_path).mkpath unless file(relative_path).directory?
+      return if file_exists?(relative_path)
+      reset_memoizers
+      file(relative_path).mkpath
     end
 
     def files
       @file_array ||= glob("**/*")
+        .reject { |path| File.directory?(path) }
         .map { |path| path.relative_path_from(@root).to_s }
     end