platformos-check 0.0.1

data/lib/platformos_check/checks/missing_template.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  # Reports missing include/render/section liquid file
+  class MissingTemplate < LiquidCheck
+    class MissingFileCorrection
+      def initialize(path:, directory:, extension:)
+        @path = path
+        @directory = directory
+        @extension = extension
+      end
+
+      def full_relative_path
+        @full_relative_path ||= module? ? module_path : app_path
+      end
+
+      private
+
+      attr_reader :path, :directory, :extension
+
+      def app_path
+        ['app', directory, "#{path}#{extension}"].join(File::SEPARATOR)
+      end
+
+      def module_path
+        path.split(File::SEPARATOR).insert(2, "public#{File::SEPARATOR}#{directory}").join(File::SEPARATOR) + extension
+      end
+
+      def module?
+        path.start_with?('modules/')
+      end
+    end
+
+    severity :suggestion
+    category :liquid
+    doc docs_url(__FILE__)
+    single_file false
+
+    def initialize(ignore_missing: [])
+      @ignore_missing = ignore_missing
+    end
+
+    def on_include(node)
+      partial = node.value.template_name_expr
+      return unless partial.is_a?(String)
+
+      add_missing_partial_offense(partial, node:)
+    end
+
+    def on_render(node)
+      partial = node.value.template_name_expr
+      return unless partial.is_a?(String)
+
+      add_missing_partial_offense(partial, node:)
+    end
+
+    def on_function(node)
+      partial = node.value.from
+      return unless partial.is_a?(String)
+
+      add_missing_function_offense(partial, node:)
+    end
+
+    def on_graphql(node)
+      return if node.value.inline_query
+
+      graphql_partial = node.value.partial_name
+      return unless graphql_partial.is_a?(String)
+
+      add_missing_graphql_offense(graphql_partial, node:)
+    end
+
+    private
+
+    def ignore?(path)
+      all_ignored_patterns.any? { |pattern| File.fnmatch?(pattern, path) }
+    end
+
+    def all_ignored_patterns
+      @all_ignored_patterns ||= @ignore_missing + ignored_patterns
+    end
+
+    def add_missing_partial_offense(path, node:)
+      return if ignore?(path) || platformos_app.grouped_files[PartialFile][path]
+
+      add_offense("'#{path}' is not found", node:) # do |corrector|
+      # corrector.create_file(@platformos_app.storage, MissingFileCorrection.new(path:, directory: 'views/partials', extension: '.liquid').full_relative_path, "")
+      # end
+    end
+
+    def add_missing_function_offense(path, node:)
+      return if ignore?(path) || platformos_app.grouped_files[PartialFile][path]
+
+      add_offense("'#{path}' is not found", node:) # do |corrector|
+      # corrector.create_file(@platformos_app.storage, MissingFileCorrection.new(path:, directory: 'lib', extension: '.liquid').full_relative_path, "")
+      # end
+    end
+
+    def add_missing_graphql_offense(path, node:)
+      return if ignore?(path) || platformos_app.grouped_files[GraphqlFile][path]
+
+      add_offense("'#{path}' is not found", node:) # do |corrector|
+      # corrector.create_file(@platformos_app.storage, MissingFileCorrection.new(path:, directory: 'graphql', extension: '.graphql').full_relative_path, "")
+      # end
+    end
+  end
+end

data/lib/platformos_check/checks/parse_json_format.rb

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

data/lib/platformos_check/checks/parser_blocking_javascript.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  # Reports errors when trying to use parser-blocking script tags
+  class ParserBlockingJavaScript < HtmlCheck
+    severity :error
+    categories :html, :performance
+    doc docs_url(__FILE__)
+
+    def on_script(node)
+      return unless node.attributes["src"]
+      return if node.attributes["defer"] || node.attributes["async"] || node.attributes["type"] == "module"
+
+      add_offense("Missing async or defer attribute on script tag", node:)
+    end
+  end
+end

