versponse 0.1.0 → 0.2.0

data/lib/versponse/validator/compiler.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Versponse
+  module Validator
+    # Compiles a validation schema into a checker that responds to valid?(data)
+    #
+    # @api private
+    class Compiler
+      # Raised inside the compiler for a keyword or value it doesn't support
+      Unsupported = Class.new(StandardError)
+
+      # Keywords that don't affect validity (x- extensions too). discriminator is not one: json_schemer uses it
+      # to pick the oneOf variant it checks.
+      ANNOTATIONS = %w[
+        description title example examples default deprecated readOnly writeOnly $comment
+        nullable xml externalDocs
+      ].freeze
+
+      # JSON Schema versions that ignore keywords next to $ref
+      REF_ONLY = %i[draft4 draft6 draft7 openapi30].freeze
+
+      # Checker classes, each building itself from the keywords it owns
+      CHECKS = [TypeCheck, ValueCheck, ObjectCheck, ArrayCheck, StringCheck, FormatCheck, NumberCheck, Combinator, Ref].freeze
+
+      # Keywords naming a schema for "#Name" references, by JSON Schema version (see Configuration#anchor)
+      ANCHORS = %w[$anchor $id id].freeze
+
+      # Keywords holding schemas that are only referenced (SelectionSchema keeps anchored originals there)
+      DEFINITIONS = %w[$defs definitions].freeze
+
+      # Every keyword the compiler accepts
+      KEYWORDS = (ANNOTATIONS + CHECKS.flat_map(&:keywords) + ANCHORS + DEFINITIONS).freeze
+
+      # @param schema [Hash] validation schema
+      # @param schemer [JSONSchemer::Schema] json_schemer schema of the same Hash, used for patterns and formats
+      # @return [#valid?, nil] the checker, or nil when the schema uses an unsupported keyword
+      def self.call(schema, schemer)
+        new(schemer).root(schema)
+      rescue Unsupported
+        nil
+      end
+
+      # @param schemer [JSONSchemer::Schema] json_schemer schema, used for patterns and formats
+      def initialize(schemer)
+        @schemer = schemer
+        @anchors = {}
+        @refs = []
+        @compiled = {}.compare_by_identity
+      end
+
+      # @param schema [Hash] root validation schema
+      # @return [#valid?] the checker
+      # @raise [Unsupported] for an unsupported keyword or an unknown anchor
+      def root(schema)
+        checker = compile(schema)
+        raise Unsupported, "unknown anchor" unless (@refs - @anchors.keys).empty?
+
+        @anchors.freeze
+        Root.new(checker)
+      end
+
+      # @param schema [Hash, Boolean] schema or subschema
+      # @return [#valid?] the checker
+      # @raise [Unsupported] for an unsupported keyword
+      def compile(schema)
+        return Constant.for(schema) if schema == true || schema == false
+        raise Unsupported, schema.inspect unless schema.is_a?(Hash)
+
+        @compiled[schema] = compile_hash(schema)
+      end
+
+      # @param schema [Hash, Boolean] a subschema of the root compiled with {#root}, the same object
+      # @return [#valid?] its checker
+      # @raise [Unsupported] for a Hash this compiler hasn't compiled
+      def checker_for(schema)
+        return Constant.for(schema) if schema == true || schema == false
+
+        @compiled.fetch(schema) { raise Unsupported, "not compiled" }
+      end
+
+      # @param schema [Hash] schema or subschema
+      # @return [#valid?] the checker
+      def compile_hash(schema)
+        schema = schema.slice("$ref", *ANCHORS) if schema.key?("$ref") && REF_ONLY.include?(Versponse.configuration.json_schema_version)
+        DEFINITIONS.each { |keyword| schema[keyword].each_value { |definition| compile(definition) } if schema[keyword].is_a?(Hash) }
+        raise Unsupported, schema.inspect unless schema.keys.all? { |key| KEYWORDS.include?(key) || key.start_with?("x-") }
+
+        name = anchor_name(schema)
+        checker = All.for(fold(CHECKS.filter_map { |check| check.build(schema, self) }))
+        @anchors[name] = checker if name
+        checker
+      end
+
+      # type: "object", "array" or "string" folds into the one check built for that shape, made strict, so a
+      # value takes one check instead of two. With no such check (an unknown format builds none) or two (string
+      # keywords and a format), the type check stays.
+      #
+      # @param checks [Array<#valid?>] checks built from one schema; TypeCheck comes first in CHECKS
+      # @return [Array<#valid?>] the checks, with the type folded in when it can be
+      def fold(checks)
+        type = checks.first
+        return checks unless type.is_a?(ClassCheck)
+
+        owners = checks.select { |check| check.class.respond_to?(:shape) && check.class.shape == type.klass }
+        return checks unless owners.one?
+
+        checks.drop(1).map { |check| check.equal?(owners.first) ? check.strict : check }
+      end
+
+      # $id and id name an anchor only as a plain "#Name" fragment; other ids change the base URI
+      #
+      # @param schema [Hash] schema
+      # @return [String, nil] the anchor name the schema declares
+      # @raise [Unsupported] for an $id or id that isn't a plain-name fragment
+      def anchor_name(schema)
+        return schema["$anchor"] if schema.key?("$anchor")
+
+        id = schema["$id"] || schema["id"]
+        return if id.nil?
+        raise Unsupported, "id #{id}" unless id.is_a?(String) && id.start_with?("#")
+
+        id.delete_prefix("#")
+      end
+
+      # @param name [String] anchor name, without "#"
+      # @return [Versponse::Validator::Ref] a reference resolved when validating
+      def ref(name)
+        @refs << name
+        Ref.new(@anchors, name)
+      end
+
+      # @param pattern [String] pattern keyword
+      # @return [Regexp] the Regexp json_schemer uses for it
+      def regexp(pattern)
+        @schemer.resolve_regexp(pattern)
+      end
+
+      # @param name [String] format keyword
+      # @return [Proc, nil] json_schemer's format check, called with (data, name); nil for a format
+      #   json_schemer doesn't know, which it treats as an annotation
+      def format(name)
+        @schemer.fetch_format(name, nil)
+      end
+    end
+  end
+end

