jsi-dev 0.0.8 → 0.0.9

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    PROPERTY_NAMES = element_map do
+      Schema::Element.new(keyword: 'propertyNames') do |element|
+        element.add_action(:subschema) do
+          if keyword?('propertyNames')
+            #> The value of "propertyNames" MUST be a valid JSON Schema.
+            cxt_yield(['propertyNames'])
+          end
+        end # element.add_action(:subschema)
+
+        element.add_action(:propertyNames) do
+          cxt_yield(subschema(['propertyNames'])) if keyword?('propertyNames')
+        end
+
+        element.add_action(:validate) do
+      if keyword?('propertyNames')
+        # The value of "propertyNames" MUST be a valid JSON Schema.
+        #
+        # If the instance is an object, this keyword validates if every property name in the instance
+        # validates against the provided schema. Note the property name that the schema is testing will
+        # always be a string.
+        if instance.respond_to?(:to_hash)
+          results = {}
+          instance.each_key do |property_name|
+            results[property_name] = subschema(['propertyNames']).internal_validate_instance(
+              Ptr[],
+              property_name,
+              validate_only: validate_only,
+            )
+          end
+          validate(
+            results.each_value.all?(&:valid?),
+            'validation.keyword.propertyNames.invalid',
+            "instance object property names are not all valid against `propertyNames` schema",
+            keyword: 'propertyNames',
+            results: results.each_value,
+            instance_property_names_valid: results.inject({}) { |h, (k, r)| h.update({k => r.valid?}) }.freeze,
+          )
+        end
+      end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # PROPERTY_NAMES = element_map
+  end # module Schema::Elements
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    # exclusive [Boolean]: whether to abort invocation of subsequent actions when a $ref is evaluated
+    REF = element_map do |exclusive: |
+      Schema::Element.new(keyword: '$ref') do |element|
+        if exclusive
+          # $ref must come before all other elements to abort evaluation
+          element.required_before_elements { |_| true }
+
+          actions_to_abort = [
+            :id,
+            :id_without_fragment,
+            :anchor,
+          ]
+          actions_to_abort.each do |action|
+            element.add_action(action) { self.abort = true if keyword?('$ref') }
+          end
+        end
+
+        resolve_ref = proc do
+          next if !keyword_value_str?('$ref')
+          ref = schema.schema_ref(schema_content['$ref'])
+          resolved_schema = ref.resolve.with_dynamic_scope_from(schema)
+          [resolved_schema, ref]
+        end
+
+        element.add_action(:inplace_applicate) do
+          resolved_schema, ref = *instance_exec(&resolve_ref) || next
+
+          inplace_schema_applicate(resolved_schema, ref: ref)
+
+          if exclusive
+            self.abort = true
+          end
+        end # element.add_action(:inplace_applicate)
+
+        element.add_action(:validate) do
+                resolved_schema, schema_ref = *instance_exec(&resolve_ref) || next
+
+                ref_result = resolved_schema.internal_validate_instance(
+                  instance_ptr,
+                  instance_document,
+                  validate_only: validate_only,
+                  visited_refs: Util.add_visited_ref(visited_refs, schema_ref),
+                )
+                inplace_results_validate(
+                  ref_result.valid?,
+                  'validation.keyword.$ref.invalid',
+                  "instance is not valid against the schema referenced by `$ref`",
+                  keyword: '$ref',
+                  results: [ref_result],
+                )
+                if exclusive
+                  self.abort = true
+                end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # REF = element_map
+  end # module Schema::Elements
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    REQUIRED = element_map do
+      Schema::Element.new(keyword: 'required') do |element|
+        element.add_action(:described_object_property_names) do
+          next if !keyword_value_ary?('required')
+          schema_content['required'].each(&block)
+        end
+
+        element.add_action(:validate) do
+      if keyword?('required')
+        value = schema_content['required']
+        # The value of this keyword MUST be an array. Elements of this array, if any, MUST be strings, and MUST be unique.
+        if value.respond_to?(:to_ary)
+          if instance.respond_to?(:to_hash)
+            # An object instance is valid against this keyword if every item in the array is the name of a property in the instance.
+            missing_required = value.reject { |property_name| instance.key?(property_name) }.freeze
+            validate(
+              missing_required.empty?,
+              'validation.keyword.required.missing_property_names',
+              'instance object does not contain all property names specified by `required` value',
+              keyword: 'required',
+              missing_required_property_names: missing_required,
+            )
+          end
+        end
+      end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # REQUIRED = element_map
+  end # module Schema::Elements
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    SELF = element_map do
+      Schema::Element.new do |element|
+        element.add_action(:inplace_applicate) do
+          inplace_schema_applicate(schema)
+        end
+
+        element.add_action(:validate) do
+          #> boolean schemas are equivalent to the following behaviors:
+          #>
+          #> true: Always passes validation, as if the empty schema {}
+          #>
+          #> false: Always fails validation, as if the schema { "not":{} }
+          if schema_content == false
+            validate(false, 'validation.false_schema', "instance is not valid against `false` schema")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    ALL_OF = element_map do
+      Schema::Element.new(keyword: 'allOf') do |element|
+        element.add_action(:subschema) do
+          #> This keyword's value MUST be a non-empty array.
+          if keyword_value_ary?('allOf')
+            schema_content['allOf'].each_index do |i|
+              #> Each item of the array MUST be a valid JSON Schema.
+              cxt_yield(['allOf', i])
+            end
+          end
+        end # element.add_action(:subschema)
+
+        element.add_action(:inplace_applicate) do
+      if keyword?('allOf') && schema_content['allOf'].respond_to?(:to_ary)
+        schema_content['allOf'].each_index do |i|
+          inplace_subschema_applicate(['allOf', i])
+        end
+      end
+        end # element.add_action(:inplace_applicate)
+
+        element.add_action(:validate) do
+          if keyword?('allOf')
+            value = schema_content['allOf']
+            # This keyword's value MUST be a non-empty array. Each item of the array MUST be a valid JSON Schema.
+            if value.respond_to?(:to_ary)
+              # An instance validates successfully against this keyword if it validates successfully against all
+              # schemas defined by this keyword's value.
+              allOf_results = value.each_index.map do |i|
+                inplace_subschema_validate(['allOf', i])
+              end
+              inplace_results_validate(
+                allOf_results.all?(&:valid?),
+                'validation.keyword.allOf.not_all_valid',
+                "instance is not valid against all `allOf` schemas",
+                keyword: 'allOf',
+                results: allOf_results,
+                allOf_indexes_valid: allOf_results.each_with_index.inject({}) { |h, (r, i)| h.update({i => r.valid?}) }.freeze,
+              )
+            end
+          end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # ALL_OF = element_map
+  end # module Schema::Elements
+
+  module Schema::Elements
+    ANY_OF = element_map do
+      Schema::Element.new(keyword: 'anyOf') do |element|
+        element.add_action(:subschema) do
+          #> This keyword's value MUST be a non-empty array.
+          if keyword_value_ary?('anyOf')
+            schema_content['anyOf'].each_index do |i|
+              #> Each item of the array MUST be a valid JSON Schema.
+              cxt_yield(['anyOf', i])
+            end
+          end
+        end # element.add_action(:subschema)
+
+        element.add_action(:inplace_application_requires_instance) { cxt_yield(true) if keyword?('anyOf') }
+
+        element.add_action(:inplace_applicate) do
+      if keyword?('anyOf') && schema_content['anyOf'].respond_to?(:to_ary)
+        anyOf = schema_content['anyOf'].each_index.map { |i| subschema(['anyOf', i]) }
+        validOf = anyOf.select { |schema| schema.instance_valid?(instance) }
+        if !validOf.empty?
+          applicators = validOf
+        else
+          # invalid application: if none of the anyOf were valid, we apply them all
+          applicators = anyOf
+        end
+
+        applicators.each do |applicator|
+          inplace_schema_applicate(applicator)
+        end
+      end
+        end # element.add_action(:inplace_applicate)
+
+        element.add_action(:validate) do
+          if keyword?('anyOf')
+            value = schema_content['anyOf']
+            # This keyword's value MUST be a non-empty array. Each item of the array MUST be a valid JSON Schema.
+            if value.respond_to?(:to_ary)
+              # An instance validates successfully against this keyword if it validates successfully against at
+              # least one schema defined by this keyword's value.
+              # Note that when annotations are being collected, all subschemas MUST be examined so that
+              # annotations are collected from each subschema that validates successfully.
+              anyOf_results = value.each_index.map do |i|
+                inplace_subschema_validate(['anyOf', i])
+              end
+              inplace_results_validate(
+                anyOf_results.any?(&:valid?),
+                'validation.keyword.anyOf.not_any_valid',
+                "instance is not valid against any `anyOf` schema",
+                keyword: 'anyOf',
+                results: anyOf_results,
+                # when invalid these are all false, but included for consistency with allOf/oneOf
+                anyOf_indexes_valid: anyOf_results.each_with_index.inject({}) { |h, (r, i)| h.update({i => r.valid?}) }.freeze,
+              )
+            end
+          end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # ANY_OF = element_map
+  end # module Schema::Elements
+
+  module Schema::Elements
+    ONE_OF = element_map do
+      Schema::Element.new(keyword: 'oneOf') do |element|
+        element.add_action(:subschema) do
+          #> This keyword's value MUST be a non-empty array.
+          if keyword_value_ary?('oneOf')
+            schema_content['oneOf'].each_index do |i|
+              #> Each item of the array MUST be a valid JSON Schema.
+              cxt_yield(['oneOf', i])
+            end
+          end
+        end # element.add_action(:subschema)
+
+        element.add_action(:inplace_application_requires_instance) { cxt_yield(true) if keyword?('oneOf') }
+
+        element.add_action(:inplace_applicate) do
+      if keyword?('oneOf') && schema_content['oneOf'].respond_to?(:to_ary)
+        oneOf_idxs = schema_content['oneOf'].each_index
+        subschema_idx_valid = Hash.new { |h, i| h[i] = subschema(['oneOf', i]).instance_valid?(instance) }
+        # count up to 2 `oneOf` subschemas which `instance` validates against
+        nvalid = oneOf_idxs.inject(0) { |n, i| n <= 1 && subschema_idx_valid[i] ? n + 1 : n }
+        if nvalid != 0
+          applicator_idxs = oneOf_idxs.select { |i| subschema_idx_valid[i] }
+        else
+          # invalid application: if none of the oneOf were valid, we apply them all.
+          # note: invalid application does not apply when multiple oneOfs validate.
+          applicator_idxs = oneOf_idxs
+        end
+
+        applicator_idxs.each do |i|
+          inplace_subschema_applicate(['oneOf', i])
+        end
+      end
+        end # element.add_action(:inplace_applicate)
+
+        element.add_action(:validate) do
+          if keyword?('oneOf')
+            value = schema_content['oneOf']
+            # This keyword's value MUST be a non-empty array. Each item of the array MUST be a valid JSON Schema.
+            if value.respond_to?(:to_ary)
+              # An instance validates successfully against this keyword if it validates successfully against
+              # exactly one schema defined by this keyword's value.
+              oneOf_results = value.each_index.map do |i|
+                inplace_subschema_validate(['oneOf', i])
+              end
+              if oneOf_results.none?(&:valid?)
+                inplace_results_validate(
+                  false,
+                  'validation.keyword.oneOf.not_any_valid',
+                  "instance is not valid against any `oneOf` schema",
+                  keyword: 'oneOf',
+                  results: oneOf_results,
+                  oneOf_indexes_valid: oneOf_results.each_with_index.inject({}) { |h, (r, i)| h.update({i => r.valid?}) }.freeze,
+                )
+              else
+                inplace_results_validate(
+                  oneOf_results.select(&:valid?).size == 1,
+                  'validation.keyword.oneOf.multiple_valid',
+                  "instance is valid against multiple `oneOf` schemas",
+                  keyword: 'oneOf',
+                  results: oneOf_results,
+                  oneOf_indexes_valid: oneOf_results.each_with_index.inject({}) { |h, (r, i)| h.update({i => r.valid?}) }.freeze,
+                )
+              end
+            end
+          end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # ONE_OF = element_map
+  end # module Schema::Elements
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    MAX_LENGTH = element_map do
+      Schema::Element.new(keyword: 'maxLength') do |element|
+        element.add_action(:validate) do
+      if keyword?('maxLength')
+        value = schema_content['maxLength']
+        # The value of this keyword MUST be a non-negative integer.
+        if internal_integer?(value) && value >= 0
+          if instance.respond_to?(:to_str)
+            # A string instance is valid against this keyword if its length is less than, or equal to, the
+            # value of this keyword.
+            length = instance.to_str.length
+            validate(
+              length <= value,
+              'validation.keyword.maxLength.length_greater',
+              "instance string length is greater than `maxLength` value",
+              keyword: 'maxLength',
+              instance_length: length,
+            )
+          end
+        end
+      end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # MAX_LENGTH = element_map
+  end # module Schema::Elements
+
+  module Schema::Elements
+    MIN_LENGTH = element_map do
+      Schema::Element.new(keyword: 'minLength') do |element|
+        element.add_action(:validate) do
+      if keyword?('minLength')
+        value = schema_content['minLength']
+        # The value of this keyword MUST be a non-negative integer.
+        if internal_integer?(value) && value >= 0
+          if instance.respond_to?(:to_str)
+            # A string instance is valid against this keyword if its length is greater than, or equal to, the
+            # value of this keyword.
+            length = instance.to_str.length
+            validate(
+              length >= value,
+              'validation.keyword.minLength.length_less',
+              "instance string length is less than `minLength` value",
+              keyword: 'minLength',
+              instance_length: length,
+            )
+          end
+        end
+      end
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # MIN_LENGTH = element_map
+  end # module Schema::Elements
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    #> String values MUST be one of the six primitive types
+    #> ("null", "boolean", "object", "array", "number", or "string"),
+    #> or "integer"
+    instance_types = {
+      'null' => proc { instance == nil },
+      'boolean' => proc { instance == true || instance == false },
+      'object' => proc { instance.respond_to?(:to_hash) },
+      'array' => proc { instance.respond_to?(:to_ary) },
+      'string' => proc { instance.respond_to?(:to_str) },
+      'number' => proc { instance.is_a?(Numeric) },
+      'integer' => proc { internal_integer?(instance) },
+    }.freeze
+
+    TYPE = element_map do
+      Schema::Element.new(keyword: 'type') do |element|
+        element.add_action(:validate) do
+          next if !keyword?('type')
+          value = schema_content['type']
+          #> The value of this keyword MUST be either a string or an array. If it is an array, elements of
+          #> the array MUST be strings and MUST be unique.
+          types = value.respond_to?(:to_ary) ? value : [value]
+          matched_type = types.any? do |type|
+              if instance_types.key?(type)
+                instance_exec(&instance_types[type])
+              else
+                false
+              end
+          end
+          validate(
+            matched_type,
+            'validation.keyword.type.not_match',
+            'instance type does not match `type` value',
+            keyword: 'type',
+          )
+        end # element.add_action(:validate)
+      end # Schema::Element.new
+    end # TYPE = element_map
+  end # module Schema::Elements
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    # https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-01#name-unevaluateditems
+    UNEVALUATED_ITEMS = element_map do
+      Schema::Element.new(keyword: 'unevaluatedItems') do |element|
+        element.depends_on_elements do |other_element|
+          other_element.invokes?(:inplace_applicate) ||
+            (other_element.invokes?(:child_applicate) && !other_element.invokes?(:application_requires_evaluated))
+        end
+
+        element.add_action(:application_requires_evaluated) { cxt_yield(true) if keyword?('unevaluatedItems') }
+
+        element.add_action(:subschema) do
+          #> The value of "unevaluatedItems" MUST be a valid JSON Schema.
+          if keyword?('unevaluatedItems')
+            cxt_yield(['unevaluatedItems'])
+          end
+        end
+
+        element.add_action(:child_applicate) do
+          if instance.respond_to?(:to_ary)
+            if keyword?('unevaluatedItems')
+              if !evaluated
+                child_subschema_applicate(['unevaluatedItems'])
+              end
+            end
+          end
+        end
+
+        element.add_action(:validate) do
+          next if !keyword?('unevaluatedItems')
+          next if !instance.respond_to?(:to_ary)
+          results = {}
+          instance.each_index do |i|
+            if !result.evaluated_tokens.include?(i)
+              results[i] = child_subschema_validate(i, ['unevaluatedItems'])
+            end
+          end
+
+          child_results_validate(
+            results.each_value.all?(&:valid?),
+            'validation.keyword.unevaluatedItems.invalid',
+            "instance array unevaluated items are not all valid against `unevaluatedItems` schema",
+            keyword: 'unevaluatedItems',
+            child_results: results,
+            instance_indexes_valid: results.inject({}) { |h, (i, r)| h.update({i => r.valid?}) }.freeze,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Elements
+    # https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-01#name-unevaluatedproperties
+    UNEVALUATED_PROPERTIES = element_map do
+      Schema::Element.new(keyword: 'unevaluatedProperties') do |element|
+        element.depends_on_elements do |other_element|
+          other_element.invokes?(:inplace_applicate) ||
+            (other_element.invokes?(:child_applicate) && !other_element.invokes?(:application_requires_evaluated))
+        end
+
+        element.add_action(:application_requires_evaluated) { cxt_yield(true) if keyword?('unevaluatedProperties') }
+
+        element.add_action(:subschema) do
+          #> The value of "unevaluatedProperties" MUST be a valid JSON Schema.
+          if keyword?('unevaluatedProperties')
+            cxt_yield(['unevaluatedProperties'])
+          end
+        end
+
+        element.add_action(:child_applicate) do
+          if instance.respond_to?(:to_hash)
+            if keyword?('unevaluatedProperties')
+              if !evaluated
+                child_subschema_applicate(['unevaluatedProperties'])
+              end
+            end
+          end
+        end
+
+        element.add_action(:validate) do
+          next if !keyword?('unevaluatedProperties')
+          next if !instance.respond_to?(:to_hash)
+          results = {}
+          instance.each_key do |property_name|
+            if !result.evaluated_tokens.include?(property_name)
+              results[property_name] = child_subschema_validate(property_name, ['unevaluatedProperties'])
+            end
+          end
+
+          child_results_validate(
+            results.each_value.all?(&:valid?),
+            'validation.keyword.unevaluatedProperties.invalid',
+            "instance object unevaluated properties are not all valid against `unevaluatedProperties` schema",
+            keyword: 'unevaluatedProperties',
+            child_results: results,
+            instance_properties_valid: results.inject({}) { |h, (k, r)| h.update({k => r.valid?}) }.freeze,
+          )
+        end
+      end
+    end
+  end
+end

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

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

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

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