leftovers 0.2.2 → 0.4.2

data/lib/leftovers/config.rb

@@ -1,21 +1,16 @@
 # frozen_string_literal: true
 
 require 'yaml'
-require_relative 'rule'
 
 module Leftovers
   class Config
     # :nocov:
-    using ::Leftovers::YAMLSymbolizeNames if defined?(::Leftovers::YAMLSymbolizeNames)
+    using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
     # :nocov:
 
     attr_reader :name
 
-    def initialize(
-      name,
-      path: ::File.join(__dir__, '..', 'config', "#{name}.yml"),
-      content: (::File.exist?(path) ? ::File.read(path) : '')
-    )
+    def initialize(name, path: nil, content: nil)
       @name = name.to_sym
       @path = path
       @content = content
@@ -37,17 +32,47 @@ module Leftovers
       @test_paths ||= Array(yaml[:test_paths])
     end
 
-    def rules
-      @rules ||= Rule.wrap(yaml[:rules])
+    def dynamic
+      @dynamic ||= ::Leftovers::ProcessorBuilders::Dynamic.build(yaml[:dynamic])
+    end
+
+    def keep
+      @keep ||= ::Leftovers::MatcherBuilders::Node.build(yaml[:keep])
+    end
+
+    def test_only
+      @test_only ||= ::Leftovers::MatcherBuilders::Node.build(yaml[:test_only])
+    end
+
+    def requires
+      @requires ||= Array(yaml[:requires])
     end
 
     private
 
+    def content
+      @content ||= ::File.exist?(path) ? ::File.read(path) : ''
+    end
+
+    def path
+      @path ||= ::File.expand_path("../config/#{name}.yml", __dir__)
+    end
+
     def yaml
-      @yaml ||= YAML.safe_load(@content, symbolize_names: true) || {}
-    rescue Psych::SyntaxError => e
-      warn "\e[31mError with config #{path}: #{e.message}\e[0m"
-      exit 1
+      @yaml ||= ::Leftovers::ConfigValidator.validate_and_process!(parse_yaml, path)
+    end
+
+    def parse_yaml
+      # :nocov:
+      if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.6')
+        Psych.safe_load(content, filename: path) || {}
+      else
+        Psych.safe_load(content, [], [], false, path) || {}
+      end
+      # :nocov:
+    rescue ::Psych::SyntaxError => e
+      warn "\e[31mConfig SyntaxError: #{e.message}\e[0m"
+      Leftovers.exit 1
     end
   end
 end

data/lib/leftovers/config_validator.rb

@@ -0,0 +1,60 @@
+# frozen-string-literal: true
+
+require 'json_schemer'
+
+module Leftovers
+  module ConfigValidator
+    autoload(:ErrorProcessor, "#{__dir__}/config_validator/error_processor")
+    autoload(:SCHEMA_HASH, "#{__dir__}/config_validator/schema_hash")
+
+    def self.default_schema
+      @default_schema ||= ::JSONSchemer.schema(::Leftovers::ConfigValidator::SCHEMA_HASH)
+    end
+
+    def self.validate(obj, validator = default_schema)
+      validator.validate(obj)
+    end
+
+    def self.validate_and_process!(yaml, path)
+      errors = validate(yaml)
+      print_validation_errors_and_exit(errors, path) unless errors.first.nil?
+      post_process!(yaml)
+    end
+
+    def self.print_validation_errors_and_exit(errors, path)
+      ::Leftovers::ConfigValidator::ErrorProcessor.process(errors).each do |message|
+        warn "\e[31mConfig SchemaError: (#{path}): #{message}\e[0m"
+      end
+
+      ::Leftovers.exit 1
+    end
+
+    def self.post_process!(obj)
+      case obj
+      when Hash
+        obj.keys.each do |key| # rubocop:disable Style/HashEachMethods # each_key never finishes.
+          obj[symbolize_name(key)] = post_process!(obj.delete(key))
+        end
+      when Array
+        obj.map! { |ea| post_process!(ea) }
+      end
+      obj
+    end
+
+    def self.symbolize_name(name) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+      case name
+      when 'matches' then :match
+      when 'defines' then :define
+      when 'calls' then :call
+      when 'name' then :names
+      when 'keyword' then :keywords
+      when 'argument' then :arguments
+      when 'has_argument' then :has_arguments
+      when 'path' then :paths
+      when 'unless' then :unless_arg
+      when 'require' then :requires
+      else name.to_sym
+      end
+    end
+  end
+end