data/lib/versponse/validator/constant.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Versponse
+  module Validator
+    # The checker of a boolean schema, or of a schema without assertions
+    #
+    # @api private
+    class Constant
+      # @param result [Boolean] the result of every check
+      def initialize(result)
+        @result = result
+        freeze
+      end
+
+      # @param _data [Object] ignored
+      # @return [Boolean] the constant result
+      def valid?(_data)
+        @result
+      end
+
+      # Accepts anything
+      VALID = new(true)
+      # Rejects anything
+      INVALID = new(false)
+
+      # @param result [Boolean] schema true or false
+      # @return [Constant] VALID or INVALID
+      def self.for(result)
+        result ? VALID : INVALID
+      end
+    end
+  end
+end

data/lib/versponse/validator/date_time_check.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Versponse
+  module Validator
+    # The date-time format, with a fast path for the timestamps Versponse renders. A String matching
+    # {FAST} is valid without json_schemer; everything else is left to json_schemer's check.
+    #
+    # @api private
+    class DateTimeCheck < FormatCheck
+      # RFC 3339 date-times that json_schemer certainly accepts: days 01-28 (no calendar check needed), no leap
+      # seconds, uppercase T and Z, bounded offsets, anchored. Fuzzed against json_schemer 2.5.0 with no false accept.
+      FAST = /\A\d{4}-(0[1-9]|1[0-2])-(0[1-9]|1\d|2[0-8])T([01]\d|2[0-3]):[0-5]\d:[0-5]\d(\.\d+)?(Z|[+-]([01]\d|2[0-3]):[0-5]\d)\z/
+
+      # @param data [Object] value to check; anything but a String passes, as in json_schemer, unless strict
+      # @return [Boolean] true when data is a valid date-time
+      def valid?(data)
+        data.is_a?(String) ? (FAST.match?(data) || @check.call(data, @name)) : !@strict
+      end
+    end
+  end
+end

