platformos-check 0.0.1

data/lib/platformos_check/app_file_rewriter.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'parser'
+
+module PlatformosCheck
+  class AppFileRewriter
+    def initialize(name, source)
+      @buffer = Parser::Source::Buffer.new(name, source:)
+      @rewriter = Parser::Source::TreeRewriter.new(
+        @buffer
+      )
+    end
+
+    def insert_before(node, content, character_range = nil)
+      @rewriter.insert_before(
+        range(
+          character_range&.begin || node.start_index,
+          character_range&.end || node.end_index
+        ),
+        content
+      )
+    end
+
+    def insert_after(node, content, character_range = nil)
+      @rewriter.insert_after(
+        range(
+          character_range&.begin || node.start_index,
+          character_range&.end || node.end_index
+        ),
+        content
+      )
+    end
+
+    def remove(node)
+      @rewriter.remove(
+        range(node.outer_markup_start_index, node.outer_markup_end_index)
+      )
+    end
+
+    def replace(node, content, character_range = nil)
+      @rewriter.replace(
+        range(
+          character_range&.begin || node.start_index,
+          character_range&.end || node.end_index
+        ),
+        content
+      )
+    end
+
+    def replace_inner_markup(node, content)
+      @rewriter.replace(
+        range(node.inner_markup_start_index, node.inner_markup_end_index),
+        content
+      )
+    end
+
+    def wrap(node, insert_before, insert_after)
+      @rewriter.wrap(
+        range(node.start_index, node.end_index),
+        insert_before,
+        insert_after
+      )
+    end
+
+    def to_s
+      @rewriter.process
+    end
+
+    private
+
+    def range(start_index, end_index)
+      Parser::Source::Range.new(
+        @buffer,
+        start_index,
+        end_index
+      )
+    end
+  end
+end

data/lib/platformos_check/asset_file.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module PlatformosCheck
+  class AssetFile < AppFile
+    def initialize(relative_path, storage)
+      super
+      @loaded = false
+      @content = nil
+    end
+
+    def rewriter
+      @rewriter ||= AppFileRewriter.new(@relative_path, source)
+    end
+
+    def write
+      content = rewriter.to_s
+      return unless source != content
+
+      @storage.write(@relative_path, content.gsub("\n", @eol))
+      @source = content
+      @rewriter = nil
+    end
+
+    def gzipped_size
+      @gzipped_size ||= Zlib.gzip(source).bytesize
+    end
+
+    def name
+      relative_path.to_s
+    end
+  end
+end

data/lib/platformos_check/bug.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'platformos_check/version'
+
+module PlatformosCheck
+  class PlatformosCheckError < StandardError; end
+
+  BUG_POSTAMBLE = <<~EOS
+    PlatformOS Check Version: #{VERSION}
+    Ruby Version: #{RUBY_VERSION}
+    Platform: #{RUBY_PLATFORM}
+    Muffin mode: activated
+
+    ------------------------
+    Whoops! It looks like you found a bug in PlatformOS Check.
+    Please report it at https://github.com/Platform-OS/platformos-lsp/issues, and include the message above.
+    Or cross your fingers real hard, and try again.
+  EOS
+
+  def self.bug(message)
+    raise PlatformosCheckError, message + BUG_POSTAMBLE
+  end
+end

