jsi-dev 0.0.8 → 0.0.9

data/lib/jsi/schema/draft202012.rb

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Draft202012
+    module Vocab end
+
+    # draft-bhutton-json-schema-01 8.  The JSON Schema Core Vocabulary
+    #
+    # The current URI for the Core vocabulary is:
+    # https://json-schema.org/draft/2020-12/vocab/core
+    #
+    # The current URI for the corresponding meta-schema is:
+    # https://json-schema.org/draft/2020-12/meta/core
+    Vocab::CORE = Schema::Vocabulary.new(
+      id: "https://json-schema.org/draft/2020-12/vocab/core",
+      elements: [
+        Schema::Elements::SELF[],
+
+        # draft-bhutton-json-schema-01 8.1.1.  The "$schema" Keyword
+        Schema::Elements::XSCHEMA[],
+
+        # draft-bhutton-json-schema-01 8.1.2.  The "$vocabulary" Keyword
+        Schema::Elements::XVOCABULARY[],
+
+        # draft-bhutton-json-schema-01 8.2.1.  The "$id" Keyword
+        Schema::Elements::ID[keyword: '$id', fragment_is_anchor: false],
+
+        # draft-bhutton-json-schema-01 8.2.2.  Defining location-independent identifiers
+        Schema::Elements::ANCHOR[keyword: '$anchor', actions: [:anchor]],
+        Schema::Elements::ANCHOR[keyword: '$dynamicAnchor', actions: [:anchor, :dynamicAnchor]],
+
+        # draft-bhutton-json-schema-01 8.2.3.  Schema References
+
+        # draft-bhutton-json-schema-01 8.2.3.1.  Direct References with "$ref"
+        Schema::Elements::REF[exclusive: false],
+
+        # draft-bhutton-json-schema-01 8.2.3.2.  Dynamic References with "$dynamicRef"
+        Schema::Elements::DYNAMIC_REF[],
+
+        # draft-bhutton-json-schema-01 8.2.4.  Schema Re-Use With "$defs"
+        Schema::Elements::DEFINITIONS[keyword: '$defs'],
+
+        # draft-bhutton-json-schema-01 8.3.  Comments With "$comment"
+        Schema::Elements::COMMENT[],
+      ],
+    )
+
+    # draft-bhutton-json-schema-01 10.  A Vocabulary for Applying Subschemas
+    #
+    # The current URI for this vocabulary, known as the Applicator vocabulary, is:
+    # https://json-schema.org/draft/2020-12/vocab/applicator
+    #
+    # The current URI for the corresponding meta-schema is:
+    # https://json-schema.org/draft/2020-12/meta/applicator
+    Vocab::APPLICATOR = Schema::Vocabulary.new(
+      id: "https://json-schema.org/draft/2020-12/vocab/applicator",
+      elements: [
+        # draft-bhutton-json-schema-01 10.2.  Keywords for Applying Subschemas in Place
+        # draft-bhutton-json-schema-01 10.2.1.  Keywords for Applying Subschemas With Logic
+
+        # draft-bhutton-json-schema-01 10.2.1.1.  allOf
+        Schema::Elements::ALL_OF[],
+
+        # draft-bhutton-json-schema-01 10.2.1.2.  anyOf
+        Schema::Elements::ANY_OF[],
+
+        # draft-bhutton-json-schema-01 10.2.1.3.  oneOf
+        Schema::Elements::ONE_OF[],
+
+        # draft-bhutton-json-schema-01 10.2.1.4.  not
+        Schema::Elements::NOT[],
+
+        # draft-bhutton-json-schema-01 10.2.2.  Keywords for Applying Subschemas Conditionally
+
+        # draft-bhutton-json-schema-01 10.2.2.1.  if
+        # draft-bhutton-json-schema-01 10.2.2.2.  then
+        # draft-bhutton-json-schema-01 10.2.2.3.  else
+        Schema::Elements::IF_THEN_ELSE[],
+
+        # draft-bhutton-json-schema-01 10.2.2.4.  dependentSchemas
+        Schema::Elements::DEPENDENT_SCHEMAS[],
+
+        # draft-bhutton-json-schema-01 10.3.  Keywords for Applying Subschemas to Child Instances
+        # draft-bhutton-json-schema-01 10.3.1.  Keywords for Applying Subschemas to Arrays
+
+        # draft-bhutton-json-schema-01 10.3.1.1.  prefixItems
+        # draft-bhutton-json-schema-01 10.3.1.2.  items
+        Schema::Elements::ITEMS_PREFIXED[],
+
+        # draft-bhutton-json-schema-01 10.3.1.3.  contains
+        Schema::Elements::CONTAINS_MINMAX[],
+
+        # draft-bhutton-json-schema-01 10.3.2.  Keywords for Applying Subschemas to Objects
+
+        # draft-bhutton-json-schema-01 10.3.2.1.  properties
+        # draft-bhutton-json-schema-01 10.3.2.2.  patternProperties
+        # draft-bhutton-json-schema-01 10.3.2.3.  additionalProperties
+        Schema::Elements::PROPERTIES[],
+
+        # draft-bhutton-json-schema-01 10.3.2.4.  propertyNames
+        Schema::Elements::PROPERTY_NAMES[],
+      ],
+    )
+
+    # draft-bhutton-json-schema-01 11.  A Vocabulary for Unevaluated Locations
+    #
+    # The current URI for this vocabulary, known as the Unevaluated Applicator vocabulary, is:
+    # https://json-schema.org/draft/2020-12/vocab/unevaluated
+    #
+    # The current URI for the corresponding meta-schema is:
+    # https://json-schema.org/draft/2020-12/meta/unevaluated
+    Vocab::UNEVALUATED = Schema::Vocabulary.new(
+      id: "https://json-schema.org/draft/2020-12/vocab/unevaluated",
+      elements: [
+        # draft-bhutton-json-schema-01 11.2.  unevaluatedItems
+        Schema::Elements::UNEVALUATED_ITEMS[],
+
+        # draft-bhutton-json-schema-01 11.3.  unevaluatedProperties
+        Schema::Elements::UNEVALUATED_PROPERTIES[],
+      ],
+    )
+
+    # draft-bhutton-json-schema-validation-01 6.  A Vocabulary for Structural Validation
+    #
+    # The current URI for this vocabulary, known as the Validation vocabulary, is:
+    # https://json-schema.org/draft/2020-12/vocab/validation
+    #
+    # The current URI for the corresponding meta-schema is:
+    # https://json-schema.org/draft/2020-12/meta/validation
+    Vocab::VALIDATION = Schema::Vocabulary.new(
+      id: "https://json-schema.org/draft/2020-12/vocab/validation",
+      elements: [
+        # draft-bhutton-json-schema-validation-01 6.1.  Validation Keywords for Any Instance Type
+
+        # draft-bhutton-json-schema-validation-01 6.1.1.  type
+        Schema::Elements::TYPE[],
+
+        # draft-bhutton-json-schema-validation-01 6.1.2.  enum
+        Schema::Elements::ENUM[],
+
+        # draft-bhutton-json-schema-validation-01 6.1.3.  const
+        Schema::Elements::CONST[],
+
+        # draft-bhutton-json-schema-validation-01 6.2.  Validation Keywords for Numeric Instances (number and integer)
+
+        # draft-bhutton-json-schema-validation-01 6.2.1.  multipleOf
+        Schema::Elements::MULTIPLE_OF[],
+
+        # draft-bhutton-json-schema-validation-01 6.2.2.  maximum
+        Schema::Elements::MAXIMUM[],
+
+        # draft-bhutton-json-schema-validation-01 6.2.3.  exclusiveMaximum
+        Schema::Elements::EXCLUSIVE_MAXIMUM[],
+
+        # draft-bhutton-json-schema-validation-01 6.2.4.  minimum
+        Schema::Elements::MINIMUM[],
+
+        # draft-bhutton-json-schema-validation-01 6.2.5.  exclusiveMinimum
+        Schema::Elements::EXCLUSIVE_MINIMUM[],
+
+        # draft-bhutton-json-schema-validation-01 6.3.  Validation Keywords for Strings
+
+        # draft-bhutton-json-schema-validation-01 6.3.1.  maxLength
+        Schema::Elements::MAX_LENGTH[],
+
+        # draft-bhutton-json-schema-validation-01 6.3.2.  minLength
+        Schema::Elements::MIN_LENGTH[],
+
+        # draft-bhutton-json-schema-validation-01 6.3.3.  pattern
+        Schema::Elements::PATTERN[],
+
+        # draft-bhutton-json-schema-validation-01 6.4.  Validation Keywords for Arrays
+
+        # draft-bhutton-json-schema-validation-01 6.4.1.  maxItems
+        Schema::Elements::MAX_ITEMS[],
+
+        # draft-bhutton-json-schema-validation-01 6.4.2.  minItems
+        Schema::Elements::MIN_ITEMS[],
+
+        # draft-bhutton-json-schema-validation-01 6.4.3.  uniqueItems
+        Schema::Elements::UNIQUE_ITEMS[],
+
+        # draft-bhutton-json-schema-validation-01 6.4.4.  maxContains
+        # draft-bhutton-json-schema-validation-01 6.4.5.  minContains
+        # (see Schema::Elements::CONTAINS_MINMAX[] - draft-bhutton-json-schema-01 10.3.1.3.  contains)
+
+        # draft-bhutton-json-schema-validation-01 6.5.  Validation Keywords for Objects
+
+        # draft-bhutton-json-schema-validation-01 6.5.1.  maxProperties
+        Schema::Elements::MAX_PROPERTIES[],
+
+        # draft-bhutton-json-schema-validation-01 6.5.2.  minProperties
+        Schema::Elements::MIN_PROPERTIES[],
+
+        # draft-bhutton-json-schema-validation-01 6.5.3.  required
+        Schema::Elements::REQUIRED[],
+
+        # draft-bhutton-json-schema-validation-01 6.5.4.  dependentRequired
+        Schema::Elements::DEPENDENT_REQUIRED[],
+      ],
+    )
+
+    # draft-bhutton-json-schema-validation-01 7.  Vocabularies for Semantic Content With "format"
+    #
+    # The current URI for this vocabulary, known as the Format-Annotation vocabulary, is:
+    # https://json-schema.org/draft/2020-12/vocab/format-annotation
+    #
+    # The current URI for the corresponding meta-schema is:
+    # https://json-schema.org/draft/2020-12/meta/format-annotation
+    Vocab::FORMAT_ANNOTATION = Schema::Vocabulary.new(
+      id: "https://json-schema.org/draft/2020-12/vocab/format-annotation",
+      elements: [
+        # draft-bhutton-json-schema-validation-01 7.2.1.  Format-Annotation Vocabulary
+        Schema::Elements::FORMAT[],
+      ],
+    )
+
+    # draft-bhutton-json-schema-validation-01 7.  Vocabularies for Semantic Content With "format"
+    #
+    # The URI for the Format-Assertion vocabulary, is:
+    # https://json-schema.org/draft/2020-12/vocab/format-assertion
+    #
+    # The current URI for the corresponding meta-schema is:
+    # https://json-schema.org/draft/2020-12/meta/format-assertion
+    #
+    # (Vocab::FORMAT_ASSERTION not implemented)
+
+
+    # draft-bhutton-json-schema-validation-01 8.  A Vocabulary for the Contents of String-Encoded Data
+    #
+    # The current URI for this vocabulary, known as the Content vocabulary, is:
+    # https://json-schema.org/draft/2020-12/vocab/content
+    #
+    # The current URI for the corresponding meta-schema is:
+    # https://json-schema.org/draft/2020-12/meta/content
+    Vocab::CONTENT = Schema::Vocabulary.new(
+      id: "https://json-schema.org/draft/2020-12/vocab/content",
+      elements: [
+        # draft-bhutton-json-schema-validation-01 8.3.  contentEncoding
+        Schema::Elements::CONTENT_ENCODING[],
+
+        # draft-bhutton-json-schema-validation-01 8.4.  contentMediaType
+        Schema::Elements::CONTENT_MEDIA_TYPE[],
+
+        # draft-bhutton-json-schema-validation-01 8.5.  contentSchema
+        Schema::Elements::CONTENT_SCHEMA[],
+      ],
+    )
+
+    # draft-bhutton-json-schema-validation-01 9.  A Vocabulary for Basic Meta-Data Annotations
+    #
+    # The current URI for this vocabulary, known as the Meta-Data vocabulary, is:
+    # https://json-schema.org/draft/2020-12/vocab/meta-data
+    #
+    # The current URI for the corresponding meta-schema is:
+    # https://json-schema.org/draft/2020-12/meta/meta-data
+    Vocab::METADATA = Schema::Vocabulary.new(
+      id: "https://json-schema.org/draft/2020-12/vocab/meta-data",
+      elements: [
+        # draft-bhutton-json-schema-validation-01 9.1.  "title" and "description"
+        Schema::Elements::INFO_STRING[keyword: 'title'],
+        Schema::Elements::INFO_STRING[keyword: 'description'],
+
+        # draft-bhutton-json-schema-validation-01 9.2.  "default"
+        Schema::Elements::DEFAULT[],
+
+        # draft-bhutton-json-schema-validation-01 9.3.  "deprecated"
+        Schema::Elements::INFO_BOOL[keyword: 'deprecated'],
+
+        # draft-bhutton-json-schema-validation-01 9.4.  "readOnly" and "writeOnly"
+        Schema::Elements::INFO_BOOL[keyword: 'readOnly'],
+        Schema::Elements::INFO_BOOL[keyword: 'writeOnly'],
+
+        # draft-bhutton-json-schema-validation-01 9.5.  "examples"
+        Schema::Elements::EXAMPLES[],
+      ],
+    )
+
+    # Compatibility vocabulary: The specification doesn't specify these keywords,
+    # but the meta-schema describes them. The test suite considers them optional.
+    Vocab::COMPATIBILITY = Schema::Vocabulary.new(
+      elements: [
+        Schema::Elements::DEFINITIONS[keyword: 'definitions'],
+
+        Schema::Elements::DEPENDENCIES[],
+      ],
+    )
+
+    DIALECT = Schema::Dialect.new(
+      id: "https://json-schema.org/draft/2020-12/schema",
+      vocabularies: [
+        Vocab::CORE,
+        Vocab::APPLICATOR,
+        Vocab::UNEVALUATED,
+        Vocab::VALIDATION,
+        Vocab::FORMAT_ANNOTATION,
+        Vocab::CONTENT,
+        Vocab::METADATA,
+        Vocab::COMPATIBILITY,
+      ],
+    )
+  end
+end