data/lib/versponse/validator/format_check.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Versponse
+  module Validator
+    # format, checked with json_schemer's own format procs
+    #
+    # @api private
+    class FormatCheck
+      # @return [Array<String>] keywords this check owns
+      def self.keywords = %w[format]
+
+      # @return [Class] the class a type folded into this check requires
+      def self.shape = String
+
+      # @param schema [Hash] schema
+      # @param compiler [Versponse::Validator::Compiler] looks formats up like json_schemer
+      # @return [FormatCheck, nil] the check, nil without format or for an unknown one (which accepts anything)
+      def self.build(schema, compiler)
+        return unless schema.key?("format")
+
+        check = compiler.format(schema["format"])
+        return unless check
+
+        (schema["format"] == "date-time") ? DateTimeCheck.new(schema["format"], check) : new(schema["format"], check)
+      end
+
+      # @param name [String] format name
+      # @param check [Proc] json_schemer's check, called with (data, name)
+      # @param strict [Boolean] true when anything but a String fails (type: "string" folded in)
+      def initialize(name, check, strict: false)
+        @name = name
+        @check = check
+        @strict = strict
+        freeze
+      end
+
+      # @return [FormatCheck] the same check, failing anything but a String
+      def strict
+        self.class.new(@name, @check, strict: true)
+      end
+
+      # @param data [Object] value to check (each format proc skips types it doesn't apply to; strict fails them)
+      # @return [Boolean] true when data matches the format
+      def valid?(data)
+        (@strict && !data.is_a?(String)) ? false : @check.call(data, @name)
+      end
+    end
+  end
+end

data/lib/versponse/validator/integer_check.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Versponse
+  module Validator
+    # type: integer from JSON Schema 6 on: json_schemer's own test, so 1.0 passes and NaN raises (Root then defers)
+    #
+    # @api private
+    class IntegerCheck
+      # @param data [Object] value to check
+      # @return [Boolean] true when data is an integer
+      def valid?(data)
+        JSONSchemer::Draft202012::Vocab::Validation::Type.valid_integer?(data)
+      end
+    end
+  end
+end

data/lib/versponse/validator/nullable_check.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Versponse
+  module Validator
+    # type: [X, "null"]: nil, or what the single-type check of X accepts
+    #
+    # @api private
+    class NullableCheck
+      # @param inner [#valid?] check of the other type
+      def initialize(inner)
+        @inner = inner
+        freeze
+      end
+
+      # @param data [Object] value to check
+      # @return [Boolean] true when data is nil or passes the inner check
+      def valid?(data)
+        data.nil? || @inner.valid?(data)
+      end
+    end
+  end
+end

data/lib/versponse/validator/number_check.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module Versponse
+  module Validator
+    # minimum, maximum, exclusiveMinimum, exclusiveMaximum and multipleOf, as json_schemer compares them
+    #
+    # @api private
+    class NumberCheck
+      # Keywords and the comparison data must pass against their value
+      BOUNDS = {"minimum" => :>=, "maximum" => :<=, "exclusiveMinimum" => :>, "exclusiveMaximum" => :<}.freeze
+
+      # @return [Array<String>] keywords this check owns
+      def self.keywords = BOUNDS.keys + %w[multipleOf]
+
+      # @param schema [Hash] schema
+      # @param _compiler [Versponse::Validator::Compiler] unused
+      # @return [NumberCheck, nil] the check, nil without number keywords
+      def self.build(schema, _compiler)
+        return unless keywords.any? { |keyword| schema.key?(keyword) }
+
+        new(bounds(schema), schema["multipleOf"])
+      end
+
+      # A boolean exclusiveMinimum/exclusiveMaximum (draft 4, OpenAPI 3.0) makes minimum/maximum exclusive
+      def self.bounds(schema)
+        bounds = BOUNDS.filter_map { |keyword, operator| [operator, schema[keyword]] if schema[keyword].is_a?(Numeric) }
+        bounds << [:>, schema["minimum"]] if schema["exclusiveMinimum"] == true && schema["minimum"].is_a?(Numeric)
+        bounds << [:<, schema["maximum"]] if schema["exclusiveMaximum"] == true && schema["maximum"].is_a?(Numeric)
+        bounds
+      end
+      private_class_method :bounds
+
+      # @param bounds [Array<Array(Symbol, Numeric)>] comparisons data must pass
+      # @param multiple_of [Numeric, nil] divisor, nil without multipleOf
+      def initialize(bounds, multiple_of)
+        @bounds = bounds.freeze
+        @multiple_of = multiple_of
+        freeze
+      end
+
+      # @param data [Object] value to check; anything but a Numeric passes
+      # @return [Boolean] true when the number matches
+      def valid?(data)
+        return true unless data.is_a?(Numeric)
+
+        @bounds.all? { |operator, value| data.public_send(operator, value) } && multiple?(data)
+      end
+
+      private
+
+      def multiple?(data)
+        @multiple_of.nil? || BigDecimal(data.to_s).modulo(@multiple_of).zero?
+      end
+    end
+  end
+end