data/lib/platformos_check/check.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require_relative "json_helpers"
+
+module PlatformosCheck
+  class Check
+    include JsonHelpers
+
+    attr_accessor :platformos_app, :options
+    attr_writer :ignored_patterns, :offenses
+
+    # The order matters.
+    SEVERITIES = %i[
+      error
+      suggestion
+      style
+    ]
+
+    # [severity: sym] => number
+    SEVERITY_VALUES = SEVERITIES
+                      .map
+                      .with_index { |sev, i| [sev, i] }
+                      .to_h
+
+    CATEGORIES = %i[
+      liquid
+      translation
+      html
+      yaml
+      performance
+      graphql
+    ]
+
+    class << self
+      def all
+        @all ||= []
+      end
+
+      def severity(severity = nil)
+        if severity
+          raise ArgumentError, "unknown severity. Use: #{SEVERITIES.join(', ')}" unless SEVERITIES.include?(severity)
+
+          @severity = severity
+        end
+        @severity if defined?(@severity)
+      end
+
+      def severity_value(severity)
+        SEVERITY_VALUES[severity] || -1
+      end
+
+      def categories(*categories)
+        @categories ||= []
+        if categories.any?
+          unknown_categories = categories.select { |category| !CATEGORIES.include?(category) }
+          if unknown_categories.any?
+            raise ArgumentError,
+                  "unknown categories: #{unknown_categories.join(', ')}. Use: #{CATEGORIES.join(', ')}"
+          end
+          @categories = categories
+        end
+        @categories
+      end
+      alias category categories
+
+      def doc(doc = nil)
+        @doc = doc if doc
+        @doc if defined?(@doc)
+      end
+
+      def docs_url(path)
+        "https://github.com/Platform-OS/platformos-lsp/blob/master/docs/checks/#{File.basename(path, '.rb')}.md"
+      end
+
+      def can_disable(disableable = nil)
+        @can_disable = disableable unless disableable.nil?
+        defined?(@can_disable) ? @can_disable : true
+      end
+
+      def single_file(single_file = nil)
+        @single_file = single_file unless single_file.nil?
+        defined?(@single_file) ? @single_file : !method_defined?(:on_end)
+      end
+    end
+
+    def offenses
+      @offenses ||= []
+    end
+
+    def add_offense(message, node: nil, app_file: node&.app_file, markup: nil, line_number: nil, node_markup_offset: 0, &block)
+      offenses << Offense.new(check: self, message:, app_file:, node:, markup:, line_number:, node_markup_offset:, correction: block)
+    end
+
+    def severity
+      @severity ||= self.class.severity
+    end
+
+    def severity=(severity)
+      raise ArgumentError, "unknown severity. Use: #{SEVERITIES.join(', ')}" unless SEVERITIES.include?(severity)
+
+      @severity = severity
+    end
+
+    def severity_value
+      SEVERITY_VALUES[severity]
+    end
+
+    def categories
+      self.class.categories
+    end
+
+    def doc
+      self.class.doc
+    end
+
+    def code_name
+      StringHelpers.demodulize(self.class.name)
+    end
+
+    def ignore!
+      @ignored = true
+    end
+
+    def ignored?
+      defined?(@ignored) && @ignored
+    end
+
+    def ignored_patterns
+      @ignored_patterns ||= []
+    end
+
+    def can_disable?
+      self.class.can_disable
+    end
+
+    def single_file?
+      self.class.single_file
+    end
+
+    def whole_platformos_app?
+      !single_file?
+    end
+
+    def ==(other)
+      other.is_a?(Check) && code_name == other.code_name
+    end
+    alias eql? ==
+
+    def to_s
+      s = +"#{code_name}:\n"
+      properties = {
+        severity:,
+        categories:,
+        doc:,
+        ignored_patterns:
+      }.merge(options)
+      properties.each_pair do |name, value|
+        s << "  #{name}: #{value}\n" if value
+      end
+      s
+    end
+  end
+end

data/lib/platformos_check/checks/TEMPLATE.rb.erb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module PlatformosCheck
+  # TODO: inherit from HtmlCheck or YamlCheck if working on a non-Liquid check
+  class <%= class_name %> < LiquidCheck
+    severity :suggestion
+    category :liquid
+    doc docs_url(__FILE__)
+
+    # TODO: def on_<NODE_TYPE>
+  end
+end

