theme-check 1.8.0 → 1.9.0

data/lib/theme_check/liquid_node.rb

@@ -45,11 +45,47 @@ module ThemeCheck
     def markup
       if tag?
         tag_markup
+      elsif literal?
+        value.to_s
       elsif @value.instance_variable_defined?(:@markup)
         @value.instance_variable_get(:@markup)
       end
     end
 
+    # The original source code of the node. Does contain wrapping braces.
+    def outer_markup
+      if literal?
+        markup
+      elsif variable_lookup?
+        ''
+      elsif variable?
+        start_token + markup + end_token
+      elsif tag? && block?
+        start_index = block_start_start_index
+        end_index = block_start_end_index
+        end_index += inner_markup.size
+        end_index = find_block_delimiter(end_index)&.end(0)
+        source[start_index...end_index]
+      elsif tag?
+        source[block_start_start_index...block_start_end_index]
+      else
+        inner_markup
+      end
+    end
+
+    def inner_markup
+      return '' unless block?
+      @inner_markup ||= source[block_start_end_index...block_end_start_index]
+    end
+
+    def inner_json
+      return nil unless schema?
+      @inner_json ||= JSON.parse(inner_markup)
+    rescue JSON::ParserError
+      # Handled by ValidSchema
+      @inner_json = nil
+    end
+
     def markup=(markup)
       if @value.instance_variable_defined?(:@markup)
         @value.instance_variable_set(:@markup, markup)
@@ -70,36 +106,24 @@ module ThemeCheck
       position.start_index
     end
 
-    def end_index
-      position.end_index
-    end
-
-    def start_token_index
-      return position.start_index if inside_liquid_tag?
-      position.start_index - (start_token.length + 1)
+    def start_row
+      position.start_row
     end
 
-    def end_token_index
-      return position.end_index if inside_liquid_tag?
-      position.end_index + end_token.length
+    def start_column
+      position.start_column
     end
 
-    def render_start_tag
-      "#{start_token} #{@value.raw}#{end_token}"
-    end
-
-    def render_end_tag
-      "#{start_token} #{@value.block_delimiter} #{end_token}"
+    def end_index
+      position.end_index
     end
 
-    def block_body_start_index
-      return unless block_tag?
-      block_regex.begin(:body)
+    def end_row
+      position.end_row
     end
 
-    def block_body_end_index
-      return unless block_tag?
-      block_regex.end(:body)
+    def end_column
+      position.end_column
     end
 
     # Literals are hard-coded values in the liquid file.
@@ -116,6 +140,14 @@ module ThemeCheck
       @value.is_a?(Liquid::Variable)
     end
 
+    def assigned_or_echoed_variable?
+      variable? && start_token == ""
+    end
+
+    def variable_lookup?
+      @value.is_a?(Liquid::VariableLookup)
+    end
+
     # A {% comment %} block node?
     def comment?
       @value.is_a?(Liquid::Comment)
@@ -142,6 +174,10 @@ module ThemeCheck
       block_tag? || block_body? || document?
     end
 
+    def schema?
+      @value.is_a?(ThemeCheck::Tags::Schema)
+    end
+
     # The `:under_score_name` of this type of node. Used to dispatch to the `on_<type_name>`
     # and `after_<type_name>` check methods.
     def type_name
@@ -152,6 +188,86 @@ module ThemeCheck
       theme_file&.source
     end
 
