theme-check 0.1.0

data/lib/theme_check/offense.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+module ThemeCheck
+  class Offense
+    MAX_SOURCE_EXCERPT_SIZE = 120
+
+    attr_reader :check, :message, :template, :node, :markup, :line_number
+
+    def initialize(check:, message: nil, template: nil, node: nil, markup: nil, line_number: nil)
+      @check = check
+
+      if message
+        @message = message
+      elsif defined?(check.class::MESSAGE)
+        @message = check.class::MESSAGE
+      else
+        raise ArgumentError, "message required"
+      end
+
+      @node = node
+      if node
+        @template = node.template
+      elsif template
+        @template = template
+      end
+
+      @markup = if markup
+        markup
+      else
+        node&.markup
+      end
+
+      @line_number = if line_number
+        line_number
+      elsif @node
+        @node.line_number
+      end
+    end
+
+    def source_excerpt
+      return unless line_number
+      @source_excerpt ||= begin
+        excerpt = template.excerpt(line_number)
+        if excerpt.size > MAX_SOURCE_EXCERPT_SIZE
+          excerpt[0, MAX_SOURCE_EXCERPT_SIZE - 3] + '...'
+        else
+          excerpt
+        end
+      end
+    end
+
+    def start_line
+      return 0 unless line_number
+      line_number - 1
+    end
+
+    def end_line
+      return 0 unless line_number
+      line_number - 1
+    end
+
+    def start_column
+      return 0 unless line_number
+      template.full_line(line_number).index(markup)
+    end
+
+    def end_column
+      return 0 unless line_number
+      template.full_line(line_number).index(markup) + markup.size
+    end
+
+    def code_name
+      check.code_name
+    end
+
+    def markup_start_in_excerpt
+      source_excerpt.index(markup) if markup
+    end
+
+    def severity
+      check.severity
+    end
+
+    def check_name
+      check.class.name.demodulize
+    end
+
+    def doc
+      check.doc
+    end
+
+    def location
+      tokens = [template&.relative_path, line_number].compact
+      tokens.join(":") if tokens.any?
+    end
+
+    def to_s
+      if template
+        "#{message} at #{location}"
+      else
+        message
+      end
+    end
+  end
+end

