jsi 0.4.0 → 0.6.0

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Validation::Items
+    # @private
+    def internal_validate_items(result_builder)
+      if schema_content.key?('items')
+        value = schema_content['items']
+        # The value of "items" MUST be either a valid JSON Schema or an array of valid JSON Schemas.
+        if value.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.
+          if result_builder.instance.respond_to?(:to_ary)
+            results = {}
+            result_builder.instance.each_index do |i|
+              if i < value.size
+                results[i] = result_builder.child_subschema_validate(['items', i], [i])
+              elsif schema_content.key?('additionalItems')
+                results[i] = result_builder.child_subschema_validate(['additionalItems'], [i])
+              end
+            end
+            result_builder.validate(
+              results.values.all?(&:valid?),
+              'instance array items are not all valid against corresponding `items` or `additionalItems` schema values',
+              keyword: 'items',
+              results: results.values,
+            )
+          end
+        else
+          # If "items" is a schema, validation succeeds if all elements in the array successfully validate
+          # against that schema.
+          if result_builder.instance.respond_to?(:to_ary)
+            results = result_builder.instance.each_index.map do |i|
+              result_builder.child_subschema_validate(['items'], [i])
+            end
+            result_builder.validate(
+              results.all?(&:valid?),
+              'instance array items are not all valid against `items` schema value',
+              keyword: 'items',
+              results: results,
+            )
+          end
+          if schema_content.key?('additionalItems')
+            result_builder.schema_warning('`additionalItems` has no effect when adjacent `items` keyword is not an array', 'items')
+          end
+        end
+      else
+        if schema_content.key?('additionalItems')
+          result_builder.schema_warning('`additionalItems` has no effect without adjacent `items` keyword', 'items')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Validation::Not
+    # @private
+    def internal_validate_not(result_builder)
+      if schema_content.key?('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 = result_builder.inplace_subschema_validate(['not']).valid?
+        result_builder.validate(
+          !not_valid,
+          'instance is valid against the schema specified as `not` value',
+          keyword: 'not',
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Validation::MultipleOf
+    # @private
+    def internal_validate_multipleOf(result_builder)
+      if schema_content.key?('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 result_builder.instance.is_a?(Numeric)
+            if result_builder.instance.is_a?(Integer) && value.is_a?(Integer)
+              valid = result_builder.instance % value == 0
+            else
+              quotient = result_builder.instance / value
+              if quotient.finite?
+                valid = quotient % 1.0 == 0.0
+              else
+                valid = BigDecimal(result_builder.instance, Float::DIG) % BigDecimal(value, Float::DIG) == 0
+              end
+            end
+            result_builder.validate(
+              valid,
+              'instance is not a multiple of `multipleOf` value',
+              keyword: 'multipleOf',
+            )
+          end
+        else
+          result_builder.schema_error('`multipleOf` is not a number greater than 0', 'multipleOf')
+        end
+      end
+    end
+  end
+
+  module Schema::Validation::MinMax
+    # @private
+    def internal_validate_maximum(result_builder)
+      if schema_content.key?('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 result_builder.instance.is_a?(Numeric)
+            result_builder.validate(
+              result_builder.instance <= value,
+              'instance is not less than or equal to `maximum` value',
+              keyword: 'maximum',
+            )
+          end
+        else
+          result_builder.schema_error('`maximum` is not a number', 'maximum')
+        end
+      end
+    end
+
+    # @private
+    def internal_validate_exclusiveMaximum(result_builder)
+      if schema_content.key?('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 result_builder.instance.is_a?(Numeric)
+            result_builder.validate(
+              result_builder.instance < value,
+              'instance is not less than `exclusiveMaximum` value',
+              keyword: 'exclusiveMaximum',
+            )
+          end
+        else
+          result_builder.schema_error('`exclusiveMaximum` is not a number', 'exclusiveMaximum')
+        end
+      end
+    end
+
+    # @private
+    def internal_validate_minimum(result_builder)
+      if schema_content.key?('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 result_builder.instance.is_a?(Numeric)
+            result_builder.validate(
+              result_builder.instance >= value,
+              'instance is not greater than or equal to `minimum` value',
+              keyword: 'minimum',
+            )
+          end
+        else
+          result_builder.schema_error('`minimum` is not a number', 'minimum')
+        end
+      end
+    end
+
+    # @private
+    def internal_validate_exclusiveMinimum(result_builder)
+      if schema_content.key?('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 result_builder.instance.is_a?(Numeric)
+            result_builder.validate(
+              result_builder.instance > value,
+              'instance is not greater than `exclusiveMinimum` value',
+              keyword: 'exclusiveMinimum',
+            )
+          end
+        else
+          result_builder.schema_error('`exclusiveMinimum` is not a number', 'exclusiveMinimum')
+        end
+      end
+    end
+  end
+end

data/lib/jsi/schema/validation/object.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Validation::MinMaxProperties
+    # @private
+    def internal_validate_maxProperties(result_builder)
+      if schema_content.key?('maxProperties')
+        value = schema_content['maxProperties']
+        # The value of this keyword MUST be a non-negative integer.
+        if internal_integer?(value) && value >= 0
+          if result_builder.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.
+            result_builder.validate(
+              result_builder.instance.size <= value,
+              'instance object contains more properties than `maxProperties` value',
+              keyword: 'maxProperties',
+            )
+          end
+        else
+          result_builder.schema_error('`maxProperties` is not a non-negative integer', 'maxProperties')
+        end
+      end
+    end
+
+    # @private
+    def internal_validate_minProperties(result_builder)
+      if schema_content.key?('minProperties')
+        value = schema_content['minProperties']
+        # The value of this keyword MUST be a non-negative integer.
+        if internal_integer?(value) && value >= 0
+          if result_builder.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.
+            result_builder.validate(
+              result_builder.instance.size >= value,
+              'instance object contains fewer properties than `minProperties` value',
+              keyword: 'minProperties',
+            )
+          end
+        else
+          result_builder.schema_error('`minProperties` is not a non-negative integer', 'minProperties')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Validation::Pattern
+    # @private
+    def internal_validate_pattern(result_builder)
+      if schema_content.key?('pattern')
+        value = schema_content['pattern']
+        # The value of this keyword MUST be a string.
+        if value.respond_to?(:to_str)
+          if result_builder.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
+              # succssfully. Recall: regular expressions are not implicitly anchored.
+              result_builder.validate(
+                regexp.match(result_builder.instance),
+                'instance string does not match `pattern` regular expression value',
+                keyword: 'pattern',
+              )
+            rescue RegexpError => e
+              result_builder.schema_error("`pattern` is not a valid regular expression: #{e.message}", 'pattern')
+            end
+          end
+        else
+          result_builder.schema_error('`pattern` is not a string', 'pattern')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Validation::Properties
+    # @private
+    def internal_validate_properties(result_builder)
+      evaluated_property_names = Set[]
+
+      if schema_content.key?('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 result_builder.instance.respond_to?(:to_hash)
+            results = {}
+            result_builder.instance.keys.each do |property_name|
+              if value.key?(property_name)
+                evaluated_property_names << property_name
+                results[property_name] = result_builder.child_subschema_validate(
+                  ['properties', property_name],
+                  [property_name],
+                )
+              end
+            end
+            result_builder.validate(
+              results.values.all?(&:valid?),
+              'instance object properties are not all valid against corresponding `properties` schema values',
+              keyword: 'properties',
+              results: results.values,
+            )
+          end
+        else
+          result_builder.schema_error('`properties` is not an object', 'properties')
+        end
+      end
+
+      if schema_content.key?('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 result_builder.instance.respond_to?(:to_hash)
+            results = {}
+            result_builder.instance.keys.each do |property_name|
+              value.keys.each 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] = result_builder.child_subschema_validate(
+                      ['patternProperties', value_property_pattern],
+                      [property_name],
+                    )
+                  end
+                rescue ::RegexpError
+                  result_builder.schema_error("`patternProperties` key #{property_name.inspect} is not a valid regular expression: #{e.message}", 'patternProperties')
+                end
+              end
+            end
+            result_builder.validate(
+              results.values.all?(&:valid?),
+              'instance object properties are not all valid against corresponding `patternProperties` schema values',
+              keyword: 'patternProperties',
+              results: results.values,
+            )
+          end
+        else
+          result_builder.schema_error('`patternProperties` is not an object', 'patternProperties')
+        end
+      end
+
+      if schema_content.key?('additionalProperties')
+        value = schema_content['additionalProperties']
+        # The value of "additionalProperties" MUST be a valid JSON Schema.
+        if result_builder.instance.respond_to?(:to_hash)
+          results = {}
+          result_builder.instance.keys.each do |property_name|
+            if !evaluated_property_names.include?(property_name)
+              results[property_name] = result_builder.child_subschema_validate(
+                ['additionalProperties'],
+                [property_name],
+              )
+            end
+          end.compact
+          result_builder.validate(
+            results.values.all?(&:valid?),
+            'instance object additional properties are not all valid against `additionalProperties` schema value',
+            keyword: 'additionalProperties',
+            results: results.values,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Validation::PropertyNames
+    # @private
+    def internal_validate_propertyNames(result_builder)
+      if schema_content.key?('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 result_builder.instance.respond_to?(:to_hash)
+          results = {}
+          result_builder.instance.keys.each do |property_name|
+            results[property_name] = subschema(['propertyNames']).internal_validate_instance(
+              Ptr[],
+              property_name,
+              validate_only: result_builder.validate_only,
+            )
+          end
+          result_builder.validate(
+            results.values.all?(&:valid?),
+            'instance object property names are not all valid against `propertyNames` schema value',
+            keyword: 'propertyNames',
+            results: results.values,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Validation::Ref
+    # @private
+    # @param throw_result [Boolean] if a $ref is present, whether to throw the result being built after
+    #   validating the $ref, bypassing subsequent keyword validation
+    def internal_validate_ref(result_builder, throw_result: false)
+      if schema_content.key?('$ref')
+        value = schema_content['$ref']
+
+        if value.respond_to?(:to_str)
+          schema_ref = jsi_memoize(:ref) { Schema::Ref.new(value, self) }
+
+          if result_builder.visited_refs.include?(schema_ref)
+            result_builder.schema_error('self-referential schema structure', '$ref')
+          else
+            ref_result = schema_ref.deref_schema.internal_validate_instance(
+              result_builder.instance_ptr,
+              result_builder.instance_document,
+              validate_only: result_builder.validate_only,
+              visited_refs: result_builder.visited_refs + [schema_ref],
+            )
+            result_builder.validate(
+              ref_result.valid?,
+              'instance is not valid against the schema referenced by `$ref` value',
+              keyword: '$ref',
+              results: [ref_result],
+            )
+            if throw_result
+              throw(:jsi_validation_result, result_builder.result)
+            end
+          end
+        else
+          result_builder.schema_error("`$ref` is not a string", '$ref')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Validation::Required
+    # @private
+    def internal_validate_required(result_builder)
+      if schema_content.key?('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 result_builder.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| result_builder.instance.key?(property_name) }
+            # TODO include missing required property names in the validation error
+            result_builder.validate(
+              missing_required.empty?,
+              'instance object does not contain all property names specified by `required` value',
+              keyword: 'required',
+            )
+          end
+        else
+          result_builder.schema_error('`required` is not an array', 'required')
+        end
+      end
+    end
+  end
+end

data/lib/jsi/schema/validation/someof.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Validation::AllOf
+    # @private
+    def internal_validate_allOf(result_builder)
+      if schema_content.key?('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|
+            result_builder.inplace_subschema_validate(['allOf', i])
+          end
+          result_builder.validate(
+            allOf_results.all?(&:valid?),
+            'instance is not valid against all schemas specified by `allOf` value',
+            keyword: 'allOf',
+            results: allOf_results,
+          )
+        else
+          result_builder.schema_error('`allOf` is not an array', 'allOf')
+        end
+      end
+    end
+  end
+
+  module Schema::Validation::AnyOf
+    # @private
+    def internal_validate_anyOf(result_builder)
+      if schema_content.key?('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|
+            result_builder.inplace_subschema_validate(['anyOf', i])
+          end
+          result_builder.validate(
+            anyOf_results.any?(&:valid?),
+            'instance is not valid against any schemas specified by `anyOf` value',
+            keyword: 'anyOf',
+            results: anyOf_results,
+          )
+        else
+          result_builder.schema_error('`anyOf` is not an array', 'anyOf')
+        end
+      end
+    end
+  end
+
+  module Schema::Validation::OneOf
+    # @private
+    def internal_validate_oneOf(result_builder)
+      if schema_content.key?('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|
+            result_builder.inplace_subschema_validate(['oneOf', i])
+          end
+          if oneOf_results.none?(&:valid?)
+            result_builder.validate(
+              false,
+              'instance is not valid against any schemas specified by `oneOf` value',
+              keyword: 'oneOf',
+              results: oneOf_results,
+            )
+          else
+            # TODO better info on what schemas passed/failed validation
+            result_builder.validate(
+              oneOf_results.select(&:valid?).size == 1,
+              'instance is valid against more than one schema specified by `oneOf` value',
+              keyword: 'oneOf',
+              results: oneOf_results,
+            )
+          end
+        else
+          result_builder.schema_error('`oneOf` is not an array', 'oneOf')
+        end
+      end
+    end
+  end
+end

data/lib/jsi/schema/validation/string.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Validation::StringLength
+    # @private
+    def internal_validate_maxLength(result_builder)
+      if schema_content.key?('maxLength')
+        value = schema_content['maxLength']
+        # The value of this keyword MUST be a non-negative integer.
+        if internal_integer?(value) && value >= 0
+          if result_builder.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.
+            result_builder.validate(
+              result_builder.instance.to_str.length <= value,
+              'instance string length is not less than or equal to `maxLength` value',
+              keyword: 'maxLength',
+            )
+          end
+        else
+          result_builder.schema_error('`maxLength` is not a non-negative integer', 'maxLength')
+        end
+      end
+    end
+
+    # @private
+    def internal_validate_minLength(result_builder)
+      if schema_content.key?('minLength')
+        value = schema_content['minLength']
+        # The value of this keyword MUST be a non-negative integer.
+        if internal_integer?(value) && value >= 0
+          if result_builder.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.
+            result_builder.validate(
+              result_builder.instance.to_str.length >= value,
+              'instance string length is not greater than or equal to `minLength` value',
+              keyword: 'minLength',
+            )
+          end
+        else
+          result_builder.schema_error('`minLength` is not a non-negative integer', 'minLength')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Validation::Type
+    # @private
+    def internal_validate_type(result_builder)
+      if schema_content.key?('type')
+        value = schema_content['type']
+        instance = result_builder.instance
+        # 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.
+        if value.respond_to?(:to_str) || value.respond_to?(:to_ary)
+          types = value.respond_to?(:to_str) ? [value] : value
+          matched_type = types.each_with_index.any? do |type, i|
+            if type.respond_to?(:to_str)
+              case type.to_str
+              when 'null'
+                instance == nil
+              when 'boolean'
+                instance == true || instance == false
+              when 'object'
+                instance.respond_to?(:to_hash)
+              when 'array'
+                instance.respond_to?(:to_ary)
+              when 'string'
+                instance.respond_to?(:to_str)
+              when 'number'
+                instance.is_a?(Numeric)
+              when 'integer'
+                internal_integer?(instance)
+              else
+                result_builder.schema_error("`type` is not one of: null, boolean, object, array, string, number, or integer", 'type')
+              end
+            else
+              result_builder.schema_error("`type` is not a string at index #{i}", 'type')
+            end
+          end
+          result_builder.validate(
+            matched_type,
+            'instance type does not match `type` value',
+            keyword: 'type',
+          )
+        else
+          result_builder.schema_error('`type` is not a string or array', 'type')
+        end
+      end
+    end
+  end
+end