platformos-check 0.0.1

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

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

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module PlatformosLiquid
+    class SourceIndex
+      class ParameterEntry < BaseEntry
+        def summary
+          nil
+        end
+
+        def platformos_documentation_url
+          "#{PLATFORMOS_DOCUMENTATION_URL}/api-reference/liquid/filters/#{hash['name']}"
+        end
+
+        private
+
+        def return_type_hash
+          {
+            'type' => (hash['types'] || ['untyped']).first
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module PlatformosLiquid
+    class SourceIndex
+      class PropertyEntry < BaseEntry
+        attr_reader :parent_name
+
+        def initialize(hash, parent_name)
+          @hash = hash || {}
+          @return_type = nil
+          @parent_name = parent_name
+        end
+
+        def platformos_documentation_url
+          "#{PLATFORMOS_DOCUMENTATION_URL}/developer-guide/variables/context-variable##{@parent_name}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module PlatformosLiquid
+    class SourceIndex
+      class ReturnTypeEntry < BaseEntry
+        def summary
+          nil
+        end
+
+        def to_s
+          hash['type']
+        end
+
+        def generic_type?
+          hash['type'] == 'generic'
+        end
+
+        def array_type?
+          !array_type.nil? && !array_type.empty?
+        end
+
+        def array_type
+          hash['array_value']
+        end
+
+        def denied_filters
+          hash['denied_filters'] || []
+        end
+
+        private
+
+        def return_type_hash
+          {
+            'type' => "type<#{self}>"
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module PlatformosLiquid
+    class SourceIndex
+      class TagEntry < BaseEntry
+        def parameters
+          (hash['parameters'] || [])
+            .map { |hash| ParameterEntry.new(hash) }
+        end
+
+        def return_type_hash
+          {
+            'type' => "tag<#{name}>"
+          }
+        end
+
+        def platformos_documentation_url
+          "#{PLATFORMOS_DOCUMENTATION_URL}/api-reference/liquid/tags/#{hash['name']}"
+        end
+      end
+    end
+  end
+end

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

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

data/lib/platformos_check/platformos_liquid/source_index.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'pathname'
+
+module PlatformosCheck
+  module PlatformosLiquid
+    class SourceIndex
+      class << self
+        def filters
+          @filters = nil if FilterState.outdated?
+
+          @filters ||= FilterState.mark_up_to_date &&
+                       load_file(:filters)
+                       .map { |hash| FilterEntry.new(hash) }
+        end
+
+        def objects
+          @objects = nil if ObjectState.outdated?
+
+          @objects ||= ObjectState.mark_up_to_date &&
+                       load_file(:objects)
+                       .concat(built_in_objects)
+                       .filter_map do |hash|
+                         next if labels_only_exposed_in_certain_contexts.include?(hash['name'])
+
+                         ObjectEntry.new(hash)
+                       end
+        end
+
+        def tags
+          @tags = nil if TagState.outdated?
+
+          @tags ||= TagState.mark_up_to_date &&
+                    load_file(:tags)
+                    .map { |hash| TagEntry.new(hash) }
+        end
+
+        def plus_labels
+          @plus_objects ||= load_file("../plus_labels")
+        end
+
+        def platformos_app_app_extension_labels
+          @platformos_app_app_extension_labels ||= load_file("../platformos_app_app_extension_labels")
+        end
+
+        def labels_only_exposed_in_certain_contexts
+          %w[robots app].freeze
+        end
+
+        def deprecated_filters
+          @deprecated_filters ||= load_file("../deprecated_filters")
+        end
+
+        private
+
+        def load_file(file_name)
+          read_json(local_path!(file_name))
+        rescue StandardError
+          # If files get manually deleted, fallback with an empty list.
+          []
+        end
+
+        def local_path!(file_name)
+          SourceManager.download unless SourceManager.has_required_files?
+          SourceManager.local_path(file_name)
+        end
+
+        def read_json(path)
+          JSON.parse(path.read)
+        end
+
+        def built_in_objects
+          load_file('../built_in_liquid_objects')
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/platformos_liquid/source_manager.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'pathname'
+require 'tmpdir'
+
+module PlatformosCheck
+  module PlatformosLiquid
+    class SourceManager
+      REQUIRED_FILE_NAMES = %i[filters objects tags latest].freeze
+
+      class DownloadResourceError < StandardError; end
+
+      class << self
+        def download_or_refresh_files(destination = default_destination)
+          if has_required_files?(destination)
+            refresh(destination)
+          else
+            download(destination)
+          end
+        end
+
+        def download(destination = default_destination)
+          Dir.mkdir(destination) unless destination.exist?
+
+          REQUIRED_FILE_NAMES.each do |file_name|
+            download_file(local_path(file_name, destination), remote_path(file_name))
+          end
+        rescue DownloadResourceError
+          # If a request error occurs, ignore it. This ensures that PlatformOS Check
+          # can rely on the sources included during the bundling phase.
+        end
+
+        def refresh(destination = default_destination)
+          refresh_threads << Thread.new { refresh_thread(destination) }
+        end
+
+        def local_path(file_name, destination = default_destination)
+          destination + "#{file_name}.json"
+        end
+
+        def has_required_files?(destination = default_destination)
+          REQUIRED_FILE_NAMES.all? { |file_name| local_path(file_name, destination).exist? }
+        end
+
+        def wait_downloads
+          refresh_threads.each(&:join)
+        end
+
+        private
+
+        def refresh_thread(destination)
+          return unless refresh_needed?(destination)
+
+          Dir.mktmpdir do |tmp_dir|
+            download(Pathname.new(tmp_dir))
+
+            FileUtils.cp_r("#{tmp_dir}/.", destination)
+
+            mark_all_indexes_outdated
+          end
+        end
+
+        def refresh_needed?(destination)
+          local_latest_content = local_path(:latest, destination).read
+          remote_latest_content = open_uri(remote_path(:latest))
+
+          revision(local_latest_content) != revision(remote_latest_content)
+        end
+
+        def revision(json_content)
+          # Raise an error if revision isn't found to avoid returning nil
+          JSON.parse(json_content).fetch('revision')
+        end
+
+        def remote_path(file_name)
+          "https://documentation.platformos.com/api/liquid/#{file_name}.json"
+        end
+
+        def download_file(local_path, remote_uri)
+          content = open_uri(remote_uri)
+          File.binwrite(local_path, content)
+        end
+
+        def mark_all_indexes_outdated
+          SourceIndex::FilterState.mark_outdated
+          SourceIndex::ObjectState.mark_outdated
+          SourceIndex::TagState.mark_outdated
+        end
+
+        # State
+
+        def default_destination
+          @default_destination ||= Pathname.new("#{__dir__}/../../../data/platformos_liquid/documentation")
+        end
+
+        def refresh_threads
+          @refresh_threads ||= []
+        end
+
+        def open_uri(uri_str)
+          uri = URI.parse(uri_str)
+
+          res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+            req = Net::HTTP::Get.new(uri)
+            http.request(req)
+          end
+
+          res.body
+        rescue StandardError
+          raise DownloadResourceError
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/platformos_liquid/tag.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module PlatformosCheck
+  module PlatformosLiquid
+    module Tag
+      extend self
+
+      LABELS_NOT_IN_SOURCE_INDEX = %w[elsif ifchanged catch ensure when]
+
+      def labels
+        @labels ||= tags_file_contents
+                    .map { |x| to_label(x) }
+                    .to_set
+      end
+
+      def end_labels
+        @end_labels ||= tags_file_contents
+                        .select { |x| x.is_a?(Hash) }
+                        .map { |x| x.values[0] }
+      end
+
+      def tag_regex(tag)
+        return unless labels.include?(tag)
+
+        @tag_regexes ||= {}
+        @tag_regexes[tag] ||= /\A#{Liquid::TagStart}-?\s*#{tag}/m
+      end
+
+      def liquid_tag_regex(tag)
+        return unless labels.include?(tag)
+
+        @tag_liquid_regexes ||= {}
+        @tag_liquid_regexes[tag] ||= /^\s*#{tag}/m
+      end
+
+      private
+
+      def to_label(label)
+        return label if label.is_a?(String)
+
+        label.keys[0]
+      end
+
+      def tags_file_contents
+        @tags_file_contents ||= SourceIndex.tags.map do |tag|
+          opening_tag = tag.name
+          closing_tag = "end#{opening_tag}"
+          if /#{opening_tag}.+#{closing_tag}/m.match?(tag.hash['syntax'])
+            { opening_tag => closing_tag }
+          else
+            opening_tag
+          end
+        end + LABELS_NOT_IN_SOURCE_INDEX
+      end
+    end
+  end
+end

data/lib/platformos_check/platformos_liquid.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'platformos_liquid/deprecated_filter'
+require_relative 'platformos_liquid/documentation'
+require_relative 'platformos_liquid/filter'
+require_relative 'platformos_liquid/object'
+require_relative 'platformos_liquid/source_manager'
+require_relative 'platformos_liquid/source_index'
+require_relative 'platformos_liquid/tag'
+
+require_relative 'platformos_liquid/source_index/base_entry'
+require_relative 'platformos_liquid/source_index/filter_entry'
+require_relative 'platformos_liquid/source_index/object_entry'
+require_relative 'platformos_liquid/source_index/parameter_entry'
+require_relative 'platformos_liquid/source_index/property_entry'
+require_relative 'platformos_liquid/source_index/return_type_entry'
+require_relative 'platformos_liquid/source_index/tag_entry'
+require_relative 'platformos_liquid/source_index/base_state'
+require_relative 'platformos_liquid/source_index/filter_state'
+require_relative 'platformos_liquid/source_index/object_state'
+require_relative 'platformos_liquid/source_index/tag_state'

data/lib/platformos_check/position.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class Position
+    include PositionHelper
+
+    attr_reader :contents
+
+    def initialize(
+      needle_arg,
+      contents_arg,
+      line_number_1_indexed: nil,
+      node_markup: nil,
+      node_markup_offset: 0 # the index of markup inside the node_markup
+    )
+      @needle = needle_arg
+
+      @contents = if contents_arg.is_a?(String) && !contents_arg.empty?
+                    contents_arg
+                  else
+                    ''
+                  end
+
+      @line_number_1_indexed = line_number_1_indexed
+      @node_markup_offset = node_markup_offset
+      @node_markup = node_markup
+    end
+
+    def start_line_offset
+      @start_line_offset ||= from_row_column_to_index(contents, line_number, 0)
+    end
+
+    def start_offset
+      @start_offset ||= compute_start_offset
+    end
+
+    def strict_position
+      @strict_position ||= StrictPosition.new(
+        needle,
+        contents,
+        start_index
+      )
+    end
+
+    # 0-indexed, inclusive
+    def start_index
+      contents.index(needle, start_offset)
+    end
+
+    # 0-indexed, exclusive
+    def end_index
+      strict_position.end_index
+    end
+
+    # 0-indexed, inclusive
+    def start_row
+      strict_position.start_row
+    end
+
+    # 0-indexed, inclusive
+    def start_column
+      strict_position.start_column
+    end
+
+    # 0-indexed, exclusive (both taken together are) therefore you
+    # might end up on a newline character or the next line
+    def end_row
+      strict_position.end_row
+    end
+
+    def end_column
+      strict_position.end_column
+    end
+
+    def content_line_count
+      @content_line_count ||= contents.count("\n")
+    end
+
+    private
+
+    def compute_start_offset
+      return start_line_offset if @node_markup.nil?
+
+      node_markup_start = contents.index(@node_markup, start_line_offset)
+      return start_line_offset if node_markup_start.nil?
+
+      node_markup_start + @node_markup_offset
+    end
+
+    def line_number
+      return 0 if @line_number_1_indexed.nil?
+
+      bounded(0, @line_number_1_indexed - 1, content_line_count)
+    end
+
+    def needle
+      @cached_needle ||= if has_content_and_line_number_but_no_needle?
+                           entire_line_needle
+                         elsif contents.empty? || @needle.nil?
+                           ''
+                         elsif !can_find_needle?
+                           entire_line_needle
+                         else
+                           @needle
+                         end
+    end
+
+    def has_content_and_line_number_but_no_needle?
+      @needle.nil? && !contents.empty? && @line_number_1_indexed.is_a?(Integer)
+    end
+
+    def can_find_needle?
+      !!contents.index(@needle, start_offset)
+    end
+
+    def entire_line_needle
+      contents.lines(chomp: true)[line_number] || ''
+    end
+  end
+
+  # This method is stricter than Position in the sense that it doesn't
+  # accept invalid inputs. Makes for code that is easier to understand.
+  class StrictPosition
+    include PositionHelper
+
+    attr_reader :needle, :contents
+
+    def initialize(needle, contents, start_index)
+      raise ArgumentError, 'Bad start_index' unless start_index.is_a?(Integer)
+      raise ArgumentError, 'Bad contents' unless contents.is_a?(String)
+      raise ArgumentError, 'Bad needle' unless needle.is_a?(String) || !contents.index(needle, start_index)
+
+      @needle = needle
+      @contents = contents
+      @start_index = start_index
+      @start_row_column = nil
+      @end_row_column = nil
+    end
+
+    # 0-indexed, inclusive
+    def start_index
+      @contents.index(needle, @start_index)
+    end
+
+    # 0-indexed, exclusive
+    def end_index
+      start_index + needle.size
+    end
+
+    def start_row
+      start_row_column[0]
+    end
+
+    def start_column
+      start_row_column[1]
+    end
+
+    def end_row
+      end_row_column[0]
+    end
+
+    def end_column
+      end_row_column[1]
+    end
+
+    private
+
+    def start_row_column
+      return @start_row_column unless @start_row_column.nil?
+
+      @start_row_column = from_index_to_row_column(contents, start_index)
+    end
+
+    def end_row_column
+      return @end_row_column unless @end_row_column.nil?
+
+      @end_row_column = from_index_to_row_column(contents, end_index)
+    end
+  end
+end

data/lib/platformos_check/position_helper.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# NOTE: Everything is 0-indexed here.
+
+module PlatformosCheck
+  module PositionHelper
+    # Apparently this old implementation is 2x slower (with benchmark/ips),
+    # so dropping with the following one... It's ugly af but
+    # this shit runs 100K+ times in one platformos-check so it gotta go
+    # fast!
+    #
+    def from_row_column_to_index(content, row, col)
+      return 0 unless content.is_a?(String) && !content.empty?
+      return 0 unless row.is_a?(Integer) && col.is_a?(Integer)
+
+      i = 0
+      safe_row = bounded(0, row, content.count("\n"))
+      scanner = StringScanner.new(content)
+      scanner.scan_until(/\n/) while i < safe_row && (i += 1)
+      result = scanner.charpos || 0
+      scanner.scan_until(/\n|\z/)
+      bounded(result, result + col, scanner.pre_match.size)
+    end
+
+    # def from_row_column_to_index(content, row, col)
+    #   return 0 unless content.is_a?(String) && !content.empty?
+    #   return 0 unless row.is_a?(Integer) && col.is_a?(Integer)
+    #   i = 0
+    #   safe_row = bounded(0, row, content.count("\n"))
+    #   charpos = -1
+    #   charpos = content.index("\n", charpos + 1) while i < safe_row && (i += 1) && charpos
+    #   result = charpos ? charpos + 1 : 0
+    #   next_line = content.index("\n", result)
+    #   upper_bound = next_line ? next_line : content.size - 1
+    #   bounded(result, result + col, upper_bound)
+    # end
+
+    def from_index_to_row_column(content, index)
+      return [0, 0] unless content.is_a?(String) && !content.empty?
+      return [0, 0] unless index.is_a?(Integer)
+
+      safe_index = bounded(0, index, content.size - 1)
+      content_up_to_index = content[0...safe_index]
+      row = content_up_to_index.count("\n")
+      col = 0
+      col += 1 while (safe_index -= 1) && safe_index >= 0 && content[safe_index] != "\n"
+      [row, col]
+    end
+
+    def bounded(a, x, b)
+      return a if x < a
+      return b if x > b
+
+      x
+    end
+  end
+end