jsi 0.2.0 → 0.6.0

data/lib/jsi/schema/application/inplace_application/someof.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Application::InplaceApplication::SomeOf
+    # @private
+    def internal_applicate_someOf(instance, visited_refs, &block)
+      if schema_content['allOf'].respond_to?(:to_ary)
+        schema_content['allOf'].each_index do |i|
+          subschema(['allOf', i]).each_inplace_applicator_schema(instance, visited_refs: visited_refs, &block)
+        end
+      end
+      if schema_content['anyOf'].respond_to?(:to_ary)
+        schema_content['anyOf'].each_index do |i|
+          if subschema(['anyOf', i]).instance_valid?(instance)
+            subschema(['anyOf', i]).each_inplace_applicator_schema(instance, visited_refs: visited_refs, &block)
+          end
+        end
+      end
+      if schema_content['oneOf'].respond_to?(:to_ary)
+        one_i = schema_content['oneOf'].each_index.detect do |i|
+          subschema(['oneOf', i]).instance_valid?(instance)
+        end
+        if one_i
+          subschema(['oneOf', one_i]).each_inplace_applicator_schema(instance, visited_refs: visited_refs, &block)
+        end
+      end
+    end
+  end
+end

data/lib/jsi/schema/application/inplace_application.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Application::InplaceApplication
+    autoload :Draft04, 'jsi/schema/application/inplace_application/draft04'
+    autoload :Draft06, 'jsi/schema/application/inplace_application/draft06'
+    autoload :Draft07, 'jsi/schema/application/inplace_application/draft07'
+
+    autoload :Ref, 'jsi/schema/application/inplace_application/ref'
+    autoload :SomeOf, 'jsi/schema/application/inplace_application/someof'
+    autoload :IfThenElse, 'jsi/schema/application/inplace_application/ifthenelse'
+    autoload :Dependencies, 'jsi/schema/application/inplace_application/dependencies'
+
+    # a set of inplace applicator schemas of this schema (from $ref, allOf, etc.) which apply to the
+    # given instance.
+    #
+    # the returned set will contain this schema itself, unless this schema contains a $ref keyword.
+    #
+    # @param instance [Object] the instance to check any applicators against
+    # @return [JSI::SchemaSet] matched applicator schemas
+    def inplace_applicator_schemas(instance)
+      SchemaSet.new(each_inplace_applicator_schema(instance))
+    end
+
+    # yields each inplace applicator schema which applies to the given instance.
+    #
+    # @param instance (see #inplace_applicator_schemas)
+    # @param visited_refs [Enumerable<JSI::Schema::Ref>]
+    # @yield [JSI::Schema]
+    # @return [nil, Enumerator] an Enumerator if invoked without a block; otherwise nil
+    def each_inplace_applicator_schema(instance, visited_refs: [], &block)
+      return to_enum(__method__, instance, visited_refs: visited_refs) unless block
+
+      catch(:jsi_application_done) do
+        if schema_content.respond_to?(:to_hash)
+          internal_inplace_applicate_keywords(instance, visited_refs, &block)
+        else
+          # self is the only applicator schema if there are no keywords
+          yield self
+        end
+      end
+
+      nil
+    end
+  end
+end

data/lib/jsi/schema/application.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Application
+    autoload :InplaceApplication, 'jsi/schema/application/inplace_application'
+    autoload :ChildApplication, 'jsi/schema/application/child_application'
+
+    autoload :Draft04, 'jsi/schema/application/draft04'
+    autoload :Draft06, 'jsi/schema/application/draft06'
+    autoload :Draft07, 'jsi/schema/application/draft07'
+  end
+end

data/lib/jsi/schema/draft04.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema
+    module Draft04
+      include Schema
+      include OldId
+      include IdWithAnchor
+      include IntegerDisallows0Fraction
+      include Schema::Application::Draft04
+      include Schema::Validation::Draft04
+    end
+  end
+end

data/lib/jsi/schema/draft06.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema
+    module Draft06
+      include Schema
+      include BigMoneyId
+      include IdWithAnchor
+      include IntegerAllows0Fraction
+      include Schema::Application::Draft06
+      include Schema::Validation::Draft06
+    end
+  end
+end

data/lib/jsi/schema/draft07.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema
+    module Draft07
+      include Schema
+      include BigMoneyId
+      include IdWithAnchor
+      include IntegerAllows0Fraction
+      include Schema::Application::Draft07
+      include Schema::Validation::Draft07
+    end
+  end
+end

data/lib/jsi/schema/issue.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema
+    Issue = Util::AttrStruct[*%w(
+      level
+      message
+      keyword
+      schema
+    )]
+
+    # an issue or problem with a schema.
+    #
+    # when the `level` is `:error`, the schema is invalid according to its specification,
+    # violating some "MUST" or "MUST NOT".
+    #
+    # when the `level` is `:warning`, the issue does not mean the schema is invalid, but contains something
+    # that does not make sense. for example, specifying `additionalItems` without an adjacent `items` has
+    # no effect (in specifications which define `additionalItems`), but is not an invalid schema.
+    #
+    # @!attribute level
+    #   :error or :warning
+    #   @return [Symbol]
+    # @!attribute message
+    #   a message describing the issue
+    #   @return [String]
+    # @!attribute keyword
+    #   the keyword of the schema that has an issue
+    #   @return [String]
+    # @!attribute schema
+    #   the schema that has an issue
+    #   @return [JSI::Schema]
+    class Issue
+    end
+  end
+end

data/lib/jsi/schema/ref.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module JSI
+  # JSI::Schema::Ref is a reference to another schema (the result of #deref_schema), resolved using a ref URI
+  # from a ref schema (the ref URI typically the contents of the ref_schema's "$ref" keyword)
+  class Schema::Ref
+    # @param ref [String] a reference URI
+    # @param ref_schema [JSI::Schema] a schema from which the reference originated
+    def initialize(ref, ref_schema = nil)
+      raise(ArgumentError, "ref is not a string") unless ref.respond_to?(:to_str)
+      @ref = ref
+      @ref_uri = Addressable::URI.parse(ref)
+      @ref_schema = ref_schema ? Schema.ensure_schema(ref_schema) : nil
+    end
+
+    attr_reader :ref
+
+    attr_reader :ref_uri
+
+    attr_reader :ref_schema
+
+    # finds the schema this ref points to
+    # @return [JSI::Schema]
+    # @raise [JSI::Schema::NotASchemaError] when the thing this ref points to is not a schema
+    # @raise [JSI::Schema::ReferenceError] when this reference cannot be resolved
+    def deref_schema
+      return @deref_schema if instance_variable_defined?(:@deref_schema)
+
+      schema_resource_root = nil
+      check_schema_resource_root = -> {
+        unless schema_resource_root
+          raise(Schema::ReferenceError, [
+            "cannot find schema by ref: #{ref}",
+            ("from: #{ref_schema.pretty_inspect.chomp}" if ref_schema),
+          ].compact.join("\n"))
+        end
+      }
+
+      ref_uri_nofrag = ref_uri.merge(fragment: nil)
+
+      if ref_uri_nofrag.empty?
+        unless ref_schema
+          raise(Schema::ReferenceError, [
+            "cannot find schema by ref: #{ref}",
+            "with no ref schema",
+          ].join("\n"))
+        end
+
+        # the URI only consists of a fragment (or is empty).
+        # for a fragment pointer, resolve using Schema#resource_root_subschema on the ref_schema.
+        # for a fragment anchor, bootstrap does not support anchors; otherwise use the ref_schema's schema_resource_root.
+        schema_resource_root = ref_schema.is_a?(MetaschemaNode::BootstrapSchema) ? nil : ref_schema.schema_resource_root
+        resolve_fragment_ptr = ref_schema.method(:resource_root_subschema)
+      else
+        # find the schema_resource_root from the non-fragment URI. we will resolve any fragment, either pointer or anchor, from there.
+        schema_resource_root = nil
+
+        if ref_uri_nofrag.absolute?
+          ref_abs_uri = ref_uri_nofrag
+        elsif ref_schema && ref_schema.jsi_resource_ancestor_uri
+          ref_abs_uri = ref_schema.jsi_resource_ancestor_uri.join(ref_uri_nofrag)
+        else
+          ref_abs_uri = nil
+        end
+        if ref_abs_uri
+          schema_resource_root = JSI.schema_registry.find(ref_abs_uri)
+        end
+
+        unless schema_resource_root
+          # HAX for how google does refs and ids
+          if ref_schema && ref_schema.jsi_document.respond_to?(:to_hash) && ref_schema.jsi_document['schemas'].respond_to?(:to_hash)
+            ref_schema.jsi_document['schemas'].each_key do |k|
+              if Addressable::URI.parse(ref_schema.jsi_document['schemas'][k]['id']) == ref_uri_nofrag
+                schema_resource_root = ref_schema.resource_root_subschema(['schemas', k])
+              end
+            end
+          end
+        end
+
+        check_schema_resource_root.call
+
+        if schema_resource_root.is_a?(Schema)
+          resolve_fragment_ptr = schema_resource_root.method(:resource_root_subschema)
+        else
+          # Note: Schema#resource_root_subschema will reinstantiate nonschemas as schemas.
+          # not implemented for remote refs when the schema_resource_root is not a schema.
+          resolve_fragment_ptr = -> (ptr) { ptr.evaluate(schema_resource_root) }
+        end
+      end
+
+      fragment = ref_uri.fragment
+
+      if fragment
+        begin
+          ptr_from_fragment = Ptr.from_fragment(fragment)
+        rescue Ptr::PointerSyntaxError
+        end
+      end
+
+      if ptr_from_fragment
+        begin
+          result_schema = resolve_fragment_ptr.call(ptr_from_fragment)
+        rescue Ptr::ResolutionError
+          raise(Schema::ReferenceError, [
+            "could not resolve pointer: #{ptr_from_fragment.pointer.inspect}",
+            ("from: #{ref_schema.pretty_inspect.chomp}" if ref_schema),
+            ("in schema resource root: #{schema_resource_root.pretty_inspect.chomp}" if schema_resource_root),
+          ].compact.join("\n"))
+        end
+      elsif fragment.nil?
+        check_schema_resource_root.call
+        result_schema = schema_resource_root
+      else
+        check_schema_resource_root.call
+
+        # find an anchor that resembles the fragment
+        result_schemas = schema_resource_root.jsi_anchor_subschemas(fragment)
+
+        if result_schemas.size == 1
+          result_schema = result_schemas.first
+        elsif result_schemas.size == 0
+          raise(Schema::ReferenceError, [
+            "could not find schema by fragment: #{fragment.inspect}",
+            "in schema resource root: #{schema_resource_root.pretty_inspect.chomp}",
+          ].join("\n"))
+        else
+          raise(Schema::ReferenceError, [
+            "found multiple schemas for plain name fragment #{fragment.inspect}:",
+            *result_schemas.map { |s| s.pretty_inspect.chomp },
+          ].join("\n"))
+        end
+      end
+
+      Schema.ensure_schema(result_schema, msg: "object identified by uri #{ref} is not a schema:")
+      return @deref_schema = result_schema
+    end
+
+    # @return [String]
+    def inspect
+      %Q(\#<#{self.class.name} #{ref}>)
+    end
+
+    # pretty-prints a representation of self to the given printer
+    # @return [void]
+    def pretty_print(q)
+      q.text '#<'
+      q.text self.class.name
+      q.text ' '
+      q.text ref
+      q.text '>'
+    end
+
+    # @private
+    def jsi_fingerprint
+      {class: self.class, ref: ref, ref_schema: ref_schema}
+    end
+    include Util::FingerprintHash
+  end
+end

data/lib/jsi/schema/schema_ancestor_node.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module JSI
+  # a node in a document which may contain a schema somewhere within is extended with SchemaAncestorNode, for
+  # tracking things necessary for a schema to function correctly
+  module Schema::SchemaAncestorNode
+    # the base URI used to resolve the ids of schemas at or below this JSI.
+    # this is always an absolute URI (with no fragment).
+    # this may be the absolute schema URI of a parent schema or the URI from which the document was retrieved.
+    # @private
+    # @return [Addressable::URI, nil]
+    attr_reader :jsi_schema_base_uri
+
+    # resources which are ancestors of this JSI in the document. this does not include self.
+    # @private
+    # @return [Array<JSI::Schema>]
+    def jsi_schema_resource_ancestors
+      return @jsi_schema_resource_ancestors if instance_variable_defined?(:@jsi_schema_resource_ancestors)
+      [].freeze
+    end
+
+    # the URI of the resource containing this node.
+    # this is always an absolute URI (with no fragment).
+    # if this node is a schema with an id, this is its absolute URI; otherwise a parent resource's URI,
+    # or nil if not contained by a resource with a URI.
+    # @return [Addressable::URI, nil]
+    def jsi_resource_ancestor_uri
+      if is_a?(Schema) && schema_absolute_uri
+        schema_absolute_uri
+      else
+        jsi_schema_base_uri
+      end
+    end
+
+    # a schema at or below this node with the given anchor.
+    #
+    # @return [JSI::Schema, nil]
+    def jsi_anchor_subschema(anchor)
+      subschemas = jsi_anchor_subschemas_map[anchor]
+      if subschemas.size == 1
+        subschemas.first
+      else
+        nil
+      end
+    end
+
+    # schemas at or below node with the given anchor.
+    #
+    # @return [Array<JSI::Schema>]
+    def jsi_anchor_subschemas(anchor)
+      jsi_anchor_subschemas_map[anchor]
+    end
+
+    private
+
+    def jsi_document=(jsi_document)
+      @jsi_document = jsi_document
+    end
+
+    def jsi_ptr=(jsi_ptr)
+      unless jsi_ptr.is_a?(Ptr)
+        raise(TypeError, "jsi_ptr must be a JSI::Ptr; got: #{jsi_ptr.inspect}")
+      end
+      @jsi_ptr = jsi_ptr
+    end
+
+    def jsi_schema_base_uri=(jsi_schema_base_uri)
+      if jsi_schema_base_uri
+        unless jsi_schema_base_uri.respond_to?(:to_str)
+          raise(TypeError, "jsi_schema_base_uri must be string or Addressable::URI; got: #{jsi_schema_base_uri.inspect}")
+        end
+        @jsi_schema_base_uri = Addressable::URI.parse(jsi_schema_base_uri).freeze
+        unless @jsi_schema_base_uri.absolute? && !@jsi_schema_base_uri.fragment
+          raise(ArgumentError, "jsi_schema_base_uri must be an absolute URI with no fragment; got: #{jsi_schema_base_uri.inspect}")
+        end
+      else
+        @jsi_schema_base_uri = nil
+      end
+    end
+
+    def jsi_schema_resource_ancestors=(jsi_schema_resource_ancestors)
+      if jsi_schema_resource_ancestors
+        unless jsi_schema_resource_ancestors.respond_to?(:to_ary)
+          raise(TypeError, "jsi_schema_resource_ancestors must be an array; got: #{jsi_schema_resource_ancestors.inspect}")
+        end
+        jsi_schema_resource_ancestors.each { |a| Schema.ensure_schema(a)  }
+        # sanity check the ancestors are in order
+        last_anc_ptr = nil
+        jsi_schema_resource_ancestors.each do |anc|
+          if last_anc_ptr.nil?
+            # pass
+          elsif last_anc_ptr == anc.jsi_ptr
+            raise(Bug, "duplicate ancestors in #{jsi_schema_resource_ancestors.pretty_inspect}")
+          elsif !last_anc_ptr.contains?(anc.jsi_ptr)
+            raise(Bug, "ancestor ptr #{anc.jsi_ptr} not contained by previous: #{last_anc_ptr} in #{jsi_schema_resource_ancestors.pretty_inspect}")
+          end
+          if anc.jsi_ptr == jsi_ptr
+            raise(Bug, "ancestor is self")
+          elsif !anc.jsi_ptr.contains?(jsi_ptr)
+            raise(Bug, "ancestor does not contain self")
+          end
+          last_anc_ptr = anc.jsi_ptr
+        end
+
+        @jsi_schema_resource_ancestors = jsi_schema_resource_ancestors.to_ary.freeze
+      else
+        @jsi_schema_resource_ancestors = [].freeze
+      end
+    end
+
+    def jsi_anchor_subschemas_map
+      jsi_memomap(__method__) do |anchor|
+        jsi_each_child_node.select do |node|
+          node.is_a?(Schema) && node.respond_to?(:anchor) && node.anchor == anchor
+        end.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Validation::ArrayLength
+    # @private
+    def internal_validate_maxItems(result_builder)
+      if schema_content.key?('maxItems')
+        value = schema_content['maxItems']
+        # The value of this keyword MUST be a non-negative integer.
+        if internal_integer?(value) && value >= 0
+          if result_builder.instance.respond_to?(:to_ary)
+            # An array instance is valid against "maxItems" if its size is less than, or equal to, the value of this keyword.
+            result_builder.validate(
+              result_builder.instance.to_ary.size <= value,
+              'instance array size is greater than `maxItems` value',
+              keyword: 'maxItems',
+            )
+          end
+        else
+          result_builder.schema_error('`maxItems` is not a non-negative integer', 'maxItems')
+        end
+      end
+    end
+
+    # @private
+    def internal_validate_minItems(result_builder)
+      if schema_content.key?('minItems')
+        value = schema_content['minItems']
+        # The value of this keyword MUST be a non-negative integer.
+        if internal_integer?(value) && value >= 0
+          if result_builder.instance.respond_to?(:to_ary)
+            # An array instance is valid against "minItems" if its size is greater than, or equal to, the value of this keyword.
+            result_builder.validate(
+              result_builder.instance.to_ary.size >= value,
+              'instance array size is less than `minItems` value',
+              keyword: 'minItems',
+            )
+          end
+        else
+          result_builder.schema_error('`minItems` is not a non-negative integer', 'minItems')
+        end
+      end
+    end
+  end
+  module Schema::Validation::UniqueItems
+    # @private
+    def internal_validate_uniqueItems(result_builder)
+      if schema_content.key?('uniqueItems')
+        value = schema_content['uniqueItems']
+        # The value of this keyword MUST be a boolean.
+        if value == false
+          # If this keyword has boolean value false, the instance validates successfully.
+          # (noop)
+        elsif value == true
+          if result_builder.instance.respond_to?(:to_ary)
+            # If it has boolean value true, the instance validates successfully if all of its elements are unique.
+            result_builder.validate(
+              result_builder.instance.uniq.size == result_builder.instance.size,
+              "instance array items' uniqueness does not match `uniqueItems` value",
+              keyword: 'uniqueItems',
+            )
+          end
+        else
+          result_builder.schema_error('`uniqueItems` is not a boolean', 'uniqueItems')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Validation::Const
+    # @private
+    def internal_validate_const(result_builder)
+      if schema_content.key?('const')
+        value = schema_content['const']
+        # The value of this keyword MAY be of any type, including null.
+        # An instance validates successfully against this keyword if its value is equal to the value of
+        # the keyword.
+        result_builder.validate(
+          result_builder.instance == value,
+          'instance is not equal to `const` value',
+          keyword: 'const',
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Validation::Contains
+    # @private
+    def internal_validate_contains(result_builder)
+      if schema_content.key?('contains')
+        # An array instance is valid against "contains" if at least one of its elements is valid against
+        # the given schema.
+        if result_builder.instance.respond_to?(:to_ary)
+          results = {}
+          result_builder.instance.each_index do |i|
+            results[i] = result_builder.child_subschema_validate(['contains'], [i])
+          end
+          result_builder.validate(
+            results.values.any?(&:valid?),
+            'instance array does not contain any items valid against `contains` schema value',
+            keyword: 'contains',
+            results: results.values,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Validation::Core
+    # validates the given instance against this schema
+    #
+    # @private
+    # @param instance_ptr [JSI::Ptr] a pointer to the instance to validate against the schema, in the instance_document
+    # @param instance_document [#to_hash, #to_ary, Object] document containing the instance instance_ptr pointer points to
+    # @param validate_only [Boolean] whether to return a full schema validation result or a simple, validation-only result
+    # @param visited_refs [Enumerable<JSI::Schema::Ref>]
+    # @return [JSI::Validation::Result]
+    def internal_validate_instance(instance_ptr, instance_document, validate_only: false, visited_refs: [])
+      if validate_only
+        result = JSI::Validation::VALID
+      else
+        result = JSI::Validation::FullResult.new
+      end
+      result_builder = result.builder(self, instance_ptr, instance_document, validate_only, visited_refs)
+
+      catch(:jsi_validation_result) do
+        # note: true/false are not valid as schemas in draft 4; they are only values of
+        # additionalProperties / additionalItems. since their behavior is undefined, though,
+        # it's fine for them to behave the same as boolean schemas in later drafts.
+        # I don't care about draft 4 to implement a different structuring for that.
+        if schema_content == true
+          # noop
+        elsif schema_content == false
+          result_builder.validate(false, 'instance is not valid against `false` schema')
+        elsif schema_content.respond_to?(:to_hash)
+          internal_validate_keywords(result_builder)
+        else
+          result_builder.schema_error('schema is not a boolean or a JSON object')
+        end
+        result
+      end.freeze
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Validation::Dependencies
+    # @private
+    def internal_validate_dependencies(result_builder)
+      if schema_content.key?('dependencies')
+        value = schema_content['dependencies']
+        # 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.
+        if value.respond_to?(:to_hash)
+          value.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 result_builder.instance.respond_to?(:to_hash) && result_builder.instance.key?(property_name)
+                missing_required = dependency.reject { |name| result_builder.instance.key?(name) }
+                # TODO include property_name / missing dependent required property names in the validation error
+                result_builder.validate(
+                  missing_required.empty?,
+                  'instance object does not contain all dependent required property names specified by `dependencies` value',
+                  keyword: 'dependencies',
+                )
+              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 result_builder.instance.respond_to?(:to_hash) && result_builder.instance.key?(property_name)
+                dependency_result = result_builder.inplace_subschema_validate(['dependencies', property_name])
+                # TODO include property_name in the validation error
+                result_builder.validate(
+                  dependency_result.valid?,
+                  'instance object is not valid against the schema corresponding to a matched property name specified by `dependencies` value',
+                  keyword: 'dependencies',
+                  results: [dependency_result],
+                )
+              end
+            end
+          end
+        else
+          result_builder.schema_error('`dependencies` is not an object', 'dependencies')
+        end
+      end
+    end
+  end
+end