data/lib/platformos_check/checks/required_layout_object.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  # Reports missing content_for_layout in layouts
+  class RequiredLayoutObject < LiquidCheck
+    severity :error
+    category :liquid
+    doc docs_url(__FILE__)
+
+    def initialize
+      @content_for_layout_found = false
+    end
+
+    def on_document(node)
+      @layout_platformos_app_node = node if node.app_file.layout?
+    end
+
+    def on_variable(node)
+      return unless node.value.name.is_a?(Liquid::VariableLookup)
+
+      @content_for_layout_found ||= node.value.name.name == "content_for_layout"
+    end
+
+    def after_document(node)
+      return unless node.app_file.layout?
+
+      add_missing_object_offense("content_for_layout", "</body>") unless @content_for_layout_found
+    end
+
+    private
+
+    def add_missing_object_offense(name, tag)
+      add_offense("layout must include {{#{name}}}", node: @layout_platformos_app_node) do
+        if @layout_platformos_app_node.source.index(tag)
+          @layout_platformos_app_node.source.insert(@layout_platformos_app_node.source.index(tag), "  {{ #{name} }}\n  ")
+          @layout_platformos_app_node.markup = @layout_platformos_app_node.source
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/checks/space_inside_braces.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  # Ensure {% ... %} & {{ ... }} have consistent spaces.
+  class SpaceInsideBraces < LiquidCheck
+    severity :style
+    category :liquid
+    doc docs_url(__FILE__)
+
+    def on_node(node)
+      return unless node.markup
+      return if node.literal?
+      return if node.assigned_or_echoed_variable?
+
+      outside_of_strings(node.markup) do |chunk, chunk_start|
+        chunk.scan(/(?<token>[,:|]|==|<>|<=|>=|<|>|!=)(?<offense>  +)/) do |_match|
+          add_too_many_spaces_after_offense(Regexp.last_match, node, chunk_start)
+        end
+        chunk.scan(/(?<offense>(?<token>[,:|]|==|<>|<=|>=|<\b|>\b|!=)(\S|\z))/) do |_match|
+          add_space_missing_after_offense(Regexp.last_match, node, chunk_start)
+        end
+        chunk.scan(/(?<offense>\s{2,})(?<token>\||==|<>|<=|>=|<|>|!=)+/) do |_match|
+          add_too_many_spaces_before_offense(Regexp.last_match, node, chunk_start) unless Regexp.last_match(:offense).include?("\n")
+        end
+        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)
+      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
+        add_space_missing_after_offense(Regexp.last_match, node, block.node_markup_offset) if block.markup =~ /^(?<token>{%-?)(?<offense>[^ \n\t-])/
+
+        add_too_many_spaces_after_offense(Regexp.last_match, node, block.node_markup_offset) if block.markup =~ /^(?<token>{%-?)(?<offense> {2,})\S/
+
+        # Looking at spaces before the end token
+        add_space_missing_before_offense(Regexp.last_match, node, block.node_markup_offset) if block.markup =~ /(?<offense>[^ \n\t-])(?<token>-?%})$/
+
+        add_too_many_spaces_before_offense(Regexp.last_match, node, block.node_markup_offset) if block.markup =~ /\S(?<offense> {2,})(?<token>-?%})$/
+
+        next
+      end
+    end
+
+    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
+      add_space_missing_after_offense(Regexp.last_match, node, block_start_offset) if node.block_start_markup =~ /^(?<token>{{-?)(?<offense>[^ \n\t-])/
+
+      add_too_many_spaces_after_offense(Regexp.last_match, node, block_start_offset) if node.block_start_markup =~ /^(?<token>{{-?)(?<offense> {2,})\S/
+
+      # Looking at spaces before the end token
+      add_space_missing_before_offense(Regexp.last_match, node, block_start_offset) if node.block_start_markup =~ /(?<offense>[^ \n\t-])(?<token>-?}})$/
+
+      return unless node.block_start_markup =~ /\S(?<offense> {2,})(?<token>-?}})$/
+
+      add_too_many_spaces_before_offense(Regexp.last_match, node, block_start_offset)
+    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
+    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
+    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
+    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, &)
+      add_offense(
+        message,
+        node:,
+        markup: match[:offense],
+        node_markup_offset: source_offset + match.begin(:offense),
+        &
+      )
+    end
+  end
+end

