jsi-dev 0.0.8 → 0.0.9

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    CONTAINS_MINMAX = element_map do
+      Schema::Element.new(keywords: ['contains', 'minContains', 'maxContains']) 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
+          minContains = keyword_value_numeric?('minContains') ? schema_content['minContains'] : 1
+          child_valid_count = instance.each_index.inject(0) { |n, i| n < minContains && child_idx_valid[i] ? n + 1 : n }
+
+          if child_valid_count < minContains
+            # invalid application: if contains_schema does not validate against `minContains` children,
+            # it applies to every child.
+            # note: this does not consider maxContains; a validation error from maxContains is not from any
+            # validation error of child application (which invalid application is intended to preserve), but
+            # rather from too few failures in child application. children that don't validate against contains
+            # are correctly not described by contains when contains validation failure comes from maxContains.
+            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')
+            # https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-01#name-contains
+            #> An array instance is valid against "contains" if at least one of its elements is valid against
+            #> the given schema, except when "minContains" is present and has a value of 0,
+            #> in which case an array instance MUST be considered valid against the "contains" keyword,
+            #> even if none 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_valid_count = instance.each_index.count { |i| results[i].valid? }
+
+              minContains = keyword_value_numeric?('minContains') ? schema_content['minContains'] : nil
+              if minContains
+                # https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#name-mincontains
+                child_results_validate(
+                  child_valid_count >= minContains,
+                  'validation.keyword.contains.fewer_than_minContains',
+                  "instance array contains fewer items that are valid against `contains` schema than `minContains` value",
+                  keyword: 'contains',
+                  child_results: results,
+                )
+              else
+                child_results_validate(
+                  child_valid_count > 0,
+                  'validation.keyword.contains.none',
+                  "instance array does not contain any items that are valid against `contains` schema",
+                  keyword: 'contains',
+                  child_results: results,
+                )
+              end
+
+              maxContains = keyword_value_numeric?('maxContains') ? schema_content['maxContains'] : nil
+              if maxContains
+                # https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#name-maxcontains
+                validate(
+                  child_valid_count <= maxContains,
+                  'validation.keyword.maxContains.more_than_maxContains',
+                  "instance array contains more items that are valid against `contains` schema than `maxContains` value",
+                  keyword: 'maxContains',
+                )
+              end
+            end
+          end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # CONTAINS_MINMAX = element_map
+  end # module Schema::Elements
+end

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

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

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

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

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    CONTENT_SCHEMA = element_map do
+      Schema::Element.new(keyword: 'contentSchema') do |element|
+        element.add_action(:subschema) do
+          if keyword?('contentSchema')
+            #> The value of this property MUST be a valid JSON schema.
+            cxt_yield(['contentSchema'])
+          end
+        end # element.add_action(:subschema)
+      end # Schema::Element.new
+    end # CONTENT_SCHEMA = element_map
+  end # module Schema::Elements
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    DEFAULT = element_map do
+      Schema::Element.new(keyword: 'default') do |element|
+        element.add_action(:default) { cxt_yield(schema_content['default']) if keyword?('default') }
+      end # Schema::Element.new
+    end # DEFAULT = element_map
+  end # module Schema::Elements
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    DEFINITIONS = element_map do |keyword: |
+      Schema::Element.new(keyword: keyword) do |element|
+        element.add_action(:subschema) do
+          #> This keyword's value MUST be an object.
+          if keyword_value_hash?(keyword)
+            schema_content[keyword].each_key do |property_name|
+              #> Each member value of this object MUST be a valid JSON Schema.
+              cxt_yield([keyword, property_name])
+            end
+          end
+        end # element.add_action(:subschema)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    DEPENDENCIES = element_map do
+      Schema::Element.new(keyword: 'dependencies') do |element|
+        element.add_action(:subschema) do
+          #> This keyword's value MUST be an object.
+          if keyword_value_hash?('dependencies')
+            schema_content['dependencies'].each_pair do |property_name, dependency|
+              #> Each property specifies a dependency.
+              #> Each dependency value MUST be an array or a valid JSON Schema.
+              if !dependency.respond_to?(:to_ary)
+                cxt_yield(['dependencies', property_name])
+              end
+            end
+          end
+        end # element.add_action(:subschema)
+
+        element.add_action(:described_object_property_names) do
+          next if !keyword_value_hash?('dependencies')
+          schema_content['dependencies'].each do |property_name, dependency|
+            cxt_yield(property_name)
+            if dependency.respond_to?(:to_ary)
+              dependency.each(&block)
+            end
+          end
+        end
+
+        element.add_action(:inplace_application_requires_instance) do
+          next if !keyword_value_hash?('dependencies')
+          next if schema_content['dependencies'].each_value.all? { |dependency| dependency.respond_to?(:to_ary) }
+          cxt_yield(true)
+        end
+
+        element.add_action(:inplace_applicate) do
+          next if !keyword_value_hash?('dependencies')
+          next if schema_content['dependencies'].each_value.all? { |dependency| dependency.respond_to?(:to_ary) }
+          next if !instance.respond_to?(:to_hash)
+          #> This keyword's value MUST be an object. Each property specifies a dependency.  Each dependency
+          #> value MUST be an array or a valid JSON Schema.
+          schema_content['dependencies'].each_pair do |property_name, dependency|
+            if dependency.respond_to?(:to_ary)
+              # noop: array-form dependencies has no in-place applicator schema
+            else
+              # If the dependency value is a subschema, and the dependency key is a
+              # property in the instance, the entire instance must validate against
+              # the dependency value.
+              if instance.key?(property_name)
+                inplace_subschema_applicate(['dependencies', property_name])
+              end
+            end
+          end
+        end # element.add_action(:inplace_applicate)
+
+        element.add_action(:validate) do
+              #> This keyword's value MUST be an object. Each property specifies a dependency.  Each dependency
+              #> value MUST be an array or a valid JSON Schema.
+              next if !keyword_value_hash?('dependencies')
+              next if !instance.respond_to?(:to_hash)
+              schema_content['dependencies'].each_pair do |property_name, dependency|
+                if dependency.respond_to?(:to_ary)
+                  # If the dependency value is an array, each element in the array, if
+                  # any, MUST be a string, and MUST be unique.  If the dependency key is
+                  # a property in the instance, each of the items in the dependency value
+                  # must be a property that exists in the instance.
+                  if instance.respond_to?(:to_hash) && instance.key?(property_name)
+                    missing_required = dependency.reject { |name| instance.key?(name) }.freeze
+                    validate(
+                      missing_required.empty?,
+                      'validation.keyword.dependencies.dependent_required.missing_property_names',
+                      'instance object does not contain all dependent required property names specified by `dependencies` value',
+                      keyword: 'dependencies',
+                      property_name: property_name,
+                      missing_dependent_required_property_names: missing_required,
+                    )
+                  end
+                else
+                  # If the dependency value is a subschema, and the dependency key is a
+                  # property in the instance, the entire instance must validate against
+                  # the dependency value.
+                  if instance.key?(property_name)
+                    dependency_result = inplace_subschema_validate(['dependencies', property_name])
+                    inplace_results_validate(
+                      dependency_result.valid?,
+                      'validation.keyword.dependencies.dependent_schema.invalid',
+                      'instance object is not valid against the schema corresponding to a matched property name specified by `dependencies` value',
+                      keyword: 'dependencies',
+                      results: [dependency_result],
+                      property_name: property_name,
+                    )
+                  end
+                end
+              end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # DEPENDENCIES = element_map
+  end # module Schema::Elements
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    DEPENDENT_REQUIRED = element_map do
+      Schema::Element.new(keyword: 'dependentRequired') do |element|
+        element.add_action(:described_object_property_names) do
+          next if !keyword_value_hash?('dependentRequired')
+          schema_content['dependentRequired'].each do |property_name, dependent_property_names|
+            cxt_yield(property_name)
+            next if !dependent_property_names.respond_to?(:to_ary)
+            dependent_property_names.each(&block)
+          end
+        end
+
+        element.add_action(:validate) do
+          #> The value of this keyword MUST be an object.
+          next if !keyword_value_hash?('dependentRequired')
+          next if !instance.respond_to?(:to_hash)
+
+          #> This keyword specifies properties that are required if a specific other property is
+          #> present. Their requirement is dependent on the presence of the other property.
+          #
+          #> Validation succeeds if, for each name that appears in both the instance and as a name
+          #> within this keyword's value, every item in the corresponding array is also the name of
+          #> a property in the instance.
+          missing_dependent_required = {}
+          schema_content['dependentRequired'].each do |property_name, dependent_property_names|
+            #> Properties in this object, if any, MUST be arrays.
+            next if !dependent_property_names.respond_to?(:to_ary)
+            if instance.key?(property_name)
+              missing_required = dependent_property_names.reject { |name| instance.key?(name) }
+              unless missing_required.empty?
+                missing_dependent_required[property_name] = missing_required
+              end
+            end
+          end
+          validate(
+            missing_dependent_required.empty?,
+            'validation.keyword.dependentRequired.missing_property_names',
+            "instance object does not contain all dependent required property names specified by `dependentRequired`",
+            keyword: 'dependentRequired',
+            missing_dependent_required: missing_dependent_required,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    DEPENDENT_SCHEMAS = element_map do
+      Schema::Element.new(keyword: 'dependentSchemas') do |element|
+        element.add_action(:subschema) do
+          #> This keyword's value MUST be an object.
+          next if !keyword_value_hash?('dependentSchemas')
+
+          #> Each value in the object MUST be a valid JSON Schema.
+          schema_content['dependentSchemas'].each_key do |property_name|
+            cxt_yield(['dependentSchemas', property_name])
+          end
+        end
+
+        element.add_action(:described_object_property_names) do
+          next if !keyword_value_hash?('dependentSchemas')
+          schema_content['dependentSchemas'].each_key(&block)
+        end
+
+        element.add_action(:inplace_application_requires_instance) { cxt_yield(true) if keyword?('dependentSchemas') }
+
+        element.add_action(:inplace_applicate) do
+          #> This keyword's value MUST be an object.
+          next if !keyword_value_hash?('dependentSchemas')
+          next if !instance.respond_to?(:to_hash)
+
+          #> This keyword specifies subschemas that are evaluated if the
+          #> instance is an object and contains a certain property.
+          #
+          #> If the object key is a property in the instance, the entire instance must validate
+          #> against the subschema. Its use is dependent on the presence of the property.
+          schema_content['dependentSchemas'].each_key do |property_name|
+            if instance.key?(property_name)
+              inplace_subschema_applicate(['dependentSchemas', property_name])
+            end
+          end
+        end
+
+        element.add_action(:validate) do
+          #> This keyword's value MUST be an object.
+          next if !keyword_value_hash?('dependentSchemas')
+          next if !instance.respond_to?(:to_hash)
+
+          #> This keyword specifies subschemas that are evaluated if the
+          #> instance is an object and contains a certain property.
+          #
+          #> If the object key is a property in the instance, the entire instance must validate
+          #> against the subschema. Its use is dependent on the presence of the property.
+          results = {}
+          schema_content['dependentSchemas'].each_key do |property_name|
+            if instance.key?(property_name)
+              results[property_name] = inplace_subschema_validate(['dependentSchemas', property_name])
+            end
+          end
+          inplace_results_validate(
+            results.each_value.all?(&:valid?),
+            'validation.keyword.dependentSchemas.invalid',
+            "instance object is not valid against all schemas corresponding to matched property names specified by `dependentSchemas`",
+            keyword: 'dependentSchemas',
+            results: results.each_value,
+            dependentSchemas_properties_valid: results.inject({}) { |h, (k, r)| h.update({k => r.valid?}) }.freeze,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    DYNAMIC_REF = element_map do
+      Schema::Element.new(keyword: '$dynamicRef') do |element|
+        resolve_dynamicRef = proc do
+          next unless keyword_value_str?('$dynamicRef')
+
+          dynamic_anchor_map = schema.jsi_next_schema_dynamic_anchor_map
+
+          #> Resolved against the current URI base, it produces the URI used as the starting point for runtime resolution.
+          #> This initial resolution is safe to perform on schema load.
+          ref = schema.schema_ref(schema_content['$dynamicRef'])
+
+          initial_resolution = ref.resolve
+
+          #> If the initially resolved starting point URI includes a
+          #> fragment that was created by the "$dynamicAnchor" keyword,
+          resolve_dynamically = \
+            # did resolution resolve a fragment?
+            ref.ref_uri.fragment &&
+            # does the fragment correspond to a dynamicAnchor? (not a regular anchor, not a pointer)
+            initial_resolution.dialect_invoke_each(:dynamicAnchor).include?(ref.ref_uri.fragment) &&
+            # is the anchor in our dynamic_anchor_map?
+            dynamic_anchor_map.key?(ref.ref_uri.fragment)
+          if resolve_dynamically
+            #> the initial URI MUST be replaced by the URI (including the fragment)
+            #> for the outermost schema resource in the dynamic scope (Section 7.1)
+            #> that defines an identically named fragment with "$dynamicAnchor".
+
+            # our dynamic resolution doesn't use a stack of dynamic scope URIs.
+            # we replace the initially resolved resource with the resource from dynamic_anchor_map.
+
+            scope_schema, subptrs = dynamic_anchor_map[ref.ref_uri.fragment]
+            resolved_schema = subptrs.inject(scope_schema, &:subschema)
+          else
+            #> Otherwise, its behavior is identical to "$ref", and no runtime resolution is needed.
+            resolved_schema = initial_resolution
+          end
+
+          [resolved_schema.with_dynamic_scope_from(schema), ref]
+        end
+
+        element.add_action(:inplace_applicate) do
+          resolved_schema, ref = *instance_exec(&resolve_dynamicRef) || next
+          inplace_schema_applicate(resolved_schema, ref: ref)
+        end
+
+        element.add_action(:validate) do
+          resolved_schema, ref = *instance_exec(&resolve_dynamicRef) || next
+          ref_result = resolved_schema.internal_validate_instance(
+            instance_ptr,
+            instance_document,
+            validate_only: validate_only,
+            visited_refs: Util.add_visited_ref(visited_refs, ref),
+          )
+          inplace_results_validate(
+            ref_result.valid?,
+            'validation.keyword.$dynamicRef.invalid',
+            "instance is not valid against the schema referenced by `$dynamicRef`",
+            keyword: '$dynamicRef',
+            results: [ref_result],
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    ENUM = element_map do
+      Schema::Element.new(keyword: 'enum') do |element|
+        element.add_action(:validate) do
+      if keyword?('enum')
+        value = schema_content['enum']
+        #> The value of this keyword MUST be an array.
+        if value.respond_to?(:to_ary)
+          # An instance validates successfully against this keyword if its value is equal to one of the
+          # elements in this keyword's array value.
+          validate(
+            value.include?(instance),
+            'validation.keyword.enum.none_equal',
+            "instance is not equal to any `enum` item",
+            keyword: 'enum',
+          )
+        end
+      end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # ENUM = element_map
+  end # module Schema::Elements
+end

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

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

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

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

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    ID = element_map do |keyword: , fragment_is_anchor: |
+      Schema::Element.new(keyword: keyword) do |element|
+        element.add_action(:id) { cxt_yield(schema_content[keyword]) if keyword_value_str?(keyword) }
+
+        element.add_action(:id_without_fragment) do
+          next if !keyword_value_str?(keyword)
+          id_without_fragment = Util.uri(schema_content[keyword]).merge(fragment: nil)
+
+          if !id_without_fragment.empty?
+            cxt_yield(id_without_fragment)
+          end
+        end
+
+        if fragment_is_anchor
+          element.add_action(:anchor) do
+            next if !keyword_value_str?(keyword)
+            id_fragment = Util.uri(schema_content[keyword]).fragment
+            if id_fragment && !id_fragment.empty?
+              cxt_yield(id_fragment)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    IF_THEN_ELSE = element_map do
+      Schema::Element.new(keywords: %w(if then else)) do |element|
+        element.add_action(:subschema) do
+          if keyword?('if')
+            #> This keyword's value MUST be a valid JSON Schema.
+            cxt_yield(['if'])
+          end
+
+          if keyword?('then')
+            #> This keyword's value MUST be a valid JSON Schema.
+            cxt_yield(['then'])
+          end
+
+          if keyword?('else')
+            #> This keyword's value MUST be a valid JSON Schema.
+            cxt_yield(['else'])
+          end
+        end # element.add_action(:subschema)
+
+        element.add_action(:inplace_application_requires_instance) { cxt_yield(true) if keyword?('if') }
+
+        element.add_action(:inplace_applicate) do
+      if keyword?('if')
+        if subschema(['if']).instance_valid?(instance)
+          if collect_evaluated
+            inplace_subschema_applicate(['if'], applicate: false)
+          end
+          if keyword?('then')
+            inplace_subschema_applicate(['then'])
+          end
+        else
+          if keyword?('else')
+            inplace_subschema_applicate(['else'])
+          end
+        end
+      end
+        end # element.add_action(:inplace_applicate)
+
+        element.add_action(:validate) do
+          if keyword?('if')
+            # This keyword's value MUST be a valid JSON Schema.
+            # This validation outcome of this keyword's subschema has no direct effect on the overall validation
+            # result. Rather, it controls which of the "then" or "else" keywords are evaluated.
+            if_result = inplace_subschema_validate(['if'])
+
+            if if_result.valid?
+              result.evaluated_tokens.merge(if_result.evaluated_tokens)
+            end
+
+            if if_result.valid?
+              if keyword?('then')
+                then_result = inplace_subschema_validate(['then'])
+                inplace_results_validate(
+                  then_result.valid?,
+                  'validation.keyword.then.invalid',
+                  "instance is not valid against `then` schema after validating against `if` schema",
+                  keyword: 'if',
+                  results: [then_result],
+                )
+              end
+            else
+              if keyword?('else')
+                else_result = inplace_subschema_validate(['else'])
+                inplace_results_validate(
+                  else_result.valid?,
+                  'validation.keyword.else.invalid',
+                  "instance is not valid against `else` schema after not validating against `if` schema",
+                  keyword: 'if',
+                  results: [else_result],
+                )
+              end
+            end
+          end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # IF_THEN_ELSE = element_map
+  end # module Schema::Elements
+end

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

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

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

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