jsi-dev 0.0.8 → 0.0.9

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    ITEMS = element_map do
+      Schema::Element.new(keywords: %w(items additionalItems)) do |element|
+        element.add_action(:subschema) do
+          if keyword?('items')
+            #> The value of "items" MUST be either a valid JSON Schema or an array of valid JSON Schemas.
+            if keyword_value_ary?('items')
+              schema_content['items'].each_index do |i|
+                cxt_yield(['items', i])
+              end
+            else
+              cxt_yield(['items'])
+            end
+          end
+
+          if keyword?('additionalItems')
+            #> The value of "additionalItems" MUST be a valid JSON Schema.
+            cxt_yield(['additionalItems'])
+          end
+        end # element.add_action(:subschema)
+
+        element.add_action(:child_applicate) do
+    if instance.respond_to?(:to_ary)
+      if keyword?('items') && schema_content['items'].respond_to?(:to_ary)
+        if schema_content['items'].size > token
+          child_subschema_applicate(['items', token])
+        elsif keyword?('additionalItems')
+          child_subschema_applicate(['additionalItems'])
+        end
+      elsif keyword?('items')
+        child_subschema_applicate(['items'])
+      end
+    end # if instance.respond_to?(:to_ary)
+        end # element.add_action(:child_applicate)
+
+        element.add_action(:validate) do
+          if instance.respond_to?(:to_ary)
+            if keyword?('items')
+              #> The value of "items" MUST be either a valid JSON Schema or an array of valid JSON Schemas.
+              if schema_content['items'].respond_to?(:to_ary)
+                #> If "items" is an array of schemas, validation succeeds if each element of the instance
+                #> validates against the schema at the same position, if any.
+                items_results = {}
+                additionalItems_results = {}
+                instance.each_index do |i|
+                  if i < schema_content['items'].size
+                    items_results[i] = child_subschema_validate(i, ['items', i])
+                  elsif keyword?('additionalItems')
+                    additionalItems_results[i] = child_subschema_validate(i, ['additionalItems'])
+                  end
+                end
+                child_results_validate(
+                  items_results.each_value.all?(&:valid?),
+                  'validation.keyword.items.array.invalid',
+                  "instance array items are not all valid against corresponding `items` schemas",
+                  keyword: 'items',
+                  child_results: items_results,
+                  instance_indexes_valid: items_results.inject({}) { |h, (i, r)| h.update({i => r.valid?}) }.freeze,
+                )
+                child_results_validate(
+                  additionalItems_results.each_value.all?(&:valid?),
+                  'validation.keyword.additionalItems.invalid',
+                  "instance array items after `items` schemas are not all valid against `additionalItems` schema",
+                  keyword: 'additionalItems',
+                  child_results: additionalItems_results,
+                  instance_indexes_valid: additionalItems_results.inject({}) { |h, (i, r)| h.update({i => r.valid?}) }.freeze,
+                )
+              else
+                #> If "items" is a schema, validation succeeds if all elements in the array successfully
+                #> validate against that schema.
+                items_results = {}
+                instance.each_index do |i|
+                  items_results[i] = child_subschema_validate(i, ['items'])
+                end
+                child_results_validate(
+                  items_results.each_value.all?(&:valid?),
+                  'validation.keyword.items.schema.invalid',
+                  "instance array items are not all valid against `items` schema",
+                  keyword: 'items',
+                  child_results: items_results,
+                  instance_indexes_valid: items_results.inject({}) { |h, (i, r)| h.update({i => r.valid?}) }.freeze,
+                )
+              end
+            end
+          end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # ITEMS = element_map
+  end # module Schema::Elements
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    ITEMS_PREFIXED = element_map do
+      Schema::Element.new(keywords: %w(items prefixItems)) do |element|
+        element.add_action(:subschema) do
+          # https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-01#name-prefixitems
+          #> The value of "prefixItems" MUST be a non-empty array of valid JSON Schemas.
+          if keyword_value_ary?('prefixItems')
+            schema_content['prefixItems'].each_index do |i|
+              cxt_yield(['prefixItems', i])
+            end
+          end
+
+          # https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-01#name-items
+          #> The value of "items" MUST be a valid JSON Schema.
+          if keyword?('items')
+            cxt_yield(['items'])
+          end
+        end
+
+        element.add_action(:child_applicate) do
+          next if !instance.respond_to?(:to_ary)
+          if keyword_value_ary?('prefixItems') && schema_content['prefixItems'].size > token
+            child_subschema_applicate(['prefixItems', token])
+          elsif keyword?('items')
+            child_subschema_applicate(['items'])
+          end
+        end
+
+        element.add_action(:validate) do
+          next if !instance.respond_to?(:to_ary)
+          i = 0
+          if keyword_value_ary?('prefixItems')
+            prefixItems_results = {}
+
+            while i < schema_content['prefixItems'].size && i < instance.size
+              prefixItems_results[i] = child_subschema_validate(i, ['prefixItems', i])
+
+              i += 1
+            end
+
+            #> Validation succeeds if each element of the instance validates
+            #> against the schema at the same position, if any.
+            #> This keyword does not constrain the length of the array.
+            #> If the array is longer than this keyword's value, this keyword
+            #> validates only the prefix of matching length.
+            child_results_validate(
+              prefixItems_results.each_value.all?(&:valid?),
+              'validation.keyword.prefixItems.invalid',
+              "instance array items are not all valid against corresponding `prefixItems` schemas",
+              keyword: 'prefixItems',
+              child_results: prefixItems_results,
+              instance_indexes_valid: prefixItems_results.inject({}) { |h, (ri, r)| h.update({ri => r.valid?}) }.freeze,
+            )
+          end
+
+          if keyword?('items')
+            items_results = {}
+
+            while i < instance.size
+              #> This keyword applies its subschema to all instance elements at indexes
+              #> greater than the length of the "prefixItems" array in the same schema
+              #> object, as reported by the annotation result of that "prefixItems" keyword.
+              #> If no such annotation result exists, "items" applies its subschema to all instance array elements.
+              #> Note that the behavior of "items" without "prefixItems" is identical
+              #> to that of the schema form of "items" in prior drafts.
+              #> When "prefixItems" is present, the behavior of "items" is identical
+              #> to the former "additionalItems" keyword.
+              items_results[i] = child_subschema_validate(i, ['items'])
+
+              i += 1
+            end
+
+            if keyword_value_ary?('prefixItems')
+              error_key = 'validation.keyword.items.after_prefixItems.invalid'
+              error_msg = "instance array items after `prefixItems` are not all valid against `items` schema"
+            else
+              error_key = 'validation.keyword.items.invalid'
+              error_msg = "instance array items are not all valid against `items` schema"
+            end
+            child_results_validate(
+              items_results.each_value.all?(&:valid?),
+              error_key,
+              error_msg,
+              keyword: 'items',
+              child_results: items_results,
+              instance_indexes_valid: items_results.inject({}) { |h, (ri, r)| h.update({ri => r.valid?}) }.freeze,
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    NOT = element_map do
+      Schema::Element.new(keyword: 'not') do |element|
+        element.add_action(:subschema) do
+          if keyword?('not')
+            #> This keyword's value MUST be a valid JSON Schema.
+            cxt_yield(['not'])
+          end
+        end # element.add_action(:subschema)
+
+        element.add_action(:validate) do
+      if keyword?('not')
+        # This keyword's value MUST be a valid JSON Schema.
+        # An instance is valid against this keyword if it fails to validate successfully against the schema
+        # defined by this keyword.
+        not_valid = inplace_subschema_validate(['not']).valid?
+        validate(
+          !not_valid,
+          'validation.keyword.not.valid',
+          "instance is valid against `not` schema",
+          keyword: 'not',
+        )
+      end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # NOT = element_map
+  end # module Schema::Elements
+end

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    MULTIPLE_OF = element_map do
+      Schema::Element.new(keyword: 'multipleOf') do |element|
+        element.add_action(:validate) do
+      if keyword?('multipleOf')
+        value = schema_content['multipleOf']
+        # The value of "multipleOf" MUST be a number, strictly greater than 0.
+        if value.is_a?(Numeric) && value > 0
+          # A numeric instance is valid only if division by this keyword's value results in an integer.
+          if instance.is_a?(Numeric)
+            if instance.is_a?(Integer) && value.is_a?(Integer)
+              valid = instance % value == 0
+            else
+              quotient = instance / value
+              if quotient.finite?
+                valid = quotient % 1.0 == 0.0
+              else
+                valid = BigDecimal(instance, Float::DIG) % BigDecimal(value, Float::DIG) == 0
+              end
+            end
+            validate(
+              valid,
+              'validation.keyword.multipleOf.not_multiple',
+              'instance is not a multiple of `multipleOf` value',
+              keyword: 'multipleOf',
+            )
+          end
+        end
+      end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # MULTIPLE_OF = element_map
+  end # module Schema::Elements
+
+  module Schema::Elements
+    MAXIMUM = element_map do
+      Schema::Element.new(keyword: 'maximum') do |element|
+        element.add_action(:validate) do
+      if keyword?('maximum')
+        value = schema_content['maximum']
+        # The value of "maximum" MUST be a number, representing an inclusive upper limit for a numeric instance.
+        if value.is_a?(Numeric)
+          # If the instance is a number, then this keyword validates only if the instance is less than or
+          # exactly equal to "maximum".
+          if instance.is_a?(Numeric)
+            validate(
+              instance <= value,
+              'validation.keyword.maximum.greater',
+              "instance is greater than `maximum` value",
+              keyword: 'maximum',
+            )
+          end
+        end
+      end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # MAXIMUM = element_map
+  end # module Schema::Elements
+
+  module Schema::Elements
+    EXCLUSIVE_MAXIMUM = element_map do
+      Schema::Element.new(keyword: 'exclusiveMaximum') do |element|
+        element.add_action(:validate) do
+      if keyword?('exclusiveMaximum')
+        value = schema_content['exclusiveMaximum']
+        # The value of "exclusiveMaximum" MUST be number, representing an exclusive upper limit for a numeric instance.
+        if value.is_a?(Numeric)
+          # If the instance is a number, then the instance is valid only if it has a value strictly less than
+          # (not equal to) "exclusiveMaximum".
+          if instance.is_a?(Numeric)
+            validate(
+              instance < value,
+              'validation.keyword.exclusiveMaximum.greater_or_equal',
+              "instance is greater than or equal to `exclusiveMaximum` value",
+              keyword: 'exclusiveMaximum',
+            )
+          end
+        end
+      end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # EXCLUSIVE_MAXIMUM = element_map
+  end # module Schema::Elements
+
+  module Schema::Elements
+    MINIMUM = element_map do
+      Schema::Element.new(keyword: 'minimum') do |element|
+        element.add_action(:validate) do
+      if keyword?('minimum')
+        value = schema_content['minimum']
+        # The value of "minimum" MUST be a number, representing an inclusive lower limit for a numeric instance.
+        if value.is_a?(Numeric)
+          # If the instance is a number, then this keyword validates only if the instance is greater than or
+          # exactly equal to "minimum".
+          if instance.is_a?(Numeric)
+            validate(
+              instance >= value,
+              'validation.keyword.minimum.less',
+              "instance is less than `minimum` value",
+              keyword: 'minimum',
+            )
+          end
+        end
+      end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # MINIMUM = element_map
+  end # module Schema::Elements
+
+  module Schema::Elements
+    EXCLUSIVE_MINIMUM = element_map do
+      Schema::Element.new(keyword: 'exclusiveMinimum') do |element|
+        element.add_action(:validate) do
+      if keyword?('exclusiveMinimum')
+        value = schema_content['exclusiveMinimum']
+        # The value of "exclusiveMinimum" MUST be number, representing an exclusive lower limit for a numeric instance.
+        if value.is_a?(Numeric)
+          # If the instance is a number, then the instance is valid only if it has a value strictly greater
+          # than (not equal to) "exclusiveMinimum".
+          if instance.is_a?(Numeric)
+            validate(
+              instance > value,
+              'validation.keyword.exclusiveMaximum.less_or_equal',
+              "instance is less than or equal to `exclusiveMinimum` value",
+              keyword: 'exclusiveMinimum',
+            )
+          end
+        end
+      end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # EXCLUSIVE_MINIMUM = element_map
+  end # module Schema::Elements
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    MAXIMUM_BOOLEAN_EXCLUSIVE = element_map do
+      Schema::Element.new(keywords: %w(maximum exclusiveMaximum)) do |element|
+        element.add_action(:validate) do
+      if keyword?('maximum')
+        value = schema_content['maximum']
+        # The value of "maximum" MUST be a JSON number.
+        if value.is_a?(Numeric)
+          if instance.is_a?(Numeric)
+            # Successful validation depends on the presence and value of "exclusiveMaximum":
+            if schema_content['exclusiveMaximum'] == true
+              # if "exclusiveMaximum" has boolean value true, the instance is valid if it is strictly lower
+              # than the value of "maximum".
+              validate(
+                instance < value,
+                'validation.keyword.maximum.with_exclusiveMaximum.greater_or_equal',
+                "instance is greater than or equal to `maximum` value with `exclusiveMaximum` = true",
+                keyword: 'maximum',
+              )
+            else
+              # if "exclusiveMaximum" is not present, or has boolean value false, then the instance is
+              # valid if it is lower than, or equal to, the value of "maximum"
+              validate(
+                instance <= value,
+                'validation.keyword.maximum.greater',
+                "instance is greater than `maximum` value",
+                keyword: 'maximum',
+              )
+            end
+          end
+        end
+      end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # MAXIMUM_BOOLEAN_EXCLUSIVE = element_map
+  end # module Schema::Elements
+
+  module Schema::Elements
+    MINIMUM_BOOLEAN_EXCLUSIVE = element_map do
+      Schema::Element.new(keywords: %w(minimum exclusiveMinimum)) do |element|
+        element.add_action(:validate) do
+      if keyword?('minimum')
+        value = schema_content['minimum']
+        # The value of "minimum" MUST be a JSON number.
+        if value.is_a?(Numeric)
+          if instance.is_a?(Numeric)
+            # Successful validation depends on the presence and value of "exclusiveMinimum":
+            if schema_content['exclusiveMinimum'] == true
+              # if "exclusiveMinimum" is present and has boolean value true, the instance is valid if it is
+              # strictly greater than the value of "minimum".
+              validate(
+                instance > value,
+                'validation.keyword.minimum.with_exclusiveMinimum.less_or_equal',
+                "instance is less than or equal to `minimum` value with `exclusiveMinimum` = true",
+                keyword: 'minimum',
+              )
+            else
+              # if "exclusiveMinimum" is not present, or has boolean value false, then the instance is
+              # valid if it is greater than, or equal to, the value of "minimum"
+              validate(
+                instance >= value,
+                'validation.keyword.minimum.less',
+                "instance is less than `minimum` value",
+                keyword: 'minimum',
+              )
+            end
+          end
+        end
+      end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # MINIMUM_BOOLEAN_EXCLUSIVE = element_map
+  end # module Schema::Elements
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    MAX_PROPERTIES = element_map do
+      Schema::Element.new(keyword: 'maxProperties') do |element|
+        element.add_action(:validate) do
+      if keyword?('maxProperties')
+        value = schema_content['maxProperties']
+        # The value of this keyword MUST be a non-negative integer.
+        if internal_integer?(value) && value >= 0
+          if instance.respond_to?(:to_hash)
+            # An object instance is valid against "maxProperties" if its number of properties is less than, or equal to, the value of this keyword.
+            size = instance.size
+            validate(
+              size <= value,
+              'validation.keyword.maxProperties.properties_count_greater',
+              "instance object properties count is greater than `maxProperties` value",
+              keyword: 'maxProperties',
+              instance_properties_count: size,
+            )
+          end
+        end
+      end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # MAX_PROPERTIES = element_map
+  end # module Schema::Elements
+
+  module Schema::Elements
+    MIN_PROPERTIES = element_map do
+      Schema::Element.new(keyword: 'minProperties') do |element|
+        element.add_action(:validate) do
+      if keyword?('minProperties')
+        value = schema_content['minProperties']
+        # The value of this keyword MUST be a non-negative integer.
+        if internal_integer?(value) && value >= 0
+          if instance.respond_to?(:to_hash)
+            # An object instance is valid against "minProperties" if its number of properties is greater than, or equal to, the value of this keyword.
+            size = instance.size
+            validate(
+              size >= value,
+              'validation.keyword.minProperties.properties_count_less',
+              "instance object properties count is less than `minProperties` value",
+              keyword: 'minProperties',
+              instance_properties_count: size,
+            )
+          end
+        end
+      end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # MIN_PROPERTIES = element_map
+  end # module Schema::Elements
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    PATTERN = element_map do
+      Schema::Element.new(keyword: 'pattern') do |element|
+        element.add_action(:validate) do
+      if keyword?('pattern')
+        value = schema_content['pattern']
+        # The value of this keyword MUST be a string.
+        if value.respond_to?(:to_str)
+          if instance.respond_to?(:to_str)
+            begin
+              # This string SHOULD be a valid regular expression, according to the ECMA 262 regular expression
+              # dialect.
+              # TODO
+              regexp = Regexp.new(value)
+              #> A string instance is considered valid if the regular expression matches the instance successfully.
+              validate(
+                regexp.match(instance),
+                'validation.keyword.pattern.not_match',
+                'instance string does not match `pattern` regular expression value',
+                keyword: 'pattern',
+              )
+            rescue RegexpError
+              # cannot validate
+            end
+          end
+        end
+      end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # PATTERN = element_map
+  end # module Schema::Elements
+end

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    PROPERTIES = element_map do
+      Schema::Element.new(keywords: %w(properties patternProperties additionalProperties)) do |element|
+        element.add_action(:subschema) do
+          #> The value of "properties" MUST be an object.
+          if keyword_value_hash?('properties')
+            schema_content['properties'].each_key do |property_name|
+              #> Each value of this object MUST be a valid JSON Schema.
+              cxt_yield(['properties', property_name])
+            end
+          end
+
+          #> The value of "patternProperties" MUST be an object.
+          if keyword_value_hash?('patternProperties')
+            schema_content['patternProperties'].each_key do |pattern|
+              #> Each property value of this object MUST be a valid JSON Schema.
+              cxt_yield(['patternProperties', pattern])
+            end
+          end
+
+          if keyword?('additionalProperties')
+            #> The value of "additionalProperties" MUST be a valid JSON Schema.
+            cxt_yield(['additionalProperties'])
+          end
+        end # element.add_action(:subschema)
+
+        element.add_action(:described_object_property_names) do
+          next if !keyword_value_hash?('properties')
+          schema_content['properties'].each_key(&block)
+        end
+
+        element.add_action(:child_applicate) do
+    if instance.respond_to?(:to_hash)
+      apply_additional = true
+      if keyword?('properties') && schema_content['properties'].respond_to?(:to_hash) && schema_content['properties'].key?(token)
+        apply_additional = false
+        child_subschema_applicate(['properties', token])
+      end
+      if keyword?('patternProperties') && schema_content['patternProperties'].respond_to?(:to_hash)
+        schema_content['patternProperties'].each_key do |pattern|
+          if pattern.respond_to?(:to_str) && token.to_s =~ Regexp.new(pattern) # TODO map pattern to ruby syntax
+            apply_additional = false
+            child_subschema_applicate(['patternProperties', pattern])
+          end
+        end
+      end
+      if apply_additional && keyword?('additionalProperties')
+        child_subschema_applicate(['additionalProperties'])
+      end
+    end # if instance.respond_to?(:to_hash)
+        end # element.add_action(:child_applicate)
+
+        element.add_action(:validate) do
+          evaluated_property_names = Set[]
+
+          if keyword?('properties')
+            value = schema_content['properties']
+            # The value of "properties" MUST be an object. Each value of this object MUST be a valid JSON Schema.
+            if value.respond_to?(:to_hash)
+              # Validation succeeds if, for each name that appears in both the instance and as a name within this
+              # keyword's value, the child instance for that name successfully validates against the corresponding
+              # schema.
+              if instance.respond_to?(:to_hash)
+                results = {}
+                instance.each_key do |property_name|
+                  if value.key?(property_name)
+                    evaluated_property_names << property_name
+                    results[property_name] = child_subschema_validate(property_name, ['properties', property_name])
+                  end
+                end
+                child_results_validate(
+                  results.each_value.all?(&:valid?),
+                  'validation.keyword.properties.invalid',
+                  "instance object properties are not all valid against corresponding `properties` schemas",
+                  keyword: 'properties',
+                  child_results: results,
+                  instance_properties_valid: results.inject({}) { |h, (k, r)| h.update({k => r.valid?}) }.freeze,
+                )
+              end
+            end
+          end
+
+          if keyword?('patternProperties')
+            value = schema_content['patternProperties']
+            # The value of "patternProperties" MUST be an object. Each property name of this object SHOULD be a
+            # valid regular expression, according to the ECMA 262 regular expression dialect. Each property value
+            # of this object MUST be a valid JSON Schema.
+            if value.respond_to?(:to_hash)
+              # Validation succeeds if, for each instance name that matches any regular expressions that appear as
+              # a property name in this keyword's value, the child instance for that name successfully validates
+              # against each schema that corresponds to a matching regular expression.
+              if instance.respond_to?(:to_hash)
+                results = {}
+                instance.each_key do |property_name|
+                  value.each_key do |value_property_pattern|
+                    begin
+                      # TODO ECMA 262
+                      if value_property_pattern.respond_to?(:to_str) && Regexp.new(value_property_pattern).match(property_name.to_s)
+                        evaluated_property_names << property_name
+                        results[property_name] = child_subschema_validate(property_name, ['patternProperties', value_property_pattern])
+                      end
+                    rescue ::RegexpError
+                      # cannot validate
+                    end
+                  end
+                end
+                child_results_validate(
+                  results.each_value.all?(&:valid?),
+                  'validation.keyword.patternProperties.invalid',
+                  "instance object properties are not all valid against matching `patternProperties` schemas",
+                  keyword: 'patternProperties',
+                  child_results: results,
+                  instance_properties_valid: results.inject({}) { |h, (k, r)| h.update({k => r.valid?}) }.freeze,
+                )
+              end
+            end
+          end
+
+          if keyword?('additionalProperties')
+            # The value of "additionalProperties" MUST be a valid JSON Schema.
+            if instance.respond_to?(:to_hash)
+              results = {}
+              instance.each_key do |property_name|
+                if !evaluated_property_names.include?(property_name)
+                  results[property_name] = child_subschema_validate(property_name, ['additionalProperties'])
+                end
+              end
+              child_results_validate(
+                results.each_value.all?(&:valid?),
+                'validation.keyword.additionalProperties.invalid',
+                "instance object additional properties are not all valid against `additionalProperties` schema",
+                keyword: 'additionalProperties',
+                child_results: results,
+                instance_properties_valid: results.inject({}) { |h, (k, r)| h.update({k => r.valid?}) }.freeze,
+              )
+            end
+          end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # PROPERTIES = element_map
+  end # module Schema::Elements
+end