data/lib/platformos_check/checks/syntax_error.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  # Report Liquid syntax errors
+  class SyntaxError < LiquidCheck
+    severity :error
+    category :liquid
+    doc docs_url(__FILE__)
+
+    def on_document(node)
+      node.app_file.warnings.each do |warning|
+        add_exception_as_offense(warning, app_file: node.app_file)
+      end
+    end
+
+    def on_error(exception)
+      add_exception_as_offense(exception, app_file: platformos_app[exception.template_name])
+    end
+
+    private
+
+    def add_exception_as_offense(exception, app_file:)
+      add_offense(
+        exception.to_s(false).sub(/ in ".*"$/, ''),
+        line_number: exception.line_number,
+        markup: exception.markup_context&.sub(/^in "(.*)"$/, '\1'),
+        app_file:
+      )
+    end
+  end
+end

data/lib/platformos_check/checks/template_length.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class TemplateLength < LiquidCheck
+    severity :suggestion
+    category :liquid
+    doc docs_url(__FILE__)
+
+    def initialize(max_length: 600)
+      @max_length = max_length
+    end
+
+    def after_document(node)
+      lines = node.app_file.source.count("\n")
+      return unless lines > @max_length
+
+      add_offense("Template has too many lines [#{lines}/#{@max_length}]", app_file: node.app_file)
+    end
+  end
+end