data/lib/platformos_check/checks/convert_include_to_render.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  # Recommends replacing `include` for `render`
+  class ConvertIncludeToRender < LiquidCheck
+    severity :suggestion
+    category :liquid
+    doc docs_url(__FILE__)
+
+    def on_include(node)
+      add_offense("`include` is deprecated - convert it to `render`", node:) do |corrector|
+        # We need to fix #445 and pass the variables from the context or don't replace at all.
+        # corrector.replace(node, "render \'#{node.value.template_name_expr}\' ")
+      end
+    end
+  end
+end

data/lib/platformos_check/checks/deprecated_filter.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class DeprecatedFilter < LiquidCheck
+    doc docs_url(__FILE__)
+    category :liquid
+    severity :suggestion
+
+    # The image_url filter does not accept width or height values
+    # greater than this numbr.
+    MAX_SIZE = 5760
+    SIZE_REGEX = /^\d*x\d*$/
+    NAMED_SIZES = {
+      "pico" => 16,
+      "icon" => 32,
+      "thumb" => 50,
+      "small" => 100,
+      "compact" => 160,
+      "medium" => 240,
+      "large" => 480,
+      "grande" => 600,
+      "original" => 1024,
+      "master" => nil
+    }
+
+    def on_variable(node)
+      used_filters = node.filters.map { |name, *_rest| name }
+      used_filters.each do |filter|
+        alternatives = PlatformosLiquid::DeprecatedFilter.alternatives(filter)
+        next unless alternatives
+
+        case filter
+        when 'img_url'
+          add_img_url_offense(node)
+        else
+          add_default_offense(node, filter, alternatives)
+        end
+      end
+    end
+
+    def add_default_offense(node, filter, alternatives)
+      alternatives = alternatives.map { |alt| "`#{alt}`" }
+      add_offense(
+        "Deprecated filter `#{filter}`, consider using an alternative: #{alternatives.join(', ')}",
+        node:
+      )
+    end
+
+    def add_img_url_offense(node)
+      img_url_filter = node.filters.find { |filter| filter[0] == "img_url" }
+      _name, img_url_filter_size, img_url_filter_props = img_url_filter
+      size_spec = img_url_filter_size&.dig(0)
+      scale = img_url_filter_props&.delete("scale")
+
+      # Can't correct those.
+      return add_default_offense(node, 'img_url', ['image_url']) unless
+        (size_spec.nil? || size_spec.is_a?(String)) &&
+        (scale.nil? || scale.is_a?(Numeric))
+
+      return add_default_offense(node, 'img_url', ['image_url']) if
+        size_spec.is_a?(String) &&
+        size_spec !~ SIZE_REGEX &&
+        !NAMED_SIZES.key?(size_spec)
+
+      node_source = node.markup
+
+      node_start_index = node.start_index
+      match = node_source.match(/img_url[^|]*/)
+      img_url_character_range =
+        (node_start_index + match.begin(0))...(node_start_index + match.end(0))
+
+      scale = (scale || 1).to_i
+      width, height = if size_spec.nil?
+                        [100, 100]
+                      elsif NAMED_SIZES.key?(size_spec)
+                        [NAMED_SIZES[size_spec], NAMED_SIZES[size_spec]]
+                      else
+                        size_spec.split('x')
+                      end.map { |v| v.to_i * scale }
+
+      image_url_filter_params = [
+        width && width > 0 ? "width: #{[width, MAX_SIZE].min}" : nil,
+        height && height > 0 ? "height: #{[height, MAX_SIZE].min}" : nil
+      ]
+      image_url_filter_params += (img_url_filter_props || {})
+                                 .map do |k, v|
+        case v
+        when Liquid::VariableLookup
+          "#{k}: #{v.name}"
+        when String
+          "#{k}: '#{v}'"
+        else
+          "#{k}: #{v}"
+        end
+      end
+      image_url_filter_params = image_url_filter_params
+                                .reject(&:nil?)
+                                .join(", ")
+
+      trailing_whitespace = match[0].match(/\s*\Z/)[0]
+
+      image_url_filter = "image_url"
+      image_url_filter += ": " + image_url_filter_params unless image_url_filter_params.empty?
+      image_url_filter += trailing_whitespace
+
+      add_offense(
+        "Deprecated filter `img_url`, consider using `image_url`",
+        node:,
+        markup: match[0]
+      ) do |corrector|
+        corrector.replace(
+          node,
+          image_url_filter,
+          img_url_character_range
+        )
+      end
+
+    # If anything goes wrong, fail gracefully by returning the default offense.
+    rescue StandardError
+      add_default_offense(node, 'img_url', ['image_url'])
+    end
+  end
+end