+    def block_start_markup
+      source[block_start_start_index...block_start_end_index]
+    end
+
+    def block_start_start_index
+      @block_start_start_index ||= if inside_liquid_tag?
+        backtrack_on_whitespace(source, start_index, /[ \t]/)
+      elsif tag?
+        backtrack_on_whitespace(source, start_index) - start_token.length
+      else
+        position.start_index - start_token.length
+      end
+    end
+
+    def block_start_end_index
+      @block_start_end_index ||= position.end_index + end_token.size
+    end
+
+    def block_end_markup
+      source[block_end_start_index...block_end_end_index]
+    end
+
+    def block_end_start_index
+      return block_start_end_index unless tag? && block?
+      @block_end_start_index ||= block_end_match&.begin(0) || block_start_end_index
+    end
+
+    def block_end_end_index
+      return block_end_start_index unless tag? && block?
+      @block_end_end_index ||= block_end_match&.end(0) || block_start_end_index
+    end
+
+    def outer_markup_start_index
+      outer_markup_position.start_index
+    end
+
+    def outer_markup_end_index
+      outer_markup_position.end_index
+    end
+
+    def outer_markup_start_row
+      outer_markup_position.start_row
+    end
+
+    def outer_markup_start_column
+      outer_markup_position.start_column
+    end
+
+    def outer_markup_end_row
+      outer_markup_position.end_row
+    end
+
+    def outer_markup_end_column
+      outer_markup_position.end_column
+    end
+
+    def inner_markup_start_index
+      inner_markup_position.start_index
+    end
+
+    def inner_markup_end_index
+      inner_markup_position.end_index
+    end
+
+    def inner_markup_start_row
+      inner_markup_position.start_row
+    end
+
+    def inner_markup_start_column
+      inner_markup_position.start_column
+    end
+
+    def inner_markup_end_row
+      inner_markup_position.end_row
+    end
+
+    def inner_markup_end_column
+      inner_markup_position.end_column
+    end
+
     WHITESPACE = /\s/
 
     # Is this node inside a `{% liquid ... %}` block?
@@ -193,30 +309,41 @@ module ThemeCheck
     end
 
     def start_token
-      return "" if inside_liquid_tag?
-      output = ""
-      output += "{{" if variable?
-      output += "{%" if tag?
-      output += "-" if whitespace_trimmed_start?
-      output
+      if inside_liquid_tag?
+        ""
+      elsif variable? && source[start_index - 3..start_index - 1] == "{{-"
+        "{{-"
+      elsif variable? && source[start_index - 2..start_index - 1] == "{{"
+        "{{"
+      elsif tag? && whitespace_trimmed_start?
+        "{%-"
+      elsif tag?
+        "{%"
+      else
+        ""
+      end
     end
 
     def end_token
-      return "" if inside_liquid_tag?
-      output = ""
-      output += "-" if whitespace_trimmed_end?
-      output += "}}" if variable?
-      output += "%}" if tag?
-      output
+      if inside_liquid_tag? && source[end_index] == "\n"
+        "\n"
+      elsif inside_liquid_tag?
+        ""
+      elsif variable? && source[end_index...end_index + 3] == "-}}"
+        "-}}"
+      elsif variable? && source[end_index...end_index + 2] == "}}"
+        "}}"
+      elsif tag? && whitespace_trimmed_end?
+        "-%}"
+      elsif tag?
+        "%}"
+      else # this could happen because we're in an assign statement (variable)
+        ""
+      end
     end
 
     private
 