data/lib/leftovers/config_validator/error_processor.rb

@@ -0,0 +1,196 @@
+# frozen-string-literal: true
+
+::Leftovers.try_require 'did_you_mean'
+
+module Leftovers
+  module ConfigValidator
+    module ErrorProcessor # rubocop:disable Metrics/ModuleLength
+      LENGTH_TYPE = %w{minItems minLength minProperties}.freeze
+      TYPE_TYPE = %w{null string boolean integer number array object}.freeze
+      VALUE_TYPE = %w{enum const}.freeze
+      REQUIRED_TYPE = %w{required}.freeze
+
+      class << self
+        def process(errors) # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/AbcSize
+          error_data_pointers = []
+          errors = group_errors(errors)
+          errors.flat_map do |data_pointer, error_group| # rubocop:disable Metrics/BlockLength
+            next if error_data_pointers.find { |x| x.start_with?(data_pointer) }
+
+            # original_error_group = error_group.dup
+            length_errors = error_group.select { |x| LENGTH_TYPE.include?(x['type']) }
+            value_errors = error_group.select { |x| VALUE_TYPE.include?(x['type']) }
+            type_errors = error_group.select { |x| TYPE_TYPE.include?(x['type']) }
+            required_errors = error_group.select { |x| REQUIRED_TYPE.include?(x['type']) }
+            messages = []
+
+            if !type_errors.empty? && (error_group - type_errors).empty?
+              error_group -= type_errors
+              error_data_pointers << data_pointer
+              any_of = group_by_same_any_of(type_errors)
+              if any_of.length == 1
+                was_class = to_json_type(type_errors.first['data'])
+                error_types = type_errors.map { |x| x['type'] }
+
+                messages << <<~MESSAGE.chomp
+                  #{data_pointer}: must be #{an to_sentence(error_types, 'or')} (was #{an was_class})
+                MESSAGE
+                # :nocov:
+              else
+                nil
+                # :nocov:
+              end
+            elsif !required_errors.empty? && error_group.first['data'].is_a?(Hash)
+              error_data_pointers << data_pointer
+              group_by_same_any_of(required_errors).each do |_any_of_key, any_of_value|
+                required_keywords = any_of_value.flat_map { |x| x['details']['missing_keys'] }
+                error_group -= any_of_value
+                if any_of_value.length > 1
+                  messages << <<~MESSAGE
+                    #{data_pointer}: requires at least one of these keywords: #{to_sentence(required_keywords, 'or')}
+                  MESSAGE
+
+                  # :nocov:
+                else
+                  nil
+                  # :nocov:
+                  # messages << "#{data_pointer}: requires keyword: #{required_keywords.first}"
+                end
+              end
+            elsif !length_errors.empty?
+              error_data_pointers << data_pointer
+              messages << "#{data_pointer}: can't be empty"
+            end
+
+            error_group.each do |error| # rubocop:disable Metrics/BlockLength
+              type = error['type']
+              case type
+              when 'schema'
+                error_data_pointers << data_pointer
+                parent_pointer = parent(data_pointer)
+                if ::File.basename(error['schema_pointer']) == 'additionalProperties'
+                  keyword = tail(data_pointer)
+                  parent_schema_pointer = parent(error['schema_pointer'])
+                  actual_keywords = schema_hash_dig(parent_schema_pointer)['properties'].keys
+                  corrections = did_you_mean(keyword, actual_keywords)
+
+                  messages << <<~MESSAGE.chomp
+                    #{parent_pointer}: invalid property keyword: #{keyword}
+                    Valid keywords: #{to_sentence actual_keywords}
+                    #{"Did you mean? #{to_sentence corrections, 'or'}" unless corrections.empty?}
+                  MESSAGE
+                  # :nocov:
+                else
+                  nil
+                  # :nocov:
+                end
+              when 'enum'
+                next if error['data'].is_a?(Hash)
+
+                error_data_pointers << data_pointer
+                given_value = error['data']
+                valid_values = value_errors.first['schema']['enum']
+                corrections = did_you_mean(given_value, valid_values)
+                messages << <<~MESSAGE
+                  #{data_pointer}: can't be: #{given_value}
+                  Valid values: #{to_sentence valid_values, 'or'}
+                  #{"Did you mean? #{to_sentence corrections, 'or'}" unless corrections.empty?}
+                MESSAGE
+              when 'not'
+                next unless error['data'].is_a?(Hash)
+
+                error_data_pointers << data_pointer
+                if error['schema']['required']
+                  invalid_combinations = error['schema']['required'] & error['data'].keys
+                  messages << <<~MESSAGE
+                    #{data_pointer}: use only one of: #{to_sentence invalid_combinations, 'or'}
+                  MESSAGE
+                  # :nocov:
+                else
+                end
+              else
+              end
+              # :nocov:
+            end
+
+            if messages.empty?
+              error_data_pointers << data_pointer
+              "#{data_pointer} is invalid"
+            else
+              messages
+            end
+          end.compact.map(&:strip)
+        end
+
+        private
+
+        def did_you_mean(word, dictionary)
+          # :nocov:
+          if defined?(::DidYouMean::SpellChecker)
+            ::DidYouMean::SpellChecker.new(dictionary: dictionary).correct(word)
+          else
+            []
+          end
+          # :nocov:
+        end
+
+        def schema_hash_dig(schema_pointer)
+          ::Leftovers::ConfigValidator::SCHEMA_HASH.dig(
+            *schema_pointer.split('/').drop(1).map { |x| x.match?(/\A\d+\z/) ? x.to_i : x }
+          )
+        end
+
+        def parent(pointer)
+          ::File.dirname(pointer)
+        end
+
+        def tail(pointer)
+          ::File.basename(pointer)
+        end
+
+        def to_json_type(value)
+          case value
+          when Hash then 'object'
+          when Float then 'number'
+          when true, false then 'boolean'
+          when nil then 'null'
+          else value.class.name.downcase
+          end
+        end
+
+        def an(str)
+          case str[0]
+          # when nil then ""
+          when 'a', 'e', 'i', 'o', 'u' then "an #{str}"
+          else "a #{str}"
+          end
+        end
+
+        def to_sentence(ary, join_word = 'and')
+          case ary.length
+          when 1 then ary.first
+          when 2 then ary.join(" #{join_word} ")
+          else
+            ary = ary.dup
+            last = ary.pop(2)
+            [*ary, last.join(", #{join_word} ")].join(', ')
+          end
+        end
+
+        def group_errors(errors)
+          errors = errors.map do |x|
+            x.delete('root_schema')
+            x
+          end
+          errors.group_by { |x| x['data_pointer'] }.sort.reverse.to_h
+        end
+
+        def group_by_same_any_of(errors)
+          errors.group_by do |x|
+            x['schema_pointer'].match?(%r{/anyOf/\d+$}) && parent(parent(x['schema_pointer']))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/config_validator/schema_hash.rb