data/lib/platformos_check/checks/html_parsing_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class HtmlParsingError < HtmlCheck
+    severity :error
+    category :html
+    doc docs_url(__FILE__)
+
+    def on_parse_error(exception, app_file)
+      add_offense("HTML in this template can not be parsed: #{exception.message}", app_file:)
+    end
+  end
+end

data/lib/platformos_check/checks/img_lazy_loading.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class ImgLazyLoading < HtmlCheck
+    severity :suggestion
+    categories :html, :performance
+    doc docs_url(__FILE__)
+
+    ACCEPTED_LOADING_VALUES = %w[lazy eager]
+
+    def on_img(node)
+      loading = node.attributes["loading"]&.downcase
+      return if ACCEPTED_LOADING_VALUES.include?(loading)
+
+      add_offense("Use loading=\"eager\" for images visible in the viewport on load and loading=\"lazy\" for others", node:)
+    end
+  end
+end

data/lib/platformos_check/checks/img_width_and_height.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  # Reports errors when trying to use parser-blocking script tags
+  class ImgWidthAndHeight < HtmlCheck
+    severity :error
+    categories :html, :performance
+    doc docs_url(__FILE__)
+
+    ENDS_IN_CSS_UNIT = /(cm|mm|in|px|pt|pc|em|ex|ch|rem|vw|vh|vmin|vmax|%)$/i
+
+    def on_img(node)
+      width = node.attributes["width"]
+      height = node.attributes["height"]
+
+      record_units_in_field_offenses("width", width, node:)
+      record_units_in_field_offenses("height", height, node:)
+
+      return if node.attributes["src"].nil? || (width && height)
+
+      missing_width = width.nil?
+      missing_height = height.nil?
+      error_message = if missing_width && missing_height
+                        "Missing width and height attributes"
+                      elsif missing_width
+                        "Missing width attribute"
+                      elsif missing_height
+                        "Missing height attribute"
+                      end
+
+      add_offense(error_message, node:)
+    end
+
+    private
+
+    def record_units_in_field_offenses(attribute, value, node:)
+      return unless ENDS_IN_CSS_UNIT.match?(value)
+
+      value_without_units = value.gsub(ENDS_IN_CSS_UNIT, '')
+      add_offense(
+        "The #{attribute} attribute does not take units. Replace with \"#{value_without_units}\"",
+        node:
+      )
+    end
+  end
+end