-    def block_regex
-      return unless block_tag?
-      /(?<start_token>#{render_start_tag})(?<body>.*)(?<end_token>#{render_end_tag})/m.match(source)
-    end
-
     def position
       @position ||= Position.new(
         markup,
@@ -225,6 +352,22 @@ module ThemeCheck
       )
     end
 
+    def outer_markup_position
+      @outer_markup_position ||= StrictPosition.new(
+        outer_markup,
+        source,
+        block_start_start_index,
+      )
+    end
+
+    def inner_markup_position
+      @inner_markup_position ||= StrictPosition.new(
+        inner_markup,
+        source,
+        block_start_end_index,
+      )
+    end
+
     # Here we're hacking around a glorious bug in Liquid that makes it so the
     # line_number and markup of a tag is wrong if there's whitespace
     # between the tag_name and the markup of the tag.
@@ -320,5 +463,72 @@ module ThemeCheck
       # return the real raw content
       @tag_markup = source[tag_start...markup_end]
     end
+
+    # Returns the index of the leftmost consecutive whitespace
+    # starting from start going backwards.
+    #
+    # e.g. backtrack_on_whitespace("01  45", 4) would return 2.
+    # e.g. backtrack_on_whitespace("{%   render %}", 5) would return 2.
+    def backtrack_on_whitespace(string, start, whitespace = WHITESPACE)
+      i = start
+      i -= 1 while string[i - 1] =~ whitespace && i > 0
+      i
+    end
+
+    def find_block_delimiter(start_index)
+      return nil unless tag? && block?
+
+      tag_start, tag_end = if inside_liquid_tag?
+        [
+          /^\s*#{@value.tag_name}\s*/,
+          /^\s*end#{@value.tag_name}\s*/,
+        ]
+      else
+        [
+          /#{Liquid::TagStart}-?\s*#{@value.tag_name}/mi,
+          /#{Liquid::TagStart}-?\s*end#{@value.tag_name}\s*-?#{Liquid::TagEnd}/mi,
+        ]
+      end
+
+      # This little algorithm below find the _correct_ block delimiter
+      # (endif, endcase, endcomment) for the current tag. What do I
+      # mean by correct? It means the one you'd expect. Making sure
+      # that we don't do the naive regex find. Since you can have
+      # nested ifs, fors, etc.
+      #
+      # It works by having a stack, pushing onto the stack when we
+      # open a tag of our type_name. And popping when we find a
+      # closing tag of our type_name.
+      #
+      # When the stack is empty, we return the end tag match.
+      index = start_index
+      stack = []
+      stack.push("open")
+      loop do
+        tag_start_match = tag_start.match(source, index)
+        tag_end_match = tag_end.match(source, index)
+
+        return nil unless tag_end_match
+
+        # We have found a tag_start and it appeared _before_ the
+        # tag_end that we found, thus we push it onto the stack.
+        if tag_start_match && tag_start_match.end(0) < tag_end_match.end(0)
+          stack.push("open")
+        end
+
+        # We have found a tag_end, therefore we pop
+        stack.pop
+
+        # Nothing left on the stack, we're done.
+        break tag_end_match if stack.empty?
+
+        # We keep looking from the end of the end tag we just found.
+        index = tag_end_match.end(0)
+      end
+    end
+
+    def block_end_match
+      @block_end_match ||= find_block_delimiter(block_start_end_index)
+    end
   end
 end

data/lib/theme_check/locale_diff.rb

@@ -33,9 +33,15 @@ module ThemeCheck
       if node
         check.add_offense(message, node: node) do |corrector|
           extra_keys.each do |k|
-            corrector.remove_key(schema, key_prefix + k)
+            SchemaHelper.delete(schema, key_prefix + k)
+          end
+          corrector.replace_inner_json(node, schema)
+        end
+      elsif theme_file.is_a?(JsonFile)
+        check.add_offense(message, theme_file: theme_file) do |corrector|
+          extra_keys.each do |k|
+            corrector.remove_translation(theme_file, key_prefix + k)
           end
-          corrector.replace_block_body(node, schema)
         end
       else
         check.add_offense(message, theme_file: theme_file)
@@ -47,9 +53,15 @@ module ThemeCheck
       if node
         check.add_offense(message, node: node) do |corrector|
           missing_keys.each do |k|
-            corrector.add_key(schema, key_prefix + k, "TODO")
+            SchemaHelper.set(schema, key_prefix + k, "TODO")
+          end
+          corrector.replace_inner_json(node, schema)
+        end
+      elsif theme_file.is_a?(JsonFile)
+        check.add_offense(message, theme_file: theme_file) do |corrector|
+          missing_keys.each do |k|
+            corrector.add_translation(theme_file, key_prefix + k, "TODO")
           end
-          corrector.replace_block_body(node, schema)
         end
       else
         check.add_offense(message, theme_file: theme_file)

data/lib/theme_check/node.rb

@@ -30,8 +30,24 @@ module ThemeCheck
       raise NotImplementedError
     end
 
+    def start_row
+      raise NotImplementedError
+    end
+
+    def start_column
+      raise NotImplementedError
+    end
+
     def end_index
       raise NotImplementedError
     end
+
+    def end_row
+      raise NotImplementedError
+    end
+
+    def end_column
+      raise NotImplementedError
+    end
   end
 end

data/lib/theme_check/offense.rb

@@ -39,26 +39,12 @@ module ThemeCheck
       end
 
       @node = node
-      @theme_file = nil
-      if node
-        @theme_file = node.theme_file
-      elsif theme_file
-        @theme_file = theme_file
-      end
-
-      @markup = if markup
-        markup
-      else
-        node&.markup
-      end
+      @theme_file = node&.theme_file || theme_file
+      @markup = markup || node&.markup
 
       raise ArgumentError, "Offense markup cannot be an empty string" if @markup.is_a?(String) && @markup.empty?
 
-      @line_number = if line_number
-        line_number
-      elsif @node
-        @node.line_number
-      end
+      @line_number = line_number || @node&.line_number
 
       @position = Position.new(
         @markup,
@@ -81,11 +67,25 @@ module ThemeCheck
       end
     end
 
+    def in_range?(other_range)
+      # Zero length ranges are OK and considered the same as size 1 ranges
+      other_range = other_range.first..other_range.end if other_range.size == 0 # rubocop:disable Style/ZeroLengthPredicate
+      range.cover?(other_range) || other_range.cover?(range)
+    end
+
+    def range
+      @range ||= if start_index == end_index
+        (start_index..end_index)
+      else
+        (start_index...end_index) # end_index is excluded
+      end
+    end
+
     def start_index
       @position.start_index
     end
 
-    def start_line
+    def start_row
       @position.start_row
     end
 
@@ -97,7 +97,7 @@ module ThemeCheck
       @position.end_index
     end
 
-    def end_line
+    def end_row
       @position.end_row
     end
 
@@ -121,6 +121,10 @@ module ThemeCheck
       StringHelpers.demodulize(check.class.name)
     end
 
+    def version
+      theme_file&.version
+    end
+
     def doc
       check.doc
     end
@@ -139,9 +143,9 @@ module ThemeCheck
       !!correction
     end
 
-    def correct
+    def correct(corrector = nil)
       if correctable?
-        corrector = Corrector.new(theme_file: theme_file)
+        corrector ||= Corrector.new(theme_file: theme_file)
         correction.call(corrector)
       end
     rescue => e
@@ -211,9 +215,9 @@ module ThemeCheck
         check: check.code_name,
         path: theme_file&.relative_path,
         severity: check.severity_value,
-        start_line: start_line,
+        start_row: start_row,
         start_column: start_column,
-        end_line: end_line,
+        end_row: end_row,
         end_column: end_column,
         message: message,
       }

data/lib/theme_check/regex_helpers.rb

@@ -5,7 +5,7 @@ module ThemeCheck
     LIQUID_TAG = /#{Liquid::TagStart}.*?#{Liquid::TagEnd}/om
     LIQUID_VARIABLE = /#{Liquid::VariableStart}.*?#{Liquid::VariableEnd}/om
     LIQUID_TAG_OR_VARIABLE = /#{LIQUID_TAG}|#{LIQUID_VARIABLE}/om
-    HTML_LIQUID_PLACEHOLDER = /≬[0-9a-z]+#*≬/m
+    HTML_LIQUID_PLACEHOLDER = /≬[0-9a-z\n]+[#\n]*≬/m
     START_OR_END_QUOTE = /(^['"])|(['"]$)/
 
     def matches(s, re)

data/lib/theme_check/schema_helper.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  class SchemaHelper
+    # Deeply sets a value in a hash. Accepts both arrays and strings for path.
+    def self.set(hash, path, value)
+      path = path.split('.') if path.is_a?(String)
+      path.each_with_index.reduce(hash) do |pointer, (token, index)|
+        if index == path.size - 1
+          pointer[token] = value
+        elsif !pointer.key?(token)
+          pointer[token] = {}
+        end
+        pointer[token]
+      end
+      hash
+    end
+
+    # Deeply delete a key from a hash
+    def self.delete(hash, path)
+      path = path.split('.') if path.is_a?(String)
+      path.each_with_index.reduce(hash) do |pointer, (token, index)|
+        break pointer.delete(token) if index == path.size - 1
+        pointer[token]
+      end
+    end
+
+    # Deeply add key/values inside a hash.
+    #
+    # Handles arrays by adding the key/value to all hashes inside the array.
+    #
+    # Specially handles objects that have the "id" key like this:
+    #
+    # e.g.
+    #
+    # schema = {
+    #   "deep" => [
+    #     { "id" => "hi" },
+    #     { "id" => "oh" },
+    #   ],
+    # }
+    # assert_equal(
+    #   {
+    #     "deep" => [
+    #       { "id" => "hi", "ho" => "ho" },
+    #       { "id" => "oh" },
+    #     ],
+    #   },
+    #   SchemaHelper.schema_corrector(schema, "deep.hi.ho", "ho")
+    # )
+    def self.schema_corrector(schema, path, value)
+      return schema unless schema.is_a?(Hash)
+      path = path.split('.') if path.is_a?(String)
+      path.each_with_index.reduce(schema) do |pointer, (token, index)|
+        case pointer
+        when Array
+          pointer.each do |item|
+            schema_corrector(item, path.drop(1), value)
+          end
+
+        when Hash
+          break pointer[token] = value if index == path.size - 1
+          pointer[token] = {} unless pointer.key?(token) || pointer.key?("id")
+          pointer[token].nil? && pointer["id"] == token ? pointer : pointer[token]
+        end
+      end
+      schema
+    end
+  end
+end

data/lib/theme_check/storage.rb

@@ -21,5 +21,9 @@ module ThemeCheck
     def directories
       raise NotImplementedError
     end
+
+    def versioned?
+      false
+    end
   end
 end

data/lib/theme_check/theme.rb

@@ -3,7 +3,7 @@ require "pathname"
 
 module ThemeCheck
   class Theme
-    DEFAULT_LOCALE_REGEXP = %r{^locales/(.*)\.default$}
+    DEFAULT_LOCALE_REGEXP = %r{locales/(.*)\.default$}
     LIQUID_REGEX = /\.liquid$/i
     JSON_REGEX = /\.json$/i
 

data/lib/theme_check/theme_file.rb

@@ -3,10 +3,13 @@ require "pathname"
 
 module ThemeCheck
   class ThemeFile
+    attr_reader :version, :storage
+
     def initialize(relative_path, storage)
       @relative_path = relative_path
       @storage = storage
       @source = nil
+      @version = nil
       @eol = "\n"
     end
 
@@ -36,7 +39,11 @@ module ThemeCheck
     # source file.
     def source
       return @source if @source
-      @source = @storage.read(@relative_path)
+      if @storage.versioned?
+        @source, @version = @storage.read_version(@relative_path)
+      else
+        @source = @storage.read(@relative_path)
+      end
       @eol = @source.include?("\r\n") ? "\r\n" : "\n"
       @source = @source.gsub("\r\n", "\n")
     end

data/lib/theme_check/theme_file_rewriter.rb

@@ -11,36 +11,45 @@ module ThemeCheck
       )
     end
 
-    def insert_before(node, content)
+    def insert_before(node, content, character_range = nil)
       @rewriter.insert_before(
-        range(node.start_index, node.end_index),
+        range(
+          character_range&.begin || node.start_index,
+          character_range&.end || node.end_index,
+        ),
         content
       )
     end
 
-    def insert_after(node, content)
+    def insert_after(node, content, character_range = nil)
       @rewriter.insert_after(
-        range(node.start_index, node.end_index),
+        range(
+          character_range&.begin || node.start_index,
+          character_range&.end || node.end_index,
+        ),
         content
       )
     end
 
     def remove(node)
       @rewriter.remove(
-        range(node.start_token_index, node.end_token_index)
+        range(node.outer_markup_start_index, node.outer_markup_end_index)
       )
     end
 
-    def replace(node, content)
+    def replace(node, content, character_range = nil)
       @rewriter.replace(
-        range(node.start_index, node.end_index),
+        range(
+          character_range&.begin || node.start_index,
+          character_range&.end || node.end_index,
+        ),
         content
       )
     end
 
-    def replace_body(node, content)
+    def replace_inner_markup(node, content)
       @rewriter.replace(
-        range(node.block_body_start_index, node.block_body_end_index),
+        range(node.inner_markup_start_index, node.inner_markup_end_index),
         content
       )
     end