@@ -0,0 +1,496 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module ConfigValidator # rubocop:disable Metrics/ModuleLength
+    SCHEMA_HASH = {
+      '$schema' => 'http://json-schema.org/draft-06/schema#',
+      'type' => 'object',
+      'definitions' => {
+        'true' => { 'enum' => [true, 'true'] },
+        'string' => {
+          'type' => 'string',
+          'minLength' => 1
+        },
+        'stringPattern' => {
+          'type' => 'object',
+          'properties' => {
+            'match' => { '$ref' => '#/definitions/string' },
+            'matches' => { '$ref' => '#/definitions/string' },
+            'has_prefix' => { '$ref' => '#/definitions/string' },
+            'has_suffix' => { '$ref' => '#/definitions/string' }
+          },
+          'minProperties' => 0,
+          'additionalProperties' => true,
+          'allOf' => [
+            # synonyms
+            { 'not' => { 'required' => %w{match matches} } },
+            # incompatible groups
+            { 'not' => { 'required' => %w{match has_prefix} } },
+            { 'not' => { 'required' => %w{match has_suffix} } },
+            { 'not' => { 'required' => %w{matches has_prefix} } },
+            { 'not' => { 'required' => %w{matches has_suffix} } }
+          ]
+        },
+        'stringList' => {
+          'anyOf' => [
+            {
+              'type' => 'array',
+              'items' => { '$ref' => '#/definitions/string' },
+              'minItems' => 1,
+              'uniqueItems' => true
+            },
+            { '$ref' => '#/definitions/string' }
+          ]
+        },
+        'name' => {
+          'anyOf' => [
+            { '$ref' => '#/definitions/string' },
+            { 'allOf' => [
+              { '$ref' => '#/definitions/stringPattern' },
+              {
+                'type' => 'object',
+                'properties' => {
+                  'match' => true, 'matches' => true,
+                  'has_prefix' => true, 'has_suffix' => true,
+                  'unless' => { '$ref' => '#/definitions/nameList' }
+                },
+                'minProperties' => 1,
+                'additionalProperties' => false
+              }
+            ] }
+          ]
+        },
+        'nameList' => {
+          'anyOf' => [
+            {
+              'type' => 'array',
+              'items' => { '$ref' => '#/definitions/name' },
+              'minItems' => 1,
+              'uniqueItems' => true
+            },
+            { '$ref' => '#/definitions/name' }
+          ]
+        },
+        'argumentPosition' => {
+          'anyOf' => [
+            { '$ref' => '#/definitions/string' },
+            { 'type' => 'integer', 'minimum' => 0 },
+            { '$ref' => '#/definitions/name' }
+          ]
+        },
+        'argumentPositionList' => {
+          'anyOf' => [
+            { '$ref' => '#/definitions/argumentPosition' },
+            {
+              'type' => 'array',
+              'items' => { '$ref' => '#/definitions/argumentPosition' },
+              'minItems' => 1,
+              'uniqueItems' => true
+            }
+          ]
+        },
+        'valueType' => {
+          'type' => 'string',
+          'enum' => %w{String Symbol Integer Float}
+        },
+        'valueTypeList' => {
+          'anyOf' => [
+            { '$ref' => '#/definitions/valueType' },
+            {
+              'type' => 'array',
+              'items' => { '$ref' => '#/definitions/valueType' },
+              'minItems' => 1,
+              'uniqueItems' => true
+            }
+          ]
+        },
+        'hasValue' => {
+          'anyOf' => [
+            { 'type' => 'string' },
+            { 'type' => 'integer' },
+            { 'type' => 'number' },
+            { 'type' => 'boolean' },
+            { 'type' => 'null' }
+          ]
+        },
+        'hasValueList' => {
+          'anyOf' => [
+            { '$ref' => '#/definitions/hasValue' },
+            {
+              'type' => 'array',
+              'items' => { '$ref' => '#/definitions/hasValue' },
+              'minItems' => 1,
+              'uniqueItems' => true
+            }
+          ]
+        },
+        'hasArgument' => {
+          'anyOf' => [
+            { '$ref' => '#/definitions/string' },
+            { 'type' => 'integer', 'minimum' => 0 },
+            {
+              'type' => 'object',
+              'properties' => {
+                'at' => { '$ref' => '#/definitions/argumentPositionList' },
+                'has_value' => { '$ref' => '#/definitions/hasValueList' },
+                'has_value_type' => { '$ref' => '#/definitions/valueTypeList' },
+                'unless' => { '$ref' => '#/definitions/hasArgumentList' }
+              },
+              'minProperties' => 1,
+              'additionalProperties' => false
+            }
+          ]
+        },
+        'hasArgumentList' => {
+          'anyOf' => [
+            { '$ref' => '#/definitions/hasArgument' },
+            {
+              'type' => 'array',
+              'items' => { '$ref' => '#/definitions/hasArgument' },
+              'minItems' => 1,
+              'uniqueItems' => true
+            }
+          ]
+        },
+        'rulePattern' => {
+          'type' => 'object',
+          'properties' => {
+            'name' => { '$ref' => '#/definitions/nameList' },
+            'names' => { '$ref' => '#/definitions/nameList' },
+            'path' => { '$ref' => '#/definitions/stringList' },
+            'paths' => { '$ref' => '#/definitions/stringList' },
+            'has_argument' => { '$ref' => '#/definitions/hasArgumentList' },
+            'has_arguments' => { '$ref' => '#/definitions/hasArgumentList' }
+          },
+          'minProperties' => 1,
+          'allOf' => [
+            # synonyms
+            { 'not' => { 'required' => %w{name names} } },
+            { 'not' => { 'required' => %w{path paths} } },
+            { 'not' => { 'required' => %w{has_argument has_arguments} } }
+          ]
+        },
+        'transformProperties' => {
+          'type' => 'object',
+          'properties' => {
+            'original' => { '$ref' => '#/definitions/true' },
+            'pluralize' => { '$ref' => '#/definitions/true' },
+            'singularize' => { '$ref' => '#/definitions/true' },
+            'camelize' => { '$ref' => '#/definitions/true' },
+            'camelcase' => { '$ref' => '#/definitions/true' },
+            'underscore' => { '$ref' => '#/definitions/true' },
+            'titleize' => { '$ref' => '#/definitions/true' },
+            'titlecase' => { '$ref' => '#/definitions/true' },
+            'demodulize' => { '$ref' => '#/definitions/true' },
+            'deconstantize' => { '$ref' => '#/definitions/true' },
+            'parameterize' => { '$ref' => '#/definitions/true' },
+            'downcase' => { '$ref' => '#/definitions/true' },
+            'upcase' => { '$ref' => '#/definitions/true' },
+            'capitalize' => { '$ref' => '#/definitions/true' },
+            'swapcase' => { '$ref' => '#/definitions/true' },
+
+            'add_prefix' => { '$ref' => '#/definitions/actionList' },
+            'add_suffix' => { '$ref' => '#/definitions/actionList' },
+
+            'split' => { '$ref' => '#/definitions/string' },
+            'delete_prefix' => { '$ref' => '#/definitions/string' },
+            'delete_suffix' => { '$ref' => '#/definitions/string' },
+            'delete_before' => { '$ref' => '#/definitions/string' },
+            'delete_after' => { '$ref' => '#/definitions/string' }
+          }
+        },
+        'transform' => {
+          'anyOf' => [
+            {
+              'type' => 'string',
+              'enum' => %w{
+                original
+                pluralize
+                singularize
+                camelize
+                camelcase
+                underscore
+                titleize
+                titlecase
+                demodulize
+                deconstantize
+                parameterize
+                downcase
+                upcase
+                capitalize
+                swapcase
+              }
+            },
+            { 'allOf' => [
+              { '$ref' => '#/definitions/transformProperties' },
+              {
+                'type' => 'object',
+                'properties' => {
+                  'original' => true,
+                  'pluralize' => true,
+                  'singularize' => true,
+                  'camelize' => true,
+                  'camelcase' => true,
+                  'underscore' => true,
+                  'titleize' => true,
+                  'titlecase' => true,
+                  'demodulize' => true,
+                  'deconstantize' => true,
+                  'parameterize' => true,
+                  'downcase' => true,
+                  'upcase' => true,
+                  'capitalize' => true,
+                  'swapcase' => true,
+                  'add_prefix' => true,
+                  'add_suffix' => true,
+                  'split' => true,
+                  'delete_prefix' => true,
+                  'delete_suffix' => true,
+                  'delete_before' => true,
+                  'delete_after' => true
+                },
+                'additionalProperties' => false
+              }
+            ] }
+          ]
+        },
+        'transformList' => {
+          'anyOf' => [
+            { '$ref' => '#/definitions/transform' },
+            {
+              'type' => 'array',
+              'items' => { '$ref' => '#/definitions/transform' },
+              'minItems' => 1,
+              'uniqueItems' => true
+            }
+          ]
+        },
+        'keyword' => {
+          'anyOf' => [
+            { '$ref' => '#/definitions/name' }
+          ]
+        },
+        'keywordList' => {
+          'anyOf' => [
+            { '$ref' => '#/definitions/keyword' },
+            {
+              'type' => 'array',
+              'items' => { '$ref' => '#/definitions/keyword' },
+              'minItems' => 1,
+              'uniqueItems' => true
+            }
+          ]
+        },
+        'action' => {
+          'anyOf' => [
+            { '$ref' => '#/definitions/string' },
+            { 'type' => 'integer', 'minimum' => 0 },
+            { 'allOf' => [
+              { '$ref' => '#/definitions/transformProperties' },
+              {
+                'type' => 'object',
+                'properties' => {
+                  'argument' => { '$ref' => '#/definitions/argumentPositionList' },
+                  'arguments' => { '$ref' => '#/definitions/argumentPositionList' },
+                  'keyword' => { '$ref' => '#/definitions/keywordList' },
+                  'keywords' => { '$ref' => '#/definitions/keywordList' },
+                  'itself' => { '$ref' => '#/definitions/true' },
+                  'value' => { '$ref' => '#/definitions/string' },
+                  'nested' => { '$ref' => '#/definitions/actionList' },
+                  'recursive' => { '$ref' => '#/definitions/true' },
+                  'transforms' => { '$ref' => '#/definitions/transformList' },
+                  'pluralize' => true,
+                  'singularize' => true,
+                  'camelize' => true,
+                  'camelcase' => true,
+                  'underscore' => true,
+                  'titleize' => true,
+                  'titlecase' => true,
+                  'demodulize' => true,
+                  'deconstantize' => true,
+                  'parameterize' => true,
+                  'downcase' => true,
+                  'upcase' => true,
+                  'capitalize' => true,
+                  'swapcase' => true,
+                  'add_prefix' => true,
+                  'add_suffix' => true,
+                  'split' => true,
+                  'delete_prefix' => true,
+                  'delete_suffix' => true,
+                  'delete_before' => true,
+                  'delete_after' => true
+                },
+                'additionalProperties' => false,
+                'allOf' => [
+                  # synonyms
+                  { 'not' => { 'required' => %w{keyword keywords} } },
+                  { 'not' => { 'required' => %w{argument arguments} } },
+                  # any of
+                  { 'anyOf' => [
+                    { 'required' => ['argument'] },
+                    { 'required' => ['arguments'] },
+                    { 'required' => ['keyword'] },
+                    { 'required' => ['keywords'] },
+                    { 'required' => ['itself'] },
+                    { 'required' => ['value'] }
+                  ] }
+                ]
+              }
+            ] }
+          ]
+        },
+        'actionList' => {
+          'anyOf' => [
+            { '$ref' => '#/definitions/action' },
+            {
+              'type' => 'array',
+              'items' => { '$ref' => '#/definitions/action' },
+              'minItems' => 1,
+              'uniqueItems' => true
+            }
+          ]
+        },
+        'dynamicAction' => {
+          'type' => 'object',
+          'properties' => {
+            'call' => { '$ref' => '#/definitions/actionList' },
+            'calls' => { '$ref' => '#/definitions/actionList' },
+            'define' => { '$ref' => '#/definitions/actionList' },
+            'defines' => { '$ref' => '#/definitions/actionList' }
+          },
+          'additionalProperties' => true,
+          'minProperties' => 1,
+          'allOf' => [
+            # synonyms
+            { 'not' => { 'required' => %w{call calls} } },
+            { 'not' => { 'required' => %w{define defines} } },
+            # At least one of
+            { 'anyOf' => [
+              { 'required' => ['call'] }, { 'required' => ['calls'] },
+              { 'required' => ['define'] }, { 'required' => ['defines'] }
+            ] }
+          ]
+        },
+        'ruleMatcherList' => {
+          'anyOf' => [
+            {
+              'type' => 'array',
+              'items' => { '$ref' => '#/definitions/ruleMatcher' },
+              'minItems' => 1,
+              'uniqueItems' => true
+            },
+            { '$ref' => '#/definitions/ruleMatcher' }
+          ]
+        },
+        'ruleMatcher' => {
+          'allOf' => [
+            { '$ref' => '#/definitions/rulePattern' },
+            { 'anyOf' => [
+              { 'required' => ['name'] }, { 'required' => ['names'] },
+              { 'required' => ['path'] }, { 'required' => ['paths'] },
+              { 'required' => ['has_argument'] }, { 'required' => ['has_arguments'] },
+              { 'required' => ['unless'] }
+            ] },
+            {
+              'type' => 'object',
+              'properties' => {
+                # unfortunately this repetition is necessary to use additionalProperties: false
+                'name' => true, 'names' => true,
+                'path' => true, 'paths' => true,
+                'has_argument' => true, 'has_arguments' => true,
+                'unless' => { '$ref' => '#/definitions/ruleMatcherList' }
+
+              },
+              'additionalProperties' => false,
+              'minProperties' => 1
+            }
+          ]
+        },
+        'dynamic' => {
+          'allOf' => [
+            { '$ref' => '#/definitions/rulePattern' },
+            { '$ref' => '#/definitions/dynamicAction' },
+            { 'anyOf' => [
+              { 'required' => ['name'] }, { 'required' => ['names'] },
+              { 'required' => ['path'] }, { 'required' => ['paths'] },
+              { 'required' => ['has_argument'] }, { 'required' => ['has_arguments'] },
+              { 'required' => ['unless'] }
+            ] },
+            {
+              'type' => 'object',
+              'properties' => {
+                # unfortunately this repetition is necessary to use additionalProperties: false
+                'name' => true, 'names' => true,
+                'path' => true, 'paths' => true,
+                'has_argument' => true, 'has_arguments' => true,
+                'unless' => { '$ref' => '#/definitions/ruleMatcherList' },
+
+                'call' => true, 'calls' => true,
+                'define' => true, 'defines' => true
+              },
+              'additionalProperties' => false,
+              'minProperties' => 1
+            }
+          ]
+        },
+        'dynamicList' => {
+          'anyOf' => [
+            {
+              'type' => 'array',
+              'items' => { '$ref' => '#/definitions/dynamic' },
+              'minItems' => 1,
+              'uniqueItems' => true
+            },
+            { '$ref' => '#/definitions/dynamic' }
+          ]
+        },
+        'keepTestOnly' => {
+          'anyOf' => [
+            { '$ref' => '#/definitions/string' },
+            {
+              'allOf' => [
+                { '$ref' => '#/definitions/stringPattern' },
+                { '$ref' => '#/definitions/rulePattern' },
+                {
+                  'type' => 'object',
+                  'properties' => {
+                    # unfortunately this repetition is necessary to use additionalProperties: false
+                    'name' => true, 'names' => true,
+                    'has_prefix' => true, 'has_suffix' => true, 'matches' => true,
+                    'path' => true, 'paths' => true,
+                    'has_argument' => true, 'has_arguments' => true,
+                    'unless' => { '$ref' => '#/definitions/keepTestOnlyList' }
+                  },
+                  'additionalProperties' => false,
+                  'minProperties' => 1
+                }
+              ]
+            }
+          ]
+        },
+        'keepTestOnlyList' => {
+          'anyOf' => [
+            {
+              'type' => 'array',
+              'items' => { '$ref' => '#/definitions/keepTestOnly' },
+              'minItems' => 1,
+              'uniqueItems' => true
+            },
+            { '$ref' => '#/definitions/keepTestOnly' }
+          ]
+        }
+      },
+      'properties' => {
+        'include_paths' => { '$ref' => '#/definitions/stringList' },
+        'exclude_paths' => { '$ref' => '#/definitions/stringList' },
+        'test_paths' => { '$ref' => '#/definitions/stringList' },
+        'requires' => { '$ref' => '#/definitions/stringList' },
+        'gems' => { '$ref' => '#/definitions/stringList' },
+        'keep' => { '$ref' => '#/definitions/keepTestOnlyList' },
+        'test_only' => { '$ref' => '#/definitions/keepTestOnlyList' },
+        'dynamic' => { '$ref' => '#/definitions/dynamicList' }
+      }
+    }.freeze
+  end
+end