data/lib/platformos_check/checks/invalid_args.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class InvalidArgs < LiquidCheck
+    class ParsedGraphQL
+      def initialize(ast)
+        @ast = ast
+      end
+
+      def required_arguments
+        variables.each_with_object([]) do |v, vars|
+          vars << v.name if v.type.is_a?(GraphQL::Language::Nodes::NonNullType)
+        end
+      end
+
+      def defined_arguments
+        variables.map(&:name)
+      end
+
+      private
+
+      attr_reader :ast
+
+      def variables
+        @variables ||= definition&.variables || []
+      end
+
+      def definition
+        @definition ||= ast.definitions.detect { |d| d.is_a?(GraphQL::Language::Nodes::OperationDefinition) }
+      end
+    end
+    severity :error
+    category :liquid, :graphql
+    doc docs_url(__FILE__)
+
+    def on_render(node)
+      add_duplicated_key_offense(node)
+    end
+
+    def on_function(node)
+      add_duplicated_key_offense(node)
+    end
+
+    def on_graphql(node)
+      add_duplicated_key_offense(node)
+
+      return if node.value.inline_query
+
+      graphql_partial = node.value.partial_name
+      return unless graphql_partial.is_a?(String)
+
+      graqphql_file = platformos_app.grouped_files[GraphqlFile][graphql_partial]
+      return unless graqphql_file
+
+      provided_arguments = node.value.attributes
+
+      return if provided_arguments.include?('args')
+
+      parsed_graphql = ParsedGraphQL.new(graqphql_file.parse)
+
+      required_arguments = parsed_graphql.required_arguments
+      defined_arguments = parsed_graphql.defined_arguments
+
+      (provided_arguments - defined_arguments).each do |name|
+        add_offense("Undefined argument `#{name}` provided to `#{graqphql_file.relative_path}`", node:)
+      end
+
+      (required_arguments - provided_arguments).each do |name|
+        add_offense("Required argument `#{name}` not provided to `#{graqphql_file.relative_path}`", node:)
+      end
+    rescue GraphQL::ParseError => e
+      add_offense("GraphQL Parse error triggered by `#{graqphql_file.relative_path}`: #{e.message}", node:)
+    end
+
+    def add_duplicated_key_offense(node)
+      node.value.duplicated_attrs.each do |duplicated_arg|
+        add_offense("Duplicated argument `#{duplicated_arg}`", node:)
+      end
+    end
+  end
+end

data/lib/platformos_check/checks/liquid_tag.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  # Recommends using {% liquid ... %} if 5 or more consecutive {% ... %} are found.
+  class LiquidTag < LiquidCheck
+    severity :suggestion
+    category :liquid
+    doc docs_url(__FILE__)
+
+    def initialize(min_consecutive_statements: 5)
+      @first_statement = nil
+      @consecutive_statements = 0
+      @min_consecutive_statements = min_consecutive_statements
+    end
+
+    def on_tag(node)
+      if node.inside_liquid_tag?
+        reset_consecutive_statements
+      # Ignore comments
+      elsif !node.comment?
+        increment_consecutive_statements(node)
+      end
+    end
+
+    def on_string(node)
+      # Only reset the counter on outputted strings, and ignore empty line-breaks
+      return unless node.parent.block? && !node.value.strip.empty?
+
+      reset_consecutive_statements
+    end
+
+    def after_document(_node)
+      reset_consecutive_statements
+    end
+
+    def increment_consecutive_statements(node)
+      @first_statement ||= node
+      @consecutive_statements += 1
+    end
+
+    def reset_consecutive_statements
+      add_offense("Use {% liquid ... %} to write multiple tags", node: @first_statement) if @consecutive_statements >= @min_consecutive_statements
+      @first_statement = nil
+      @consecutive_statements = 0
+    end
+  end
+end

data/lib/platformos_check/checks/missing_enable_comment.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class MissingEnableComment < LiquidCheck
+    severity :error
+    doc docs_url(__FILE__)
+
+    # Don't allow this check to be disabled with a comment,
+    # as we need to be able to check for disabled checks.
+    can_disable false
+
+    def on_document(_node)
+      @disabled_checks = DisabledChecks.new
+    end
+
+    def on_comment(node)
+      @disabled_checks.update(node)
+    end
+
+    def on_inline_comment(node)
+      @disabled_checks.update(node)
+    end
+
+    def after_document(node)
+      checks_missing_end_index = @disabled_checks.checks_missing_end_index
+      return if checks_missing_end_index.empty?
+
+      message = if checks_missing_end_index.any? { |name| name == :all }
+                  "All checks were"
+                else
+                  checks_missing_end_index.join(', ') + " " + (checks_missing_end_index.size == 1 ? "was" : "were")
+                end
+
+      add_offense("#{message} disabled but not re-enabled with platformos-check-enable", node:)
+    end
+  end
+end