data/lib/jsi/schema/dynamic_anchor_map.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module JSI
+  # A map of dynamic anchors to schemas.
+  #
+  # key: `anchor_name` [String] a `$dynamicAnchor` keyword value
+  #
+  # value: [Array] (2-tuple)
+  #
+  #   - `anchor_root` [Schema]
+  #
+  #     The resource root of the schema containing the `$dynamicAnchor` with `anchor_name`.
+  #
+  #     The `#jsi_schema_dynamic_anchor_map` of anchor_root is expected to be empty.
+  #     It should be replaced when the anchor schema is resolved.
+  #
+  #   - `ptrs` [Array<{Ptr}>]
+  #
+  #     Pointers passed to {Schema#subschema} from `anchor_root`, resulting in the schema containing the
+  #     `$dynamicAnchor` with `anchor_name`.
+  #
+  # @api private
+  class Schema::DynamicAnchorMap < Hash
+    # In order to avoid instantiating a node with a dynamic_anchor_map that refers to that node itself
+    # (which results in its jsi_fingerprint circularly referring to itself)
+    # we remove such anchors from the dynamic_anchor_map it will be instantiated with.
+    # The node's #jsi_next_schema_dynamic_anchor_map will remap such anchors to the node again.
+    #
+    # If the indicated node is not a schema and a resource root, nothing will be removed.
+    # @return [Schema::DynamicAnchorMap]
+    def without_node(node, document: node.jsi_document, ptr: node.jsi_ptr, registry: node.jsi_registry)
+      dynamic_anchor_map = self
+      each do |anchor, (anchor_root, anchor_ptrs)|
+        # Determine whether this anchor maps to the indicated node.
+        # This should strictly use the same fields as the node's #jsi_fingerprint
+        # (which is different for Base, MetaSchemaNode, and MetaSchemaNode::BootstrapSchema).
+        # However, some fields of the fingerprint are fairly complicated to compute with neither
+        # the node being removed nor the anchor schema actually instantiated.
+        # Realistically document+ptr is sufficient and correct outside of implausible edge cases.
+        maps_to_node = anchor_root.jsi_document.equal?(document) &&
+          anchor_root.jsi_ptr == ptr &&
+          anchor_root.jsi_registry == registry
+        if maps_to_node
+          dynamic_anchor_map = dynamic_anchor_map.dup
+          dynamic_anchor_map.delete(anchor)
+          dynamic_anchor_map.freeze
+        end
+      end
+      dynamic_anchor_map.empty? ? EMPTY : dynamic_anchor_map
+    end
+
+    # @private
+    # @return [String]
+    def anchor_schemas_identifier
+      names = map do |anchor, (r, ptrs)|
+        -"#{anchor}→#{ptrs.inject(r, &:subschema).jsi_schema_identifier(required: true)}"
+      end
+      -"«#{names.join(", ")}»"
+    end
+
+    EMPTY = new.freeze
+  end
+end