data/lib/platformos_check/checks/undefined_object.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class UndefinedObject < LiquidCheck
+    category :liquid
+    doc docs_url(__FILE__)
+    severity :error
+
+    class TemplateInfo
+      def initialize(app_file: nil)
+        @all_variable_lookups = {}
+        @all_assigns = {}
+        @all_captures = {}
+        @all_forloops = {}
+        @all_renders = {}
+        @app_file = app_file
+      end
+
+      attr_reader :all_assigns, :all_captures, :all_forloops, :app_file
+
+      def add_render(name:, node:)
+        @all_renders[name] = node
+      end
+
+      def add_variable_lookup(name:, node:)
+        parent = node
+        line_number = nil
+        loop do
+          line_number = parent.line_number
+          parent = parent.parent
+          break unless line_number.nil? && parent
+        end
+        key = [name, line_number]
+        @all_variable_lookups[key] = node
+      end
+
+      def all_variables
+        all_assigns.keys + all_captures.keys + all_forloops.keys
+      end
+
+      def each_partial
+        @all_renders.each do |(name, info)|
+          yield [name, info]
+        end
+      end
+
+      def each_variable_lookup(unique_keys = false)
+        seen = Set.new
+        @all_variable_lookups.each do |(key, info)|
+          name, _line_number = key
+
+          next if unique_keys && seen.include?(name)
+
+          seen << name
+
+          yield [key, info]
+        end
+      end
+    end
+
+    def initialize(config_type: :default, exclude_partials: true)
+      @config_type = config_type
+      @exclude_partials = exclude_partials
+      @files = {}
+    end
+
+    def on_document(node)
+      return if ignore?(node)
+
+      @files[node.app_file.name] = TemplateInfo.new(app_file: node.app_file)
+    end
+
+    def on_assign(node)
+      return if ignore?(node)
+
+      @files[node.app_file.name].all_assigns[node.value.to] = node
+    end
+
+    def on_capture(node)
+      return if ignore?(node)
+
+      @files[node.app_file.name].all_captures[node.value.instance_variable_get(:@to)] = node
+    end
+
+    def on_parse_json(node)
+      return if ignore?(node)
+
+      @files[node.app_file.name].all_captures[node.value.to] = node
+    end
+
+    def on_for(node)
+      return if ignore?(node)
+
+      @files[node.app_file.name].all_forloops[node.value.variable_name] = node
+    end
+
+    def on_include(_node)
+      # NOOP: we purposely do nothing on `include` since it is deprecated
+    end
+
+    def on_render(node)
+      return if ignore?(node)
+      return unless node.value.template_name_expr.is_a?(String)
+
+      partial_name = node.value.template_name_expr
+      @files[node.app_file.name].add_render(
+        name: partial_name,
+        node:
+      )
+    end
+
+    def on_function(node)
+      return if ignore?(node)
+
+      name = node.value.from.is_a?(String) ? node.value.from : node.value.from.name
+      @files[node.app_file.name].add_render(
+        name:,
+        node:
+      )
+
+      @files[node.app_file.name].all_assigns[node.value.to] = node
+    end
+
+    def on_graphql(node)
+      return if ignore?(node)
+
+      @files[node.app_file.name].all_assigns[node.value.to] = node
+    end
+
+    def on_variable_lookup(node)
+      return if ignore?(node)
+
+      @files[node.app_file.name].add_variable_lookup(
+        name: node.value.name,
+        node:
+      )
+    end
+
+    def on_end
+      all_global_objects = PlatformosCheck::PlatformosLiquid::Object.labels
+      all_global_objects.freeze
+
+      each_template do |(_name, info)|
+        if info.app_file.notification?
+          # NOTE: `data` comes from graphql for notifications
+          check_object(info, all_global_objects + %w[data response form])
+        else
+          check_object(info, all_global_objects)
+        end
+      end
+    end
+
+    private
+
+    attr_reader :config_type
+
+    def ignore?(node)
+      @exclude_partials && node.app_file.partial?
+    end
+
+    def each_template
+      @files.each do |(name, info)|
+        next if info.app_file.partial?
+
+        yield [name, info]
+      end
+    end
+
+    def check_object(info, all_global_objects, render_node = nil, visited_partials = Set.new)
+      check_undefined(info, all_global_objects, render_node)
+
+      info.each_partial do |(partial_name, node)|
+        partial_info = @files[partial_name]
+        next unless partial_info # NOTE: undefined partial
+
+        partial_variables = node.value.attributes.keys +
+                            [node.value.instance_variable_get(:@alias_name)]
+        unless visited_partials.include?(partial_name)
+          visited_partials << partial_name
+          check_object(partial_info, all_global_objects + partial_variables, node, visited_partials)
+        end
+      end
+    end
+
+    def check_undefined(info, all_global_objects, render_node)
+      all_variables = info.all_variables
+
+      info.each_variable_lookup(!!render_node) do |(key, node)|
+        name, line_number = key
+        next if all_variables.include?(name)
+        next if all_global_objects.include?(name)
+
+        node = node.parent
+        node = node.parent if %i[condition variable_lookup].include?(node.type_name)
+
+        next if node.variable? && node.filters.any? { |(filter_name)| filter_name == "default" }
+
+        if render_node
+          add_offense("Missing argument `#{name}`", node: render_node)
+        else
+          add_offense("Undefined object `#{name}`", node:, line_number:)
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/checks/unknown_filter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  #
+  # Unwanted:
+  #
+  # {{ x | some_unknown_filter }}
+  #
+  # Wanted:
+  #
+  # {{ x | upcase }}
+  #
+  class UnknownFilter < LiquidCheck
+    severity :error
+    category :liquid
+    doc docs_url(__FILE__)
+
+    def on_variable(node)
+      used_filters = node.filters.map { |name, *_rest| name }
+      undefined_filters = used_filters - PlatformosLiquid::Filter.labels - PlatformosLiquid::Filter.aliases
+
+      undefined_filters.each do |undefined_filter|
+        add_offense("Undefined filter `#{undefined_filter}`", node:)
+      end
+    end
+  end
+end