data/lib/theme_check/parsing_helpers.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module ThemeCheck
+  module ParsingHelpers
+    # Yield each chunk outside of "...", '...'
+    def outside_of_strings(markup)
+      scanner = StringScanner.new(markup)
+
+      while scanner.scan(/.*?("|')/)
+        yield scanner.matched[..-2]
+        # Skip to the end of the string
+        scanner.skip_until(scanner.matched[-1] == "'" ? /[^\\]'/ : /[^\\]"/)
+      end
+
+      yield scanner.rest if scanner.rest?
+    end
+  end
+end

data/lib/theme_check/printer.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module ThemeCheck
+  class Printer
+    def print(theme, offenses)
+      offenses.each do |offense|
+        print_offense(offense)
+        puts
+      end
+
+      puts "#{theme.all.size} files inspected, #{red(offenses.size.to_s + ' offenses')} detected"
+    end
+
+    def print_offense(offense)
+      location = if offense.location
+        blue(offense.location) + ": "
+      else
+        ""
+      end
+
+      puts location +
+        colorized_severity(offense.severity) + ": " +
+        yellow(offense.check_name) + ": " +
+        offense.message + "."
+      if offense.source_excerpt
+        puts "\t#{offense.source_excerpt}"
+        if offense.markup_start_in_excerpt
+          puts "\t" + (" " * offense.markup_start_in_excerpt) + ("^" * offense.markup.size)
+        end
+      end
+    end
+
+    private
+
+    def colorize(str, color_code)
+      "\e[#{color_code}m#{str}\e[0m"
+    end
+
+    def colorized_severity(severity)
+      case severity
+      when :error
+        red(severity)
+      when :suggestion
+        pink(severity)
+      when :style
+        light_blue(severity)
+      end
+    end
+
+    def red(str)
+      colorize(str, 31)
+    end
+
+    def green(str)
+      colorize(str, 32)
+    end
+
+    def yellow(str)
+      colorize(str, 33)
+    end
+
+    def blue(str)
+      colorize(str, 34)
+    end
+
+    def pink(str)
+      colorize(str, 35)
+    end
+
+    def light_blue(str)
+      colorize(str, 36)
+    end
+  end
+end

data/lib/theme_check/shopify_liquid.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+require_relative 'shopify_liquid/filter'
+require_relative 'shopify_liquid/object'

data/lib/theme_check/shopify_liquid/filter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+require 'yaml'
+
+module ThemeCheck
+  module ShopifyLiquid
+    module Filter
+      extend self
+
+      def labels
+        @labels ||= begin
+          YAML.load(File.read("#{__dir__}/../../../data/shopify_liquid/filters.yml"))
+            .values
+            .flatten
+        end
+      end
+    end
+  end
+end

data/lib/theme_check/shopify_liquid/object.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+require 'yaml'
+
+module ThemeCheck
+  module ShopifyLiquid
+    module Object
+      extend self
+
+      def labels
+        @labels ||= begin
+          YAML.load(File.read("#{__dir__}/../../../data/shopify_liquid/objects.yml"))
+        end
+      end
+    end
+  end
+end

data/lib/theme_check/tags.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+require "active_support/core_ext/string/starts_ends_with"
+
+module ThemeCheck
+  module Tags
+    # Copied tags parsing code from storefront-renderer
+
+    class Section < Liquid::Tag
+      SYNTAX = /\A\s*(?<section_name>#{Liquid::QuotedString})\s*\z/o
+
+      attr_reader :section_name
+
+      def initialize(tag_name, markup, options)
+        super
+
+        match = markup.match(SYNTAX)
+        raise(
+          Liquid::SyntaxError,
+          "Error in tag 'section' - Valid syntax: section '[type]'",
+        ) unless match
+        @section_name = match[:section_name].tr(%('"), '')
+        @section_name.chomp!(".liquid") if @section_name.ends_with?(".liquid")
+      end
+    end
+
+    class Form < Liquid::Block
+      TAG_ATTRIBUTES = /([\w\-]+)\s*:\s*(#{Liquid::QuotedFragment})/o
+      # Matches forms with arguments:
+      #  'type', object
+      #  'type', object, key: value, ...
+      #  'type', key: value, ...
+      #
+      # old format: form product
+      # new format: form "product", product, id: "newID", class: "custom-class", data-example: "100"
+      FORM_FORMAT = %r{
+        (?<type>#{Liquid::QuotedFragment})
+        (?:\s*,\s*(?<variable_name>#{Liquid::VariableSignature}+)(?!:))?
+        (?<attributes>(?:\s*,\s*(?:#{TAG_ATTRIBUTES}))*)\s*\Z
+      }xo
+
+      attr_reader :type_expr, :variable_name_expr, :tag_attributes
+
+      def initialize(tag_name, markup, options)
+        super
+        @match = FORM_FORMAT.match(markup)
+        raise Liquid::SyntaxError, "in 'form' - Valid syntax: form 'type'[, object]" unless @match
+        @type_expr = parse_expression(@match[:type])
+        @variable_name_expr = parse_expression(@match[:variable_name])
+        tag_attributes = @match[:attributes].scan(TAG_ATTRIBUTES)
+        tag_attributes.each do |kv_pair|
+          kv_pair[1] = parse_expression(kv_pair[1])
+        end
+        @tag_attributes = tag_attributes
+      end
+
+      class ParseTreeVisitor < Liquid::ParseTreeVisitor
+        def children
+          super + [@node.type_expr, @node.variable_name_expr] + @node.tag_attributes
+        end
+      end
+    end
+
+    class Paginate < Liquid::Block
+      SYNTAX = /(?<liquid_variable_name>#{Liquid::QuotedFragment})\s*((?<by>by)\s*(?<page_size>#{Liquid::QuotedFragment}))?/
+
+      attr_reader :page_size
+
+      def initialize(tag_name, markup, options)
+        super
+
+        if (matches = markup.match(SYNTAX))
+          @liquid_variable_name = matches[:liquid_variable_name]
+          @page_size = parse_expression(matches[:page_size])
+          @window_size = nil # determines how many pagination links are shown
+
+          @liquid_variable_count_expr = parse_expression("#{@liquid_variable_name}_count")
+
+          var_parts = @liquid_variable_name.rpartition('.')
+          @source_drop_expr = parse_expression(var_parts[0].empty? ? var_parts.last : var_parts.first)
+          @method_name = var_parts.last.to_sym
+
+          markup.scan(Liquid::TagAttributes) do |key, value|
+            case key
+            when 'window_size'
+              @window_size = value.to_i
+            end
+          end
+        else
+          raise(Liquid::SyntaxError, "in tag 'paginate' - Valid syntax: paginate [collection] by number")
+        end
+      end
+
+      class ParseTreeVisitor < Liquid::ParseTreeVisitor
+        def children
+          super + [@node.page_size]
+        end
+      end
+    end
+
+    class Layout < Liquid::Tag
+      SYNTAX = /(?<layout>#{Liquid::QuotedFragment})/
+
+      NO_LAYOUT_KEYS = %w(false nil none).freeze
+
+      attr_reader :layout_expr
+
+      def initialize(tag_name, markup, tokens)
+        super
+        match = markup.match(SYNTAX)
+        raise(
+          Liquid::SyntaxError,
+          "in 'layout' - Valid syntax: layout (none|[layout_name])",
+        ) unless match
+        layout_markup = match[:layout]
+        @layout_expr = if NO_LAYOUT_KEYS.include?(layout_markup.downcase)
+          false
+        else
+          parse_expression(layout_markup)
+        end
+      end
+
+      class ParseTreeVisitor < Liquid::ParseTreeVisitor
+        def children
+          [@node.layout_expr]
+        end
+      end
+    end
+
+    class Style < Liquid::Block; end
+
+    class Schema < Liquid::Raw; end
+
+    class Javascript < Liquid::Raw; end
+
+    class Stylesheet < Liquid::Raw; end
+
+    Liquid::Template.register_tag('form', Form)
+    Liquid::Template.register_tag('layout', Layout)
+    Liquid::Template.register_tag('paginate', Paginate)
+    Liquid::Template.register_tag('section', Section)
+    Liquid::Template.register_tag('style', Style)
+    Liquid::Template.register_tag('schema', Schema)
+    Liquid::Template.register_tag('javascript', Javascript)
+    Liquid::Template.register_tag('stylesheet', Stylesheet)
+  end
+end

data/lib/theme_check/template.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+require "pathname"
+
+module ThemeCheck
+  class Template
+    attr_reader :path
+
+    def initialize(path, root)
+      @path = Pathname(path)
+      @root = Pathname(root)
+    end
+
+    def relative_path
+      @path.relative_path_from(@root)
+    end
+
+    def name
+      relative_path.sub_ext('').to_s
+    end
+
+    def template?
+      name.start_with?('templates')
+    end
+
+    def section?
+      name.start_with?('sections')
+    end
+
+    def snippet?
+      name.start_with?('snippets')
+    end
+
+    def source
+      @source ||= @path.read
+    end
+
+    def lines
+      @lines ||= source.split("\n")
+    end
+
+    def excerpt(line)
+      lines[line - 1].strip
+    end
+
+    def full_line(line)
+      lines[line - 1]
+    end
+
+    def parse
+      @ast ||= self.class.parse(source)
+    end
+
+    def warnings
+      @ast.warnings
+    end
+
+    def root
+      parse.root
+    end
+
+    def ==(other)
+      other.is_a?(Template) && @path == other.path
+    end
+
+    def self.parse(source)
+      Liquid::Template.parse(
+        source,
+        line_numbers: true,
+        error_mode: :warn,
+      )
+    end
+  end
+end