data/lib/jsi/schema/element.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema
+    class Element
+      # @yield [Schema::Element] self
+      def initialize(keyword: nil, keywords: Util::EMPTY_SET)
+        @keywords = keyword ? (keywords.empty? ? Set[keyword].freeze : raise(ArgumentError)) : Set.new(keywords).freeze
+        @actions = Hash.new(Util::EMPTY_ARY)
+        @required_before_element_selector = nil
+        @depends_on_element_selector = nil
+
+        yield(self)
+
+        @actions.freeze
+        freeze
+      end
+
+      # @return [Set]
+      attr_reader(:keywords)
+
+      # @return [Hash<Symbol, Array<Proc>>]
+      attr_reader(:actions)
+
+      # this element will be invoked before elements for which the result of the block is true-ish
+      # @yieldparam [Schema::Element]
+      # @yieldreturn [Boolean]
+      def required_before_elements(&block)
+        @required_before_element_selector = block
+      end
+
+      # this element will be invoked after elements for which the result of the block is true-ish
+      # @yieldparam [Schema::Element]
+      # @yieldreturn [Boolean]
+      def depends_on_elements(&block)
+        @depends_on_element_selector = block
+      end
+
+      # selects which of `elements` this element is required before
+      def select_elements_self_is_required_before(elements)
+        return(Util::EMPTY_ARY) unless @required_before_element_selector
+        elements.select { |e| e != self && @required_before_element_selector.call(e) }.freeze
+      end
+
+      # selects which of `elements` this element depends on
+      def select_elements_self_depends_on(elements)
+        return(Util::EMPTY_ARY) unless @depends_on_element_selector
+        elements.select { |e| e != self && @depends_on_element_selector.call(e) }.freeze
+      end
+
+      # @param name [Symbol]
+      # @yield perform the action
+      # @return [void]
+      def add_action(name, &block)
+        raise(TypeError) unless name.is_a?(Symbol)
+
+        @actions[name] = @actions[name].dup.push(block).freeze
+
+        nil
+      end
+
+      # @param action_name [Symbol]
+      # @return [Boolean]
+      def invokes?(action_name)
+        !@actions[action_name].empty?
+      end
+    end
+  end
+end

