platformos-check 0.0.1

data/lib/platformos_check/liquid_visitor.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class LiquidVisitor
+    attr_reader :checks
+
+    def initialize(checks, disabled_checks)
+      @checks = checks
+      @disabled_checks = disabled_checks
+    end
+
+    def visit_liquid_file(liquid_file)
+      visit(LiquidNode.new(liquid_file.root, nil, liquid_file))
+    rescue Liquid::Error => e
+      e.template_name = liquid_file.name
+      call_checks(:on_error, e)
+    end
+
+    private
+
+    def visit(node)
+      call_checks(:on_node, node)
+      call_checks(:on_tag, node) if node.tag?
+      call_checks(:"on_#{node.type_name}", node)
+      node.children.each { |child| visit(child) }
+      unless node.literal?
+        call_checks(:"after_#{node.type_name}", node)
+        call_checks(:after_tag, node) if node.tag?
+        call_checks(:after_node, node)
+      end
+
+      @disabled_checks.update(node) if node.comment? || node.inline_comment?
+    end
+
+    def call_checks(method, *)
+      checks.call(method, *)
+    end
+  end
+end

data/lib/platformos_check/migration_file.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class MigrationFile < LiquidFile
+    def migration?
+      true
+    end
+  end
+end

data/lib/platformos_check/node.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class Node
+    def parent
+      raise NotImplementedError
+    end
+
+    def app_file
+      raise NotImplementedError
+    end
+
+    def value
+      raise NotImplementedError
+    end
+
+    def children
+      raise NotImplementedError
+    end
+
+    def markup
+      raise NotImplementedError
+    end
+
+    def line_number
+      raise NotImplementedError
+    end
+
+    def start_index
+      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/platformos_check/offense.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class Offense
+    include PositionHelper
+
+    MAX_SOURCE_EXCERPT_SIZE = 120
+
+    attr_reader :check, :message, :app_file, :node, :markup, :line_number, :correction
+
+    def initialize(
+      check:, # instance of a PlatformosCheck::Check
+      message: nil, # error message for the offense
+      app_file: nil, # AppFile
+      node: nil, # Node
+      markup: nil, # string
+      line_number: nil, # line number of the error (1-indexed)
+      # node_markup_offset is the index inside node.markup to start
+      # looking for markup :mindblow:.
+      # This is so we can accurately highlight node substrings.
+      # e.g. if we have the following scenario in which we
+      # want to highlight the middle comma
+      #   * node.markup == "replace ',',', '"
+      #   * markup == ","
+      # Then we need some way of telling our Position class to start
+      # looking for the second comma. This is done with node_markup_offset.
+      # More context can be found in #376.
+      node_markup_offset: 0,
+      correction: nil # block
+    )
+      @check = check
+      @correction = correction
+
+      if message
+        @message = message
+      elsif defined?(check.class::MESSAGE)
+        @message = check.class::MESSAGE
+      else
+        raise ArgumentError, "message required"
+      end
+
+      @node = node
+      @app_file = node&.app_file || app_file
+      @markup = markup || node&.markup
+
+      raise ArgumentError, "Offense markup cannot be an empty string" if @markup.is_a?(String) && @markup.empty?
+
+      @line_number = line_number || @node&.line_number
+
+      @position = Position.new(
+        @markup,
+        @app_file&.source,
+        line_number_1_indexed: @line_number,
+        node_markup_offset:,
+        node_markup: node&.markup
+      )
+    end
+
+    def source_excerpt
+      return unless line_number
+
+      @source_excerpt ||= begin
+        excerpt = app_file.source_excerpt(line_number)
+        if excerpt.size > MAX_SOURCE_EXCERPT_SIZE
+          excerpt[0, MAX_SOURCE_EXCERPT_SIZE - 3] + '...'
+        else
+          excerpt
+        end
+      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_row
+      @position.start_row
+    end
+
+    def start_column
+      @position.start_column
+    end
+
+    def end_index
+      @position.end_index
+    end
+
+    def end_row
+      @position.end_row
+    end
+
+    def end_column
+      @position.end_column
+    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
+      StringHelpers.demodulize(check.class.name)
+    end
+
+    def version
+      app_file&.version
+    end
+
+    def doc
+      check.doc
+    end
+
+    def location
+      tokens = [app_file&.relative_path, line_number].compact
+      tokens.join(":") if tokens.any?
+    end
+
+    def location_range
+      tokens = [app_file&.relative_path, start_index, end_index].compact
+      tokens.join(":") if tokens.any?
+    end
+
+    def correctable?
+      !!correction
+    end
+
+    def correct(corrector = nil)
+      if correctable?
+        corrector ||= Corrector.new(app_file:)
+        correction.call(corrector)
+      end
+    rescue StandardError => e
+      PlatformosCheck.bug(<<~EOS)
+        Exception while running `Offense#correct`:
+        ```
+        #{e.class}: #{e.message}
+          #{e.backtrace.join("\n  ")}
+        ```
+
+        Offense:
+        ```
+        #{JSON.pretty_generate(to_h)}
+        ```
+        Check options:
+        ```
+        #{check.options.pretty_inspect}
+        ```
+        Markup:
+        ```
+        #{markup}
+        ```
+        Node.Markup:
+        ```
+        #{node&.markup}
+        ```
+      EOS
+      exit(2)
+    end
+
+    def whole_platformos_app?
+      check.whole_platformos_app?
+    end
+
+    def single_file?
+      check.single_file?
+    end
+
+    def ==(other)
+      other.is_a?(Offense) &&
+        code_name == other.code_name &&
+        message == other.message &&
+        location == other.location &&
+        start_index == other.start_index &&
+        end_index == other.end_index
+    end
+    alias eql? ==
+
+    def to_s
+      if app_file
+        "#{message} at #{location}"
+      else
+        message
+      end
+    end
+
+    def to_s_range
+      if app_file
+        "#{message} at #{location_range}"
+      else
+        message
+      end
+    end
+
+    def to_h
+      {
+        check: check.code_name,
+        path: app_file&.relative_path,
+        severity: check.severity_value,
+        start_row:,
+        start_column:,
+        end_row:,
+        end_column:,
+        message:
+      }
+    end
+  end
+end

