platformos-check 0.0.1

data/lib/platformos_check/printer.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class Printer
+    def initialize(out_stream = STDOUT)
+      @out = out_stream
+    end
+
+    def print(platformos_app, offenses, auto_correct)
+      offenses.each do |offense|
+        print_offense(offense, auto_correct)
+        @out.puts
+      end
+
+      correctable = offenses.select(&:correctable?)
+      @out.puts "#{platformos_app.all.size} files inspected, #{red(offenses.size.to_s + ' offenses')} detected, \
+#{yellow(correctable.size.to_s + ' offenses')} #{auto_correct ? 'corrected' : 'auto-correctable'}"
+    end
+
+    def print_offense(offense, auto_correct)
+      location = if offense.location
+                   blue(offense.location) + ": "
+                 else
+                   ""
+                 end
+
+      corrected = if auto_correct && offense.correctable?
+                    green("[Corrected] ")
+                  else
+                    ""
+                  end
+
+      @out.puts location +
+                colorized_severity(offense.severity) + ": " +
+                yellow(offense.check_name) + ": " +
+                corrected +
+                offense.message + "."
+      return unless offense.source_excerpt
+
+      @out.puts "\t#{offense.source_excerpt}"
+      return unless offense.markup_start_in_excerpt
+
+      @out.puts "\t" + (" " * offense.markup_start_in_excerpt) + ("^" * offense.markup.size)
+    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/platformos_check/regex_helpers.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module RegexHelpers
+    LIQUID_TAG = /#{Liquid::TagStart}.*?#{Liquid::TagEnd}/om
+    LIQUID_VARIABLE = /#{Liquid::VariableStart}.*?#{Liquid::VariableEnd}/om
+    LIQUID_TAG_OR_VARIABLE = /#{LIQUID_TAG}|#{LIQUID_VARIABLE}/om
+    HTML_LIQUID_PLACEHOLDER = /≬[0-9a-z\n]+[#\n]*≬/m
+    START_OR_END_QUOTE = /(^['"])|(['"]$)/
+
+    def matches(s, re)
+      start_at = 0
+      matches = []
+      while (m = s.match(re, start_at))
+        matches.push(m)
+        start_at = m.end(0)
+      end
+      matches
+    end
+  end
+end

data/lib/platformos_check/releaser.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'platformos_check/version'
+
+module PlatformosCheck
+  class Releaser
+    ROOT = File.expand_path('../..', __dir__)
+    LIB = File.join(ROOT, 'lib')
+
+    class VersionError < StandardError; end
+
+    def release(version)
+      raise VersionError, "Missing version argument." if version.nil?
+      raise VersionError, "Version should be a string." unless version.is_a?(String)
+      raise VersionError, "Version should be a valid semver version." unless /^\d+\.\d+.\d+$/.match?(version)
+
+      update_docs(version)
+      update_version(version)
+    end
+
+    def update_version(version)
+      version_file_path = File.join(LIB, 'platformos_check/version.rb')
+      version_file = File.read(version_file_path)
+      updated_version_file = version_file.gsub(PlatformosCheck::VERSION, version)
+
+      return if updated_version_file == version_file
+
+      puts "Updating version to #{version} in #{version_file_path}."
+      File.write(version_file_path, updated_version_file)
+    end
+
+    def update_docs(version)
+      Dir[ROOT + '/docs/checks/*.md'].each do |filename|
+        doc_content = File.read(filename)
+        updated_doc_content = doc_content.gsub('PLATFORMOS_CHECK_VERSION', version)
+        next if updated_doc_content == doc_content
+
+        puts "Replacing `PLATFORMOS_CHECK_VERSION` with #{version} in #{Pathname.new(filename).relative_path_from(ROOT)}"
+        File.write(filename, updated_doc_content)
+      end
+    end
+  end
+end

data/lib/platformos_check/schema_file.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class SchemaFile < YamlFile
+  end
+end

data/lib/platformos_check/sms_file.rb

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

data/lib/platformos_check/storage.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class Storage
+    def path(relative_path)
+      raise NotImplementedError
+    end
+
+    def read(relative_path)
+      raise NotImplementedError
+    end
+
+    def write(relative_path, content)
+      raise NotImplementedError
+    end
+
+    def files
+      raise NotImplementedError
+    end
+
+    def directories
+      raise NotImplementedError
+    end
+
+    def versioned?
+      false
+    end
+  end
+end

data/lib/platformos_check/string_helpers.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module StringHelpers
+    extend self
+
+    # Removes the module part from the expression in the string.
+    # Ported from ActiveSupport
+    #
+    #   demodulize('ActiveSupport::Inflector::Inflections') # => "Inflections"
+    #   demodulize('Inflections')                           # => "Inflections"
+    #   demodulize('::Inflections')                         # => "Inflections"
+    #   demodulize('')                                      # => ""
+    #
+    # See also #deconstantize.
+    def demodulize(path)
+      path = path.to_s
+      if (i = path.rindex("::"))
+        path[(i + 2)..-1]
+      else
+        path
+      end
+    end
+
+    # Makes an underscored, lowercase form from the expression in the string.
+    # Base on ActiveSupport's
+    #
+    # Changes '::' to '/' to convert namespaces to paths.
+    #
+    #   underscore('ActiveModel')         # => "active_model"
+    #   underscore('ActiveModel::Errors') # => "active_model/errors"
+    #
+    # As a rule of thumb you can think of +underscore+ as the inverse of
+    # #camelize, though there are cases where that does not hold:
+    #
+    #   camelize(underscore('SSLError'))  # => "SslError"
+    def underscore(camel_cased_word)
+      return camel_cased_word unless /[A-Z-]|::/.match?(camel_cased_word)
+
+      word = camel_cased_word.to_s.gsub("::", "/")
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+  end
+end

data/lib/platformos_check/tags/background.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module Tags
+    class Background < Base
+      PARTIAL_SYNTAX = /(#{Liquid::VariableSignature}+)\s*=\s*(.*)\s*/om
+      CLOSE_TAG_SYNTAX = /\A(.*)(?-mix:\{%-?)\s*(\w+)\s*(.*)?(?-mix:%\})\z/m # based on Liquid::Raw::FullTokenPossiblyInvalid
+
+      attr_reader :to, :from, :attributes, :value_expr
+
+      def initialize(tag_name, markup, options)
+        if markup =~ PARTIAL_SYNTAX
+          super
+          @to = Regexp.last_match(1)
+          @partial_syntax = true
+
+          after_assign_markup = Regexp.last_match(2).split('|')
+          parse_markup(tag_name, after_assign_markup.shift)
+          after_assign_markup.unshift(@to)
+          @from = Liquid::Variable.new(after_assign_markup.join('|'), options)
+        else
+          @partial_syntax = false
+          parse_markup(tag_name, markup)
+          super
+        end
+      end
+
+      def parse(tokens)
+        return super if @partial_syntax
+
+        @body = +''
+        while (token = tokens.send(:shift))
+          if token =~ CLOSE_TAG_SYNTAX && block_delimiter == Regexp.last_match(2)
+            @body << Regexp.last_match(1) if Regexp.last_match(1) != ''
+            return
+          end
+          @body << token unless token.empty?
+        end
+
+        raise Liquid::SyntaxError, parse_context.locale.t('errors.syntax.tag_never_closed', block_name:)
+      end
+
+      def block_name
+        @tag_name
+      end
+
+      def block_delimiter
+        @block_delimiter = "end#{block_name}"
+      end
+
+      def parse_main_value(tag_name, markup)
+        raise Liquid::SyntaxError, "Invalid syntax for #{tag_name} tag" unless markup =~ syntax
+
+        @main_value = Regexp.last_match(1)
+        @value_expr = @main_value ? Liquid::Expression.parse(@main_value) : nil
+      end
+
+      class ParseTreeVisitor < Liquid::ParseTreeVisitor
+        def children
+          [
+            @node.to
+          ].compact + @node.attributes_expr.values
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/tags/base.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module Tags
+    class Base < Liquid::Tag
+      include BaseTagMethods
+
+      def initialize(tag_name, markup, parse_context)
+        super
+        parse_markup(tag_name, markup)
+      end
+    end
+  end
+end

data/lib/platformos_check/tags/base_block.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module Tags
+    class BaseBlock < Liquid::Block
+      include BaseTagMethods
+
+      def initialize(tag_name, markup, options)
+        super
+        parse_markup(tag_name, markup)
+      end
+    end
+  end
+end

data/lib/platformos_check/tags/base_tag_methods.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module Tags
+    module BaseTagMethods
+      SYNTAX = /(#{Liquid::QuotedFragment}+)(\s*(#{Liquid::QuotedFragment}+))?/o
+      # this is Liquid::TagAttributes with the beginnig changed from \w+ to [\w-] to allow for
+      # attributes like html-id: 10, which was identified as id: 10, but should be html-id: 10.
+      # In other words - allow hyphens in key names.
+      TAG_ATTRIBUTES = /([\w-]+)\s*:\s*((?-mix:(?-mix:"[^"]*"|'[^']*')|(?:[^\s,|'"]|(?-mix:"[^"]*"|'[^']*'))+))/
+      BACKWARDS_COMPATIBILITY_KEYS = %w[method].freeze
+
+      attr_reader :main_value, :attributes_expr, :value_expr, :duplicated_attrs
+
+      protected
+
+      def parse_markup(tag_name, markup)
+        @remaining_markup = markup
+
+        parse_main_value(tag_name, markup)
+        parse_attributes(@remaining_markup)
+      end
+
+      def parse_main_value(tag_name, markup)
+        raise Liquid::SyntaxError, "Invalid syntax for #{tag_name} tag" unless markup =~ syntax
+
+        @main_value = Regexp.last_match(1)
+        @remaining_markup = markup[Regexp.last_match.end(1)..-1] if @main_value
+
+        @value_expr = @main_value ? Liquid::Expression.parse(@main_value) : nil
+      end
+
+      def parse_attributes(markup)
+        @attributes_expr = {}
+        @duplicated_attrs = []
+
+        markup.scan(TAG_ATTRIBUTES) do |key, value|
+          unless well_formed_object_access?(value)
+            raise Liquid::SyntaxError,
+                  'Invalid syntax for function tag, no spaces allowed when accessing array or hash.'
+          end
+
+          @duplicated_attrs << key if @attributes_expr.key?(key)
+          @attributes_expr[key] = Liquid::Expression.parse(value)
+        end
+      end
+
+      def well_formed_object_access?(representation)
+        return false if /\[\z/.match?(representation.to_s)
+
+        true
+      end
+
+      def syntax
+        SYNTAX
+      end
+    end
+  end
+end

data/lib/platformos_check/tags/cache.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module Tags
+    class Cache < BaseBlock
+      class ParseTreeVisitor < Liquid::ParseTreeVisitor
+        def children
+          super + [@node.value_expr].compact + @node.attributes_expr.values
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/tags/export.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module Tags
+    class Export < Liquid::Tag
+      SYNTAX = /\A([\w-]+[\s,]*[\w\s,]*)\s*(namespace:\s*(.+))?\z/
+
+      attr_reader :namespace, :variables
+
+      def initialize(tag_name, markup, options)
+        super
+        raise Liquid::SyntaxError, "Syntax Error in 'export' - Valid syntax: export [var1], [var2], ..., namespace: [namespace]" unless markup =~ SYNTAX
+
+        @variables = Regexp.last_match(1).split(',').map { |v| Liquid::Expression.parse(v) }
+        @namespace = Liquid::Expression.parse(Regexp.last_match(3)&.strip)
+      end
+
+      def parse_main_value(_tag_name, _markup); end
+
+      class ParseTreeVisitor < Liquid::ParseTreeVisitor
+        def children
+          @node.variables +
+            [
+              @node.namespace
+            ]
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/tags/form.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module Tags
+    class Form < BaseBlock
+      def initialize(tag_name, markup, tokens)
+        super
+        @tag_name = tag_name
+        @markup = markup
+        @model_name = markup.scan(::Liquid::QuotedFragment).flatten.first
+        # we want to allow {% form method: delete %}, but also {% form form, method: delete %}
+        @model_name = 'form' if @model_name.nil? || @model_name == '' || @model_name[-1] == ':'
+        parse_attributes(markup)
+      end
+
+      def parse_main_value(_tag_name, _markup); end
+    end
+  end
+end

data/lib/platformos_check/tags/function.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module Tags
+    class Function < Base
+      # SYNTAX_HASH @to is the same as for hash_assign tag, but with mandatory brackets
+      SYNTAX_HASH = %r{((\(?[\w\-.]\)?)+)(\[.+\])+\s*=\s*([\w/\-."']+)\s*(.*)}om
+      # SYNTAX_VARIABLE @to is the original Liquid::VariableSignature but with bracket
+      # characters removed
+      SYNTAX_VARIABLE = %r{((?-mix:\(?[\w\-.]\)?)+)\s*=\s*([\w/\-."']+)\s*(.*)}om
+
+      attr_reader :to, :from, :attributes
+
+      def initialize(tag_name, markup, options)
+        super
+        if markup =~ SYNTAX_VARIABLE
+          @to = Regexp.last_match(1)
+          @from = Liquid::Expression.parse(Regexp.last_match(2))
+          # Rest of markup contains only the function parameters, an improvement made in
+          # another PR as well, to avoid other parts of the markup containing special
+          # characters from conflicting with ::Liquify::Tags::BaseTagMethods::TAG_ATTRIBUTES
+          @rest_of_markup = Regexp.last_match(3)
+
+          @assign_type = :variable
+        elsif markup =~ SYNTAX_HASH
+          @to = Regexp.last_match(1)
+          # No longer checking there is hash access as it's mandatory in the Regex
+          @from = Liquid::Expression.parse(Regexp.last_match(4))
+          @keys = parse_raw_keys(Regexp.last_match(3))
+          @rest_of_markup = Regexp.last_match(5)
+
+          @assign_type = :hash
+        else
+          raise Liquid::SyntaxError, 'Invalid syntax for function tag'
+        end
+
+        @attributes = {}
+        @rest_of_markup.scan(::PlatformosCheck::Tags::Base::TAG_ATTRIBUTES) do |key, value|
+          unless well_formed_object_access?(value)
+            raise Liquid::SyntaxError,
+                  'Invalid syntax for function tag, no spaces allowed when accessing array or hash.'
+          end
+
+          @attributes[key] = Liquid::Expression.parse(value)
+        end
+      end
+
+      class ParseTreeVisitor < Liquid::ParseTreeVisitor
+        def children
+          [
+            @node.from,
+            @node.main_value
+          ] + @node.attributes_expr.values
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/tags/graphql.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module Tags
+    class Graphql < Base
+      QUERY_NAME_SYNTAX = /(#{Liquid::VariableSignature}+)\s*=\s*(.*)\s*/om
+      INLINE_SYNTAX = /(#{Liquid::QuotedFragment}+)(\s*(#{Liquid::QuotedFragment}+))?/o
+      CLOSE_TAG_SYNTAX = /\A(.*)(?-mix:\{%-?)\s*(\w+)\s*(.*)?(?-mix:%\})\z/m # based on Liquid::Raw::FullTokenPossiblyInvalid
+
+      attr_reader :to, :from, :inline_query, :value_expr, :partial_name, :attributes_expr, :attributes
+
+      def initialize(tag_name, markup, options)
+        super
+        if markup =~ QUERY_NAME_SYNTAX
+          @to = Regexp.last_match(1)
+          @inline_query = false
+
+          # inline query looks like this:
+          # {% graph res = "my_query", id: "1" | dig: 'my_query' %}
+          # we want to first process "my_query, id: "1" , store it in "res" and then process
+          # it with filters like this:
+          # res | dig: 'my_query'
+          after_assign_markup = Regexp.last_match(2).split('|')
+          parse_markup(tag_name, after_assign_markup.shift)
+          @attributes = attributes_expr.keys
+
+          after_assign_markup.unshift(@to)
+          @partial_name = value_expr
+          @from = Liquid::Variable.new(after_assign_markup.join('|'), options)
+        elsif INLINE_SYNTAX.match?(markup)
+          @inline_query = true
+          parse_markup(tag_name, markup)
+          @attributes = attributes_expr.keys
+          @to = @value_expr.name
+        else
+          raise Liquid::SyntaxError, 'Invalid syntax for graphql tag'
+        end
+      end
+
+      def parse(tokens)
+        return super unless @inline_query
+
+        @body = +''
+        while (token = tokens.send(:shift))
+          if token =~ CLOSE_TAG_SYNTAX && block_delimiter == Regexp.last_match(2)
+            @body << Regexp.last_match(1) if Regexp.last_match(1) != ''
+            return
+          end
+          @body << token unless token.empty?
+        end
+
+        raise Liquid::SyntaxError, parse_context.locale.t('errors.syntax.tag_never_closed', block_name:)
+      end
+
+      def block_name
+        @tag_name
+      end
+
+      def block_delimiter
+        @block_delimiter = "end#{block_name}"
+      end
+
+      class ParseTreeVisitor < Liquid::ParseTreeVisitor
+        def children
+          [@node.to].compact + @node.attributes_expr.values
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/tags/hash_assign.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module Tags
+    class HashAssign < Base
+      SYNTAX = /((\(?[\w\-.]\)?)+)(\[.+\])*\s*=\s*(\S.*)\s*/om
+      KEYS = /[\w\-"'.]+/
+
+      attr_reader :keys, :to, :from
+
+      def initialize(tag_name, markup, options)
+        super
+        raise Liquid::SyntaxError, "Syntax Error in 'hash_assign' - Valid syntax: hash_assign hash[key] = value" unless markup =~ SYNTAX
+
+        @to = Regexp.last_match(1)
+        @from = Liquid::Variable.new(Regexp.last_match(4), options)
+        raw_keys = Regexp.last_match(3)
+        raise Liquid::SyntaxError, "Syntax Error in 'hash_assign' - Valid syntax: hash_assign hash[key] = value" unless raw_keys
+
+        @keys = parse_raw_keys(raw_keys)
+      end
+
+      # raw_keys can be something like
+      # "[item2][ item[0] ]['mich][ael']"
+      def parse_raw_keys(raw_keys)
+        nesting_level = 0
+        keys = []
+        current_key = ''
+        in_double_quote = false
+        in_single_quote = false
+        raw_keys.each_char do |char|
+          case char
+          when '['
+            if !in_double_quote && !in_single_quote
+              nesting_level += 1
+              current_key += char if nesting_level > 1
+            else
+              current_key += char
+            end
+          when ']'
+            if !in_double_quote && !in_single_quote
+              nesting_level -= 1
+              if nesting_level.zero?
+                keys << Liquid::Expression.parse(current_key)
+                current_key = ''
+              else
+                current_key += char
+              end
+            else
+              current_key += char
+            end
+          when '"'
+            in_double_quote = !in_double_quote unless in_single_quote
+            current_key += char
+          when "'"
+            in_single_quote = !in_single_quote unless in_double_quote
+            current_key += char
+          else
+            current_key += char
+          end
+        end
+
+        keys
+      end
+
+      class ParseTreeVisitor < Liquid::ParseTreeVisitor
+        def children
+          [
+            @node.from
+          ] + @node.keys
+        end
+      end
+    end
+  end
+end