data/lib/jsi/schema/elements/anchor.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    ANCHOR = element_map do |keyword: , actions: |
+      Schema::Element.new(keyword: keyword) do |element|
+        actions.each do |action|
+          element.add_action(action) { cxt_yield(schema_content[keyword]) if keyword_value_str?(keyword) }
+        end
+      end
+    end
+  end
+end

data/lib/jsi/schema/elements/array_validation.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    MAX_ITEMS = element_map do
+      Schema::Element.new(keyword: 'maxItems') do |element|
+        element.add_action(:validate) do
+      if keyword?('maxItems')
+        value = schema_content['maxItems']
+        # The value of this keyword MUST be a non-negative integer.
+        if internal_integer?(value) && value >= 0
+          if instance.respond_to?(:to_ary)
+            # An array instance is valid against "maxItems" if its size is less than, or equal to, the value of this keyword.
+            size = instance.to_ary.size
+            validate(
+              size <= value,
+              'validation.keyword.maxItems.size_greater',
+              'instance array size is greater than `maxItems` value',
+              keyword: 'maxItems',
+              instance_size: size,
+            )
+          end
+        end
+      end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # MAX_ITEMS = element_map
+  end # module Schema::Elements
+
+  module Schema::Elements
+    MIN_ITEMS = element_map do
+      Schema::Element.new(keyword: 'minItems') do |element|
+        element.add_action(:validate) do
+      if keyword?('minItems')
+        value = schema_content['minItems']
+        # The value of this keyword MUST be a non-negative integer.
+        if internal_integer?(value) && value >= 0
+          if instance.respond_to?(:to_ary)
+            # An array instance is valid against "minItems" if its size is greater than, or equal to, the value of this keyword.
+            size = instance.to_ary.size
+            validate(
+              size >= value,
+              'validation.keyword.minItems.size_less',
+              'instance array size is less than `minItems` value',
+              keyword: 'minItems',
+              instance_size: size,
+            )
+          end
+        end
+      end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # MIN_ITEMS = element_map
+  end # module Schema::Elements
+
+  module Schema::Elements
+    UNIQUE_ITEMS = element_map do
+      Schema::Element.new(keyword: 'uniqueItems') do |element|
+        element.add_action(:validate) do
+      if keyword?('uniqueItems')
+        value = schema_content['uniqueItems']
+        # The value of this keyword MUST be a boolean.
+        if value == true
+          if instance.respond_to?(:to_ary)
+            # If it has boolean value true, the instance validates successfully if all of its elements are unique.
+            # TODO instance.tally.select { |_, count| count > 1 }.keys.freeze when all supported Hash.method_defined?(:tally)
+            duplicate_items = instance.group_by(&:itself).select { |_, v| v.size > 1 }.keys.freeze
+            validate(
+              duplicate_items.empty?,
+              'validation.keyword.uniqueItems.not_unique',
+              "instance array items are not unique with `uniqueItems` = true",
+              keyword: 'uniqueItems',
+              duplicate_items: duplicate_items,
+            )
+          end
+        end
+      end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # UNIQUE_ITEMS = element_map
+  end # module Schema::Elements
+end

data/lib/jsi/schema/elements/comment.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    COMMENT = element_map do
+      Schema::Element.new(keyword: '$comment') do |element|
+      end # Schema::Element.new
+    end # CONTENT_ENCODING = element_map
+  end # module Schema::Elements
+end

data/lib/jsi/schema/{validation → elements}/const.rb

@@ -1,20 +1,24 @@
 # frozen_string_literal: true
 
 module JSI
-  module Schema::Validation::Const
-    # @private
-    def internal_validate_const(result_builder)
+  module Schema::Elements
+    CONST = element_map do
+      Schema::Element.new(keyword: 'const') do |element|
+        element.add_action(:validate) do
       if keyword?('const')
         value = schema_content['const']
         # The value of this keyword MAY be of any type, including null.
         # An instance validates successfully against this keyword if its value is equal to the value of
         # the keyword.
-        result_builder.validate(
-          result_builder.instance == value,
+        validate(
+          instance == value,
+          'validation.keyword.const.not_equal',
           'instance is not equal to `const` value',
           keyword: 'const',
         )
       end
-    end
-  end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # CONST = element_map
+  end # module Schema::Elements
 end

data/lib/jsi/schema/elements/contains.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    CONTAINS = element_map do
+      Schema::Element.new(keyword: 'contains') do |element|
+        element.add_action(:subschema) do
+          if keyword?('contains')
+            #> The value of this keyword MUST be a valid JSON Schema.
+            cxt_yield(['contains'])
+          end
+        end # element.add_action(:subschema)
+
+        element.add_action(:child_applicate) do
+    if instance.respond_to?(:to_ary)
+      if keyword?('contains')
+        contains_schema = subschema(['contains'])
+
+        child_idx_valid = Hash.new { |h, i| h[i] = contains_schema.instance_valid?(instance[i]) }
+
+        if child_idx_valid[token]
+          child_schema_applicate(contains_schema)
+        else
+          instance_valid = instance.each_index.any? { |i| child_idx_valid[i] }
+
+          unless instance_valid
+            # invalid application: if contains_schema does not validate against any child, it applies to every child
+            child_schema_applicate(contains_schema)
+          end
+        end
+      end
+    end # if instance.respond_to?(:to_ary)
+        end # element.add_action(:child_applicate)
+
+        element.add_action(:validate) do
+          if keyword?('contains')
+            # An array instance is valid against "contains" if at least one of its elements is valid against
+            # the given schema.
+            if instance.respond_to?(:to_ary)
+              results = {}
+              instance.each_index do |i|
+                results[i] = child_subschema_validate(i, ['contains'])
+              end
+              child_results_validate(
+                results.each_value.any?(&:valid?),
+                'validation.keyword.contains.none',
+                "instance array does not contain any items valid against `contains` schema",
+                keyword: 'contains',
+                child_results: results,
+                # when invalid these are all false, but included for consistency with `contains` with min/max
+                instance_indexes_valid: results.inject({}) { |h, (i, r)| h.update({i => r.valid?}) }.freeze,
+              )
+            end
+          end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # CONTAINS = element_map
+  end # module Schema::Elements
+end