data/lib/platformos_check/page_file.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class PageFile < LiquidFile
+    def page?
+      true
+    end
+  end
+end

data/lib/platformos_check/parsing_helpers.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module ParsingHelpers
+    # Yield each chunk outside of "...", '...'
+    def outside_of_strings(markup)
+      scanner = StringScanner.new(markup)
+
+      while scanner.scan(/.*?("|')/m)
+        chunk_start = scanner.pre_match.size
+        yield scanner.matched[0..-2], chunk_start
+        quote = scanner.matched[-1] == "'" ? "'" : "\""
+        # Skip to the end of the string
+        # Check for empty string first, since follow regexp uses lookahead
+        scanner.skip(/#{quote}/) || scanner.skip_until(/[^\\]#{quote}/)
+      end
+
+      yield scanner.rest, scanner.charpos if scanner.rest?
+    end
+  end
+end

data/lib/platformos_check/partial_file.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class PartialFile < LiquidFile
+    DIR_PREFIX = %r{\A/?((marketplace_builder|app)/(views/partials|liquid_views|views|lib)/|modules/((\w|-)*)/(private|public)/(views/partials|liquid_views|views|lib)/)}
+
+    def partial?
+      true
+    end
+
+    def dir_prefix
+      DIR_PREFIX
+    end
+  end
+end

data/lib/platformos_check/platformos_liquid/deprecated_filter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module PlatformosCheck
+  module PlatformosLiquid
+    module DeprecatedFilter
+      extend self
+
+      def alternatives(filter)
+        all.fetch(filter, nil)
+      end
+
+      def labels
+        @labels ||= all.keys
+      end
+
+      private
+
+      def all
+        @all ||= SourceIndex.deprecated_filters
+                            .values
+                            .each_with_object({}) do |filters, acc|
+          filters.each do |(filter, alternatives)|
+            acc[filter] = alternatives
+          end
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/platformos_liquid/documentation/markdown_template.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module PlatformosLiquid
+    class Documentation
+      class MarkdownTemplate
+        MARKDOWN_RELATIVE_LINK = %r{(\[([^\[]+)\]\((/[^\)]+)\))*}
+
+        def render(entry)
+          [
+            title(entry),
+            body(entry)
+          ].reject(&:empty?).join("\n")
+        end
+
+        private
+
+        def title(entry)
+          "### [#{entry.name}](#{entry.platformos_documentation_url})"
+        end
+
+        def body(entry)
+          [entry.deprecation_reason, entry.summary, entry.description]
+            .reject(&:nil?)
+            .reject(&:empty?)
+            .join(horizontal_rule)
+            .tap { |body| break(patch_urls!(body)) }
+        end
+
+        def horizontal_rule
+          "\n\n---\n\n"
+        end
+
+        def patch_urls!(body)
+          body.gsub(MARKDOWN_RELATIVE_LINK) do |original_link|
+            match = Regexp.last_match
+
+            text = match[2]
+            path = match[3]
+
+            if text && path
+              "[#{text}](https://documentation.platformos.com#{path})"
+            else
+              original_link
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/platformos_liquid/documentation.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'documentation/markdown_template'
+
+module PlatformosCheck
+  module PlatformosLiquid
+    class Documentation
+      class << self
+        def filter_doc(filter_name)
+          render_doc(SourceIndex.filters.find { |entry| entry.name == filter_name })
+        end
+
+        def object_doc(object_name)
+          render_doc(SourceIndex.objects.find { |entry| entry.name == object_name })
+        end
+
+        def tag_doc(tag_name)
+          render_doc(SourceIndex.tags.find { |entry| entry.name == tag_name })
+        end
+
+        def object_property_doc(object_name, property_name)
+          property_entry = SourceIndex
+                           .objects
+                           .find { |entry| entry.name == object_name }
+            &.properties
+            &.find { |prop| prop.name == property_name }
+
+          render_doc(property_entry)
+        end
+
+        def render_doc(entry)
+          return nil unless entry
+
+          markdown_template.render(entry)
+        end
+
+        private
+
+        def markdown_template
+          @markdown_template ||= MarkdownTemplate.new
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/platformos_liquid/filter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module PlatformosCheck
+  module PlatformosLiquid
+    module Filter
+      extend self
+
+      def labels
+        @labels ||= SourceIndex.filters.map(&:name)
+      end
+
+      def aliases
+        @aliases ||= SourceIndex.filters.map(&:aliases).flatten
+      end
+    end
+  end
+end

data/lib/platformos_check/platformos_liquid/object.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module PlatformosCheck
+  module PlatformosLiquid
+    module Object
+      extend self
+
+      def labels
+        @labels ||= SourceIndex.objects.map(&:name)
+      end
+    end
+  end
+end

data/lib/platformos_check/platformos_liquid/source_index/base_entry.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module PlatformosCheck
+  module PlatformosLiquid
+    class SourceIndex
+      class BaseEntry
+        extend Forwardable
+
+        attr_reader :hash
+
+        def_delegators :return_type_instance, :generic_type?, :array_type?, :array_type, :to_s, :denied_filters
+
+        PLATFORMOS_DOCUMENTATION_URL = "https://documentation.platformos.com"
+
+        def initialize(hash = {})
+          @hash = hash || {}
+          @return_type = nil
+        end
+
+        def name
+          hash['name']
+        end
+
+        def summary
+          hash['summary'] || ''
+        end
+
+        def description
+          hash['description'] || ''
+        end
+
+        def deprecated?
+          hash['deprecated']
+        end
+
+        def deprecation_reason
+          return nil unless deprecated?
+
+          hash['deprecation_reason'] || nil
+        end
+
+        def platformos_documentation_url
+          PLATFORMOS_DOCUMENTATION_URL
+        end
+
+        attr_writer :return_type
+
+        def return_type
+          @return_type || to_s
+        end
+
+        def return_type_instance
+          ReturnTypeEntry.new(return_type_hash)
+        end
+
+        private
+
+        def return_type_hash
+          hash['return_type']&.first
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/platformos_liquid/source_index/base_state.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module PlatformosLiquid
+    class SourceIndex
+      class BaseState
+        class << self
+          def mark_outdated
+            @up_to_date = false
+          end
+
+          def mark_up_to_date
+            @up_to_date = true
+          end
+
+          def outdated?
+            @up_to_date == false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/platformos_liquid/source_index/filter_entry.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module PlatformosLiquid
+    class SourceIndex
+      class FilterEntry < BaseEntry
+        def parameters
+          (hash['parameters'] || [])
+            .map { |hash| ParameterEntry.new(hash) }
+        end
+
+        def aliases
+          hash['aliases'] || []
+        end
+
+        def input_type
+          @input_type ||= hash['syntax'].split(' | ')[0]
+        end
+
+        def platformos_documentation_url
+          "#{PLATFORMOS_DOCUMENTATION_URL}/api-reference/liquid/filters/#{hash['name']}"
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/platformos_liquid/source_index/filter_state.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module PlatformosLiquid
+    class SourceIndex
+      class FilterState < BaseState
+        @up_to_date = false
+      end
+    end
+  end
+end

data/lib/platformos_check/platformos_liquid/source_index/object_entry.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module PlatformosLiquid
+    class SourceIndex
+      class ObjectEntry < BaseEntry
+        def properties
+          (hash['properties'] || [])
+            .map do |prop_hash|
+              PropertyEntry.new(prop_hash, hash['name'])
+            end
+        end
+
+        def platformos_documentation_url
+          "#{PLATFORMOS_DOCUMENTATION_URL}/developer-guide/variables/context-variable##{hash['name']}"
+        end
+      end
+    end
+  end
+end