data/lib/versponse/validator/object_check.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Versponse
+  module Validator
+    # properties, required, additionalProperties, minProperties and maxProperties
+    #
+    # @api private
+    class ObjectCheck
+      # @return [Array<String>] keywords this check owns
+      def self.keywords = %w[properties required additionalProperties minProperties maxProperties]
+
+      # @return [Class] the class a type folded into this check requires
+      def self.shape = Hash
+
+      # @param schema [Hash] schema
+      # @param compiler [Versponse::Validator::Compiler] compiles subschemas
+      # @return [ObjectCheck, ClosedObjectCheck, nil] the check, nil without object keywords
+      def self.build(schema, compiler)
+        return unless keywords.any? { |keyword| schema.key?(keyword) }
+
+        properties = schema.fetch("properties", {}).transform_values { |property| compiler.compile(property) }
+        required = schema.fetch("required", [])
+        sizes = Range.new(schema["minProperties"], schema["maxProperties"])
+        if schema["additionalProperties"] == false && required.all? { |key| properties.key?(key) }
+          return ClosedObjectCheck.new(properties:, required:, sizes:)
+        end
+
+        new(properties:, required:, additional: compiler.compile(schema.fetch("additionalProperties", true)), sizes:)
+      end
+
+      # @param properties [Hash{String => #valid?}] checkers of named properties
+      # @param required [Array<String>] required keys
+      # @param additional [#valid?] checker of other properties
+      # @param sizes [Range] allowed number of properties
+      # @param strict [Boolean] true when anything but a Hash fails (type: "object" folded in)
+      def initialize(properties:, required:, additional:, sizes:, strict: false)
+        @properties = properties.freeze
+        @required = required.freeze
+        @additional = additional
+        @sizes = sizes
+        @strict = strict
+        freeze
+      end
+
+      # @return [ObjectCheck] the same check, failing anything but a Hash
+      def strict
+        self.class.new(properties: @properties, required: @required, additional: @additional, sizes: @sizes, strict: true)
+      end
+
+      # A Hash with Symbol keys is checked with their Strings; any other non-String key throws {Root::DEFER}, which
+      # hands it to json_schemer
+      #
+      # @param data [Object] value to check; anything but a Hash passes unless strict
+      # @return [Boolean] true when the Hash matches
+      def valid?(data)
+        return !@strict unless data.is_a?(Hash)
+        return reject(data) unless @sizes.cover?(data.size)
+
+        @required.each { |key| return reject(data) unless data.key?(key) }
+        data.each do |key, value|
+          return with_string_keys(data) unless key.is_a?(String)
+          return false unless (@properties[key] || @additional).valid?(value)
+        end
+        true
+      end
+
+      private
+
+      # json_schemer reads Symbol keys as Strings, so a false is certain only for a Hash with String keys; one with
+      # Symbol keys is checked again with their Strings
+      #
+      # @param data [Hash] value being checked
+      # @return [Boolean] false, or the answer for the Hash with String keys
+      def reject(data)
+        data.each_key { |key| return with_string_keys(data) unless key.is_a?(String) }
+        false
+      end
+
+      # @param data [Hash] value with a non-String key
+      # @return [Boolean] the answer for the Hash with String keys; throws {Root::DEFER} when the keys can't all be
+      #   read as Strings (inside oneOf or not, a false would be read as a real answer)
+      def with_string_keys(data)
+        strings = StringKeys.call(data)
+        throw Root::DEFER unless strings
+
+        valid?(strings)
+      end
+    end
+  end
+end

data/lib/versponse/validator/ref.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Versponse
+  module Validator
+    # $ref to a local $anchor ("#Name"), resolved when validating so recursive schemas work
+    #
+    # @api private
+    class Ref
+      # @return [Array<String>] keywords this check owns
+      def self.keywords = %w[$ref]
+
+      # @param schema [Hash] schema
+      # @param compiler [Versponse::Validator::Compiler] registers the reference
+      # @return [Ref, nil] the check, nil without $ref
+      # @raise [Versponse::Validator::Compiler::Unsupported] for anything but a plain-name fragment
+      def self.build(schema, compiler)
+        return unless schema.key?("$ref")
+        raise Compiler::Unsupported, schema["$ref"] unless schema["$ref"].match?(/\A#[A-Za-z_][-A-Za-z0-9._]*\z/)
+
+        compiler.ref(schema["$ref"].delete_prefix("#"))
+      end
+
+      # @param anchors [Hash{String => #valid?}] anchors of the root schema, filled while compiling
+      # @param name [String] anchor name
+      def initialize(anchors, name)
+        @anchors = anchors
+        @name = name
+        freeze
+      end
+
+      # @param data [Object] value to check
+      # @return [Boolean] true when data matches the anchored schema
+      def valid?(data)
+        @anchors.fetch(@name).valid?(data)
+      end
+    end
+  end
+end

data/lib/versponse/validator/root.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Versponse
+  module Validator
+    # Compiled checker of a whole schema. A check that can't answer (a non-String key) throws {DEFER},
+    # which this root turns into false, so the caller asks json_schemer, instead of a false that a
+    # oneOf or not further up would read as a real answer.
+    #
+    # @api private
+    class Root
+      # Thrown by a check that leaves the value to json_schemer
+      DEFER = :versponse_validator_defer
+
+      # @param checker [#valid?] compiled checker
+      def initialize(checker)
+        @checker = checker
+        freeze
+      end
+
+      # @param data [Object] value to check
+      # @return [Boolean] true when the value matches; false when it doesn't or json_schemer has to decide
+      #   (a check deferred, or raised, e.g. comparing Infinity)
+      def valid?(data)
+        catch(DEFER) { return @checker.valid?(data) }
+        false
+      rescue
+        false
+      end
+    end
+  end
+end

data/lib/versponse/validator/string_check.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Versponse
+  module Validator
+    # minLength, maxLength and pattern
+    #
+    # @api private
+    class StringCheck
+      # @return [Array<String>] keywords this check owns
+      def self.keywords = %w[minLength maxLength pattern]
+
+      # @return [Class] the class a type folded into this check requires
+      def self.shape = String
+
+      # @param schema [Hash] schema
+      # @param compiler [Versponse::Validator::Compiler] resolves patterns like json_schemer
+      # @return [StringCheck, nil] the check, nil without string keywords
+      def self.build(schema, compiler)
+        return unless keywords.any? { |keyword| schema.key?(keyword) }
+
+        new(Range.new(schema["minLength"], schema["maxLength"]), schema["pattern"]&.then { |pattern| compiler.regexp(pattern) })
+      end
+
+      # @param lengths [Range] allowed lengths in characters
+      # @param pattern [Regexp, nil] pattern matched anywhere in the string
+      # @param strict [Boolean] true when anything but a String fails (type: "string" folded in)
+      def initialize(lengths, pattern, strict: false)
+        @lengths = lengths
+        @pattern = pattern
+        @strict = strict
+        freeze
+      end
+
+      # @return [StringCheck] the same check, failing anything but a String
+      def strict
+        self.class.new(@lengths, @pattern, strict: true)
+      end
+
+      # @param data [Object] value to check; anything but a String passes unless strict
+      # @return [Boolean] true when the String matches
+      def valid?(data)
+        return !@strict unless data.is_a?(String)
+
+        @lengths.cover?(data.size) && (@pattern.nil? || @pattern.match?(data))
+      end
+    end
+  end
+end

data/lib/versponse/validator/string_keys.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Versponse
+  module Validator
+    # json_schemer reads Symbol keys as their Strings, so the object checks do too: a Hash with Symbol keys is
+    # checked again with String keys
+    #
+    # @api private
+    module StringKeys
+      # @param data [Hash] value being checked
+      # @return [Hash{String => Object}, nil] the Hash with String keys, nil when a key is neither a String nor a
+      #   Symbol, or a Symbol and a String name the same key (json_schemer decides those)
+      def self.call(data)
+        return unless data.each_key.all? { |key| key.is_a?(String) || key.is_a?(Symbol) }
+
+        strings = data.transform_keys(&:to_s)
+        strings if strings.size == data.size
+      end
+    end
+  end
+end

data/lib/versponse/validator/type_check.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Versponse
+  module Validator
+    # type, with json_schemer's semantics (integer accepts 1.0, number includes NaN)
+    #
+    # @api private
+    class TypeCheck
+      # Type tests, matching json_schemer's valid_type
+      TESTS = {
+        "null" => :nil?.to_proc,
+        "boolean" => ->(data) { data == true || data == false },
+        "number" => ->(data) { data.is_a?(Numeric) },
+        "integer" => ->(data) { JSONSchemer::Draft202012::Vocab::Validation::Type.valid_integer?(data) },
+        "string" => ->(data) { data.is_a?(String) },
+        "array" => ->(data) { data.is_a?(Array) },
+        "object" => ->(data) { data.is_a?(Hash) }
+      }.freeze
+
+      # Types that are a class test, checked without a lambda when a schema allows only that type
+      CLASSES = {"number" => Numeric, "string" => String, "array" => Array, "object" => Hash}.freeze
+
+      # Draft 4 and OpenAPI 3.0 (based on it) accept only Integers; later versions also accept 1.0
+      INTEGER_ONLY = %i[draft4 openapi30].freeze
+
+      # JSON Schema versions where nullable: true adds "null" to type (json_schemer's OpenAPI30::Vocab::Base::Type)
+      NULLABLE_TYPE = %i[openapi30].freeze
+
+      # Integer test of draft 4 and OpenAPI 3.0
+      STRICT_INTEGER = ->(data) { data.is_a?(Integer) }
+
+      # @return [Array<String>] keywords this check owns
+      def self.keywords = %w[type]
+
+      # Reads config.json_schema_version; checkers are cached per class, and setting it resets them
+      #
+      # @param schema [Hash] schema
+      # @param _compiler [Versponse::Validator::Compiler] unused
+      # @return [TypeCheck, nil] the check, nil without type
+      # @raise [Versponse::Validator::Compiler::Unsupported] for an unknown type
+      def self.build(schema, _compiler)
+        return unless schema.key?("type")
+
+        types = Array(schema["type"])
+        types = (types + ["null"]).uniq if schema["nullable"] == true && NULLABLE_TYPE.include?(Versponse.configuration.json_schema_version)
+        single = types.map { |type| single(type) }
+        return single.first if types.one? && single.first
+        return NullableCheck.new(single[types.index { |type| type != "null" }]) if types.size == 2 && types.include?("null") && single.compact.one?
+
+        new(types.map { |type| test_for(type) })
+      end
+
+      # @param type [String] one JSON Schema type
+      # @return [#valid?, nil] a check of only that type, nil for null and unknown types
+      def self.single(type)
+        return ClassCheck.new(CLASSES.fetch(type)) if CLASSES.key?(type)
+        return BooleanCheck.new if type == "boolean"
+        return unless type == "integer"
+
+        INTEGER_ONLY.include?(Versponse.configuration.json_schema_version) ? ClassCheck.new(Integer) : IntegerCheck.new
+      end
+      private_class_method :single
+
+      def self.test_for(type)
+        return STRICT_INTEGER if type == "integer" && INTEGER_ONLY.include?(Versponse.configuration.json_schema_version)
+
+        TESTS.fetch(type) { raise Compiler::Unsupported, "type #{type}" }
+      end
+      private_class_method :test_for
+
+      # @param tests [Array<Proc>] tests of the allowed types
+      def initialize(tests)
+        @tests = tests.freeze
+        freeze
+      end
+
+      # @param data [Object] value to check
+      # @return [Boolean] true when data has one of the types
+      def valid?(data)
+        @tests.any? { |test| test.call(data) }
+      end
+    end
+  end
+end