platformos-check 0.0.1

data/lib/platformos_check/config.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class Config
+    DOTFILE = '.platformos-check.yml'
+    BUNDLED_CONFIGS_DIR = Pathname.new("#{__dir__}/../../config").realpath
+    BOOLEAN = [true, false]
+
+    attr_reader :root
+    attr_accessor :auto_correct
+
+    class << self
+      attr_reader :last_loaded_config
+
+      def from_path(path)
+        if (filename = find(path))
+          new(root: filename.dirname, configuration: load_config(filename))
+        else
+          # No configuration file
+          new(root: path)
+        end
+      end
+
+      def from_string(config)
+        new(configuration: YAML.load(config), should_resolve_requires: false)
+      end
+
+      def from_hash(config)
+        new(configuration: config, should_resolve_requires: false)
+      end
+
+      def find(root, needle = DOTFILE)
+        Pathname.new(root).descend.reverse_each do |path|
+          pathname = path.join(needle)
+          return pathname if pathname.exist?
+        end
+        nil
+      end
+
+      def load_file(absolute_path)
+        @last_loaded_config = absolute_path
+        # An empty file returns false, so we || {}.
+        YAML.load_file(absolute_path) || {}
+      end
+
+      def bundled_config_path(name)
+        "#{BUNDLED_CONFIGS_DIR}/#{name.to_s.sub(/^:/, '')}.yml"
+      end
+
+      def bundled_config?(name)
+        name.is_a?(Symbol) || (name.is_a?(String) && name[0] == ":")
+      end
+
+      def load_bundled_config(name)
+        load_file(bundled_config_path(name))
+      end
+
+      def load_config(name, pwd = Pathname.pwd)
+        return load_bundled_config(name) if bundled_config?(name)
+
+        path = name.is_a?(Pathname) ? name : Pathname.new(name)
+        path = pwd.join(path) if path.relative?
+        return {} unless path.exist?
+
+        config = load_file(path)
+        extends = config["extends"] || :default
+        merge_configurations!(load_config(extends, path.realpath.dirname), config)
+      end
+
+      def merge_configurations!(config, other)
+        config.merge(other) do |_key, old_value, new_value|
+          case old_value
+          when Hash
+            merge_configurations!(old_value, new_value)
+          else
+            new_value
+          end
+        end
+      end
+
+      def default
+        load_config(":default")
+      end
+    end
+
+    def initialize(root: nil, configuration: nil, should_resolve_requires: true)
+      @configuration = if configuration
+                         validate_configuration(configuration)
+                       else
+                         self.class.default
+                       end
+
+      extends = @configuration["extends"] || :default
+      @configuration = self.class.merge_configurations!(self.class.load_config(extends), @configuration)
+
+      @root = if root && @configuration.key?("root")
+                Pathname.new(root).join(@configuration["root"])
+              elsif root
+                Pathname.new(root)
+              end
+
+      @auto_correct = false
+
+      resolve_requires if @root && should_resolve_requires
+    end
+
+    def [](name)
+      @configuration[name]
+    end
+
+    def to_h
+      @configuration
+    end
+
+    def check_configurations
+      @check_configurations ||= @configuration.select { |name, _| check_name?(name) }
+    end
+
+    def enabled_checks
+      @enabled_checks ||= check_configurations.map do |check_name, options|
+        next unless options["enabled"]
+
+        check_class = PlatformosCheck.const_get(check_name)
+
+        next if check_class.categories.any? { |category| exclude_categories.include?(category) }
+        next if include_categories.any? && !include_categories.all? { |category| check_class.categories.include?(category) }
+
+        options_for_check = options.transform_keys(&:to_sym)
+        options_for_check.delete(:enabled)
+        severity = options_for_check.delete(:severity)
+        check_ignored_patterns = options_for_check.delete(:ignore) || []
+        check = if options_for_check.empty?
+                  check_class.new
+                else
+                  check_class.new(**options_for_check)
+                end
+        check.severity = severity.to_sym if severity
+        check.ignored_patterns = check_ignored_patterns + ignored_patterns
+        check.options = options_for_check
+        check
+      end.compact
+    end
+
+    def ignored_patterns
+      self["ignore"] || []
+    end
+
+    def include_categories
+      self["include_categories"] || []
+    end
+
+    def include_categories=(categories)
+      @configuration["include_categories"] = categories
+    end
+
+    def exclude_categories
+      self["exclude_categories"] || []
+    end
+
+    def exclude_categories=(categories)
+      @configuration["exclude_categories"] = categories
+    end
+
+    private
+
+    def check_name?(name)
+      name.to_s.start_with?(/[A-Z]/)
+    end
+
+    def validate_configuration(configuration, default_configuration = self.class.default, parent_keys = [])
+      valid_configuration = {}
+
+      configuration.each do |key, value|
+        # No validation possible unless we have a default to compare to
+        unless default_configuration
+          valid_configuration[key] = value
+          next
+        end
+
+        default = default_configuration[key]
+        keys = parent_keys + [key]
+        name = keys.join(".")
+
+        if check_name?(key)
+          if value.is_a?(Hash)
+            valid_configuration[key] = validate_configuration(value, default, keys)
+          else
+            warn("bad configuration type for #{name}: expected a Hash, got #{value.inspect}")
+          end
+        elsif key == "extends"
+          if value.is_a?(Symbol) || value.is_a?(String)
+            valid_configuration[key] = value
+          else
+            warn("bad configuration type for extends: expected a Symbol or a String, got #{value.inspect}")
+          end
+        elsif key == "severity"
+          valid_configuration[key] = value
+        elsif default.nil?
+          warn("unknown configuration: #{name}")
+        elsif BOOLEAN.include?(default) && !BOOLEAN.include?(value)
+          warn("bad configuration type for #{name}: expected true or false, got #{value.inspect}")
+        elsif !BOOLEAN.include?(default) && default.class != value.class
+          warn("bad configuration type for #{name}: expected a #{default.class}, got #{value.inspect}")
+        else
+          valid_configuration[key] = value
+        end
+      end
+
+      valid_configuration
+    end
+
+    def resolve_requires
+      self["require"]&.each do |path|
+        file_to_require = @root.join(path).realpath
+        require(file_to_require.to_s)
+      end
+    end
+  end
+end

data/lib/platformos_check/config_file.rb

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

data/lib/platformos_check/corrector.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class Corrector
+    include JsonHelpers
+
+    def initialize(app_file:)
+      @app_file = app_file
+    end
+
+    def insert_after(node, content, character_range = nil)
+      @app_file.rewriter.insert_after(node, content, character_range)
+    end
+
+    def insert_before(node, content, character_range = nil)
+      @app_file.rewriter.insert_before(node, content, character_range)
+    end
+
+    def remove(node)
+      @app_file.rewriter.remove(node)
+    end
+
+    def replace(node, content, character_range = nil)
+      @app_file.rewriter.replace(node, content, character_range)
+      node.markup = content
+    end
+
+    def replace_inner_markup(node, content)
+      @app_file.rewriter.replace_inner_markup(node, content)
+    end
+
+    def replace_inner_json(node, json, **)
+      replace_inner_markup(node, pretty_json(json, **))
+    end
+
+    def wrap(node, insert_before, insert_after)
+      @app_file.rewriter.wrap(node, insert_before, insert_after)
+    end
+
+    def create_file(storage, relative_path, content)
+      storage.write(relative_path, content)
+    end
+
+    def remove_file(storage, relative_path)
+      storage.remove(relative_path)
+    end
+
+    def mkdir(storage, relative_path)
+      storage.mkdir(relative_path)
+    end
+
+    # def rename(storage, old_path, new_path)
+    #   storage.rename(old_path, new_path)
+    # end
+
+    def add_translation(json_file, path, value)
+      hash = json_file.content
+      JsonHelper.set(hash, path, value)
+      json_file.update_contents(hash)
+    end
+
+    def remove_translation(json_file, path)
+      hash = json_file.content
+      JsonHelper.delete(hash, path)
+      json_file.update_contents(hash)
+    end
+  end
+end

data/lib/platformos_check/disabled_check.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# This class keeps track of checks being turned on and off in ranges.
+# We'll use the node position to figure out if the test is disabled or not.
+module PlatformosCheck
+  class DisabledCheck
+    attr_reader :name, :app_file, :ranges
+    attr_accessor :first_line
+
+    def initialize(app_file, name)
+      @app_file = app_file
+      @name = name
+      @ranges = []
+      @first_line = false
+    end
+
+    def start_index=(index)
+      return unless ranges.empty? || !last.end.nil?
+
+      @ranges << (index..)
+    end
+
+    def end_index=(index)
+      return if ranges.empty? || !last.end.nil?
+
+      @ranges << (@ranges.pop.begin..index)
+    end
+
+    def disabled?(index)
+      (index == 0 && first_line) ||
+        ranges.any? { |range| range.cover?(index) }
+    end
+
+    def last
+      ranges.last
+    end
+
+    def missing_end_index?
+      return false if first_line && ranges.size == 1
+
+      last&.end.nil?
+    end
+  end
+end

data/lib/platformos_check/disabled_checks.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class DisabledChecks
+    DISABLE_START = 'platformos-check-disable'
+    DISABLE_END = 'platformos-check-enable'
+    DISABLE_PREFIX_PATTERN = /#{DISABLE_START}|#{DISABLE_END}/
+
+    ACTION_DISABLE_CHECKS = :disable
+    ACTION_ENABLE_CHECKS = :enable
+
+    def initialize
+      @disabled_checks = Hash.new do |hash, key|
+        app_file, check_name = key
+        hash[key] = DisabledCheck.new(app_file, check_name)
+      end
+    end
+
+    def update(node)
+      text = comment_text(node)
+      if start_disabling?(text)
+        checks_from_text(text).each do |check_name|
+          disabled = @disabled_checks[[node.app_file, check_name]]
+          disabled.start_index = node.start_index
+          disabled.first_line = true if node.line_number == 1
+        end
+      elsif stop_disabling?(text)
+        checks_from_text(text).each do |check_name|
+          disabled = @disabled_checks[[node.app_file, check_name]]
+          next unless disabled
+
+          disabled.end_index = node.end_index
+        end
+      else
+        # We want to disable checks inside comments
+        # (e.g. html checks inside {% comment %})
+        disabled = @disabled_checks[[node.app_file, :all]]
+        unless disabled.first_line
+          disabled.start_index = node.inner_markup_start_index
+          disabled.end_index = node.inner_markup_end_index
+        end
+      end
+    end
+
+    def disabled?(check, app_file, check_name, index)
+      return true if check.ignored_patterns&.any? do |pattern|
+        app_file&.relative_path&.fnmatch?(pattern)
+      end
+
+      @disabled_checks[[app_file, :all]]&.disabled?(index) ||
+        @disabled_checks[[app_file, check_name]]&.disabled?(index)
+    end
+
+    def checks_missing_end_index
+      @disabled_checks.values
+                      .select(&:missing_end_index?)
+                      .map(&:name)
+    end
+
+    def remove_disabled_offenses(checks)
+      checks.disableable.each do |check|
+        check.offenses.reject! do |offense|
+          disabled?(check, offense.app_file, offense.code_name, offense.start_index)
+        end
+      end
+    end
+
+    private
+
+    def comment_text(node)
+      case node.type_name
+      when :comment
+        node.value.nodelist.join
+      when :inline_comment
+        node.markup.sub(/\s*#+\s*/, '')
+      end
+    end
+
+    def start_disabling?(text)
+      text.strip.start_with?(DISABLE_START)
+    end
+
+    def stop_disabling?(text)
+      text.strip.start_with?(DISABLE_END)
+    end
+
+    # Return a list of checks from a platformos-check-disable comment
+    # Returns [:all] if all checks are meant to be disabled
+    def checks_from_text(text)
+      checks = text.gsub(DISABLE_PREFIX_PATTERN, '').strip.split(',').map(&:strip)
+      return [:all] if checks.empty?
+
+      checks
+    end
+  end
+end

data/lib/platformos_check/email_file.rb

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

data/lib/platformos_check/exceptions.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module PlatformosCheck
+  TIMEOUT_EXCEPTIONS = [
+    Net::ReadTimeout,
+    Net::OpenTimeout,
+    Net::WriteTimeout,
+    Errno::ETIMEDOUT,
+    Timeout::Error
+  ]
+
+  CONNECTION_EXCEPTIONS = [
+    IOError,
+    EOFError,
+    SocketError,
+    Errno::EINVAL,
+    Errno::ECONNRESET,
+    Errno::ECONNABORTED,
+    Errno::EPIPE,
+    Errno::ECONNREFUSED,
+    Errno::EAGAIN,
+    Errno::EHOSTUNREACH,
+    Errno::ENETUNREACH,
+    Errno::EADDRNOTAVAIL
+  ]
+
+  NET_HTTP_EXCEPTIONS = [
+    Net::HTTPBadResponse,
+    Net::HTTPHeaderSyntaxError,
+    Net::ProtocolError,
+    *TIMEOUT_EXCEPTIONS,
+    *CONNECTION_EXCEPTIONS
+  ]
+end

data/lib/platformos_check/file_system_storage.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module PlatformosCheck
+  class FileSystemStorage < Storage
+    attr_reader :root
+
+    def initialize(root, ignored_patterns: [])
+      @root = Pathname.new(root)
+      @ignored_patterns = ignored_patterns
+      @files = {}
+    end
+
+    def relative_path(absolute_path)
+      Pathname.new(absolute_path).relative_path_from(@root).to_s
+    end
+
+    def path(relative_path)
+      @root.join(relative_path)
+    end
+
+    def read(relative_path)
+      file(relative_path).read(mode: 'rb', encoding: 'UTF-8')
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def write(relative_path, content)
+      reset_memoizers unless file_exists?(relative_path)
+
+      file(relative_path).dirname.mkpath unless file(relative_path).dirname.directory?
+      file(relative_path).write(content, mode: 'w+b', encoding: 'UTF-8')
+    end
+
+    def remove(relative_path)
+      file(relative_path).delete
+      reset_memoizers
+    end
+
+    def mkdir(relative_path)
+      return if file_exists?(relative_path)
+
+      reset_memoizers
+      file(relative_path).mkpath
+    end
+
+    # TODO: Fix corrector
+    # def rename(old_path, new_path)
+    #   return unless file_exists?(old_path)
+    #
+    #   reset_memoizers
+    #
+    #   file(old_path).mv(new_path)
+    # end
+
+    def files
+      @file_array ||= glob("**/*")
+                      .reject { |path| File.directory?(path) }
+                      .map { |path| path.relative_path_from(@root).to_s }
+    end
+
+    def directories
+      @directories ||= glob('**/')
+                       .select { |f| File.directory?(f) }
+                       .map { |f| f.relative_path_from(@root).to_s }
+    end
+
+    private
+
+    def file_exists?(relative_path)
+      !!@files[relative_path]
+    end
+
+    def reset_memoizers
+      @file_array = nil
+      @directories = nil
+    end
+
+    def glob(pattern)
+      @root.glob(pattern).reject do |path|
+        relative_path = path.relative_path_from(@root)
+        @ignored_patterns.any? { |ignored| relative_path.fnmatch?(ignored) }
+      end
+    end
+
+    def file(name)
+      return @files[name] if @files[name]
+
+      @files[name] = root.join(name)
+    end
+  end
+end

data/lib/platformos_check/graphql_file.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'graphql'
+
+module PlatformosCheck
+  class GraphqlFile < AppFile
+    DIR_PREFIX = %r{\A/?((marketplace_builder|app)/(graph_queries|graphql)s?/|modules/((\w|-)*)/(private|public)/(graph_queries|graphql)s?/)}
+
+    def write
+      content = rewriter.to_s
+      return unless source != content
+
+      @storage.write(@relative_path, content.gsub("\n", @eol))
+      @source = content
+      @rewriter = nil
+    end
+
+    def rewriter
+      @rewriter ||= AppFileRewriter.new(@relative_path, source)
+    end
+
+    def dir_prefix
+      DIR_PREFIX
+    end
+
+    def source_excerpt(line)
+      original_lines = source.split("\n")
+      original_lines[bounded(0, line - 1, original_lines.size - 1)].strip
+    rescue StandardError => e
+      PlatformosCheck.bug(<<~EOS)
+        Exception while running `source_excerpt(#{line})`:
+        ```
+        #{e.class}: #{e.message}
+          #{e.backtrace.join("\n  ")}
+        ```
+
+        path: #{path}
+
+        source:
+        ```
+        #{source}
+        ```
+      EOS
+    end
+
+    def parse
+      @parse ||= GraphQL.parse(source)
+    end
+
+    def warnings
+      @ast.warnings
+    end
+
+    def root
+      parse.root
+    end
+
+    def self.parse(_source)
+      Struct.new(:warnings, :root)
+    end
+
+    private
+
+    def bounded(lower, x, upper)
+      [lower, [x, upper].min].max
+    end
+  end
+end

data/lib/platformos_check/html_check.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class HtmlCheck < Check
+    extend ChecksTracking
+    START_OR_END_QUOTE = /(^['"])|(['"]$)/
+  end
+end