jsi-dev 0.0.0.pre.commonmarker

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Application::InplaceApplication::SomeOf
+    # @private
+    def internal_applicate_someOf(instance, visited_refs, &block)
+      if keyword?('allOf') && 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 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|
+          applicator.each_inplace_applicator_schema(instance, visited_refs: visited_refs, &block)
+        end
+      end
+      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 ? n : subschema_idx_valid[i] ? n + 1 : n }
+        if nvalid == 1
+          applicator_idxs = oneOf_idxs.select { |i| subschema_idx_valid[i] }
+        else
+          # invalid application: if none or multiple of the oneOf were valid, we apply them all
+          applicator_idxs = oneOf_idxs
+        end
+
+        applicator_idxs.each do |i|
+          subschema(['oneOf', 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,14 @@
+# 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'
+  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,13 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema
+    module Draft04
+      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,13 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema
+    module Draft06
+      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,13 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema
+    module Draft07
+      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,183 @@
+# frozen_string_literal: true
+
+module JSI
+  # A JSI::Schema::Ref is a reference to a schema identified by a URI, typically from
+  # a `$ref` keyword of a schema.
+  class Schema::Ref
+    # @param ref [String] A reference URI - typically the `$ref` value of the ref_schema
+    # @param ref_schema [JSI::Schema] A schema from which the reference originated.
+    #
+    #   If the ref URI consists of only a fragment, it is resolved from the `ref_schema`'s
+    #   {Schema#schema_resource_root}. Otherwise the resource is found in the `ref_schema`'s
+    #   {SchemaAncestorNode#jsi_schema_registry #jsi_schema_registry} (and any fragment is resolved from there).
+    # @param schema_registry [SchemaRegistry] The registry in which the resource this ref refers to will be found.
+    #   This should only be specified in the absence of a `ref_schema`.
+    #   If neither is specified, {JSI.schema_registry} is used.
+    def initialize(ref, ref_schema: nil, schema_registry: nil)
+      raise(ArgumentError, "ref is not a string") unless ref.respond_to?(:to_str)
+      @ref = ref
+      @ref_uri = Util.uri(ref)
+      @ref_schema = ref_schema ? Schema.ensure_schema(ref_schema) : nil
+      @schema_registry = schema_registry || (ref_schema ? ref_schema.jsi_schema_registry : JSI.schema_registry)
+      @deref_schema = nil
+    end
+
+    # @return [String]
+    attr_reader :ref
+
+    # @return [Addressable::URI]
+    attr_reader :ref_uri
+
+    # @return [Schema, nil]
+    attr_reader :ref_schema
+
+    # @return [SchemaRegistry, nil]
+    attr_reader(:schema_registry)
+
+    # 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 @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).freeze
+
+      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.
+
+        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).freeze
+        else
+          ref_abs_uri = nil
+        end
+        if ref_abs_uri
+          unless schema_registry
+            raise(Schema::ReferenceError, [
+              "could not resolve remote ref with no schema_registry specified",
+              "ref URI: #{ref_uri.to_s}",
+              ("from: #{ref_schema.pretty_inspect.chomp}" if ref_schema),
+            ].compact.join("\n"))
+          end
+          schema_resource_root = 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 do |k, v|
+              if Addressable::URI.parse(v['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) { schema_resource_root.jsi_descendent_node(ptr) }
+        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
+
+    alias_method :to_s, :inspect
+
+    # 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
+
+    # see {Util::Private::FingerprintHash}
+    # @api 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,122 @@
+# 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
+    if Util::LAST_ARGUMENT_AS_KEYWORD_PARAMETERS
+      def initialize(*)
+        super
+        jsi_schema_ancestor_node_initialize
+      end
+    else
+      def initialize(*, **)
+        super
+        jsi_schema_ancestor_node_initialize
+      end
+    end
+
+    # 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.
+    # @api 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.
+    # @api private
+    # @return [Array<JSI::Schema>]
+    attr_reader :jsi_schema_resource_ancestors
+
+    # See {SchemaSet#new_jsi} param `schema_registry`
+    # @return [SchemaRegistry]
+    attr_reader(:jsi_schema_registry)
+
+    # 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
+      (is_a?(Schema) && schema_absolute_uri) || jsi_schema_base_uri
+    end
+
+    # The schema at or below this node with the given anchor.
+    # If no schema has that anchor (or multiple schemas do, incorrectly), nil.
+    #
+    # @return [JSI::Schema, nil]
+    def jsi_anchor_subschema(anchor)
+      subschemas = @anchor_subschemas_map[anchor: anchor]
+      if subschemas.size == 1
+        subschemas.first
+      else
+        nil
+      end
+    end
+
+    # All schemas at or below this node with the given anchor.
+    #
+    # @return [Set<JSI::Schema>]
+    def jsi_anchor_subschemas(anchor)
+      @anchor_subschemas_map[anchor: anchor]
+    end
+
+    private
+
+    def jsi_schema_ancestor_node_initialize
+      @anchor_subschemas_map = jsi_memomap(&method(:jsi_anchor_subschemas_compute))
+    end
+
+    attr_writer :jsi_document
+
+    def jsi_ptr=(jsi_ptr)
+      #chkbug raise(Bug, "jsi_ptr not #{Ptr}: #{jsi_ptr}") unless jsi_ptr.is_a?(Ptr)
+      @jsi_ptr = jsi_ptr
+    end
+
+    def jsi_schema_base_uri=(jsi_schema_base_uri)
+      #chkbug raise(Bug) if jsi_schema_base_uri && !jsi_schema_base_uri.is_a?(Addressable::URI)
+      #chkbug raise(Bug) if jsi_schema_base_uri && !jsi_schema_base_uri.absolute?
+      #chkbug raise(Bug) if jsi_schema_base_uri && jsi_schema_base_uri.fragment
+
+      @jsi_schema_base_uri = jsi_schema_base_uri
+    end
+
+    def jsi_schema_resource_ancestors=(jsi_schema_resource_ancestors)
+      #chkbug raise(Bug) unless jsi_schema_resource_ancestors.respond_to?(:to_ary)
+      #chkbug jsi_schema_resource_ancestors.each { |a| Schema.ensure_schema(a) }
+      #chkbug # sanity check the ancestors are in order
+      #chkbug last_anc_ptr = nil
+      #chkbug jsi_schema_resource_ancestors.each do |anc|
+      #chkbug   if last_anc_ptr.nil?
+      #chkbug     # pass
+      #chkbug   elsif last_anc_ptr == anc.jsi_ptr
+      #chkbug     raise(Bug, "duplicate ancestors in #{jsi_schema_resource_ancestors.pretty_inspect}")
+      #chkbug   elsif !last_anc_ptr.contains?(anc.jsi_ptr)
+      #chkbug     raise(Bug, "ancestor ptr #{anc.jsi_ptr} not contained by previous: #{last_anc_ptr} in #{jsi_schema_resource_ancestors.pretty_inspect}")
+      #chkbug   end
+      #chkbug   if anc.jsi_ptr == jsi_ptr
+      #chkbug     raise(Bug, "ancestor is self")
+      #chkbug   elsif !anc.jsi_ptr.contains?(jsi_ptr)
+      #chkbug     raise(Bug, "ancestor does not contain self")
+      #chkbug   end
+      #chkbug   last_anc_ptr = anc.jsi_ptr
+      #chkbug end
+
+      @jsi_schema_resource_ancestors = jsi_schema_resource_ancestors
+    end
+
+    attr_writer(:jsi_schema_registry)
+
+    def jsi_anchor_subschemas_compute(anchor: )
+        jsi_each_descendent_node.select do |node|
+          node.is_a?(Schema) && node.respond_to?(:anchor) && node.anchor == anchor
+        end.to_set.freeze
+    end
+
+    # @return [Util::MemoMap]
+    def jsi_memomap(**options, &block)
+      Util::MemoMap::Mutable.new(**options, &block)
+    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 keyword?('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 keyword?('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 keyword?('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 keyword?('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 keyword?('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(i, ['contains'])
+          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/dependencies.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Validation::Dependencies
+    # @private
+    def internal_validate_dependencies(result_builder)
+      if keyword?('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