jsi-dev 0.0.8 → 0.0.10

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

@@ -1,44 +0,0 @@
-# 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

@@ -1,14 +0,0 @@
-# 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

@@ -1,12 +0,0 @@
-# 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/ref.rb

@@ -1,183 +0,0 @@
-# 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/validation/array.rb

@@ -1,69 +0,0 @@
-# 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/contains.rb

@@ -1,25 +0,0 @@
-# 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

@@ -1,49 +0,0 @@
-# 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

data/lib/jsi/schema/validation/draft04/minmax.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module JSI
-  module Schema::Validation::Draft04::MinMax
-    # @private
-    def internal_validate_maximum(result_builder)
-      if keyword?('exclusiveMaximum')
-        value = schema_content['exclusiveMaximum']
-        # The value of "exclusiveMaximum" MUST be a boolean.
-        unless [true, false].include?(value)
-          result_builder.schema_error('`exclusiveMaximum` is not true or false', 'exclusiveMaximum')
-        end
-        if !keyword?('maximum')
-          result_builder.schema_error('`exclusiveMaximum` has no effect without adjacent `maximum` keyword', 'exclusiveMaximum')
-        end
-      end
-
-      if keyword?('maximum')
-        value = schema_content['maximum']
-        # The value of "maximum" MUST be a JSON number.
-        if value.is_a?(Numeric)
-          if result_builder.instance.is_a?(Numeric)
-            # Successful validation depends on the presence and value of "exclusiveMaximum":
-            if schema_content['exclusiveMaximum'] == true
-              # if "exclusiveMaximum" has boolean value true, the instance is valid if it is strictly lower
-              # than the value of "maximum".
-              result_builder.validate(
-                result_builder.instance < value,
-                'instance is not less than `maximum` value with `exclusiveMaximum` = true',
-                keyword: 'maximum',
-              )
-            else
-              # if "exclusiveMaximum" is not present, or has boolean value false, then the instance is
-              # valid if it is lower than, or equal to, the value of "maximum"
-              result_builder.validate(
-                result_builder.instance <= value,
-                'instance is not less than or equal to `maximum` value',
-                keyword: 'maximum',
-              )
-            end
-          end
-        else
-          result_builder.schema_error('`maximum` is not a number', 'maximum')
-        end
-      end
-    end
-
-    # @private
-    def internal_validate_minimum(result_builder)
-      if keyword?('exclusiveMinimum')
-        value = schema_content['exclusiveMinimum']
-        # The value of "exclusiveMinimum" MUST be a boolean.
-        unless [true, false].include?(value)
-          result_builder.schema_error('`exclusiveMinimum` is not true or false', 'exclusiveMinimum')
-        end
-        if !keyword?('minimum')
-          result_builder.schema_error('`exclusiveMinimum` has no effect without adjacent `minimum` keyword', 'exclusiveMinimum')
-        end
-      end
-
-      if keyword?('minimum')
-        value = schema_content['minimum']
-        # The value of "minimum" MUST be a JSON number.
-        if value.is_a?(Numeric)
-          if result_builder.instance.is_a?(Numeric)
-            # Successful validation depends on the presence and value of "exclusiveMinimum":
-            if schema_content['exclusiveMinimum'] == true
-              # if "exclusiveMinimum" is present and has boolean value true, the instance is valid if it is
-              # strictly greater than the value of "minimum".
-              result_builder.validate(
-                result_builder.instance > value,
-                'instance is not greater than `minimum` value with `exclusiveMinimum` = true',
-                keyword: 'minimum',
-              )
-            else
-              # if "exclusiveMinimum" is not present, or has boolean value false, then the instance is
-              # valid if it is greater than, or equal to, the value of "minimum"
-              result_builder.validate(
-                result_builder.instance >= value,
-                'instance is not greater than or equal to `minimum` value',
-                keyword: 'minimum',
-              )
-            end
-          end
-        else
-          result_builder.schema_error('`minimum` is not a number', 'minimum')
-        end
-      end
-    end
-  end
-end

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

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-module JSI
-  module Schema::Validation::Draft04
-    autoload :MinMax, 'jsi/schema/validation/draft04/minmax'
-
-    include Schema::Validation::Ref
-
-    include Schema::Validation::MultipleOf
-    include Schema::Validation::Draft04::MinMax
-
-    include Schema::Validation::StringLength
-    include Schema::Validation::Pattern
-
-    include Schema::Validation::Items
-    include Schema::Validation::ArrayLength
-    include Schema::Validation::UniqueItems
-
-    include Schema::Validation::MinMaxProperties
-    include Schema::Validation::Required
-    include Schema::Validation::Properties
-    include Schema::Validation::Dependencies
-
-    include Schema::Validation::Enum
-    include Schema::Validation::Type
-
-    include Schema::Validation::AllOf
-    include Schema::Validation::AnyOf
-    include Schema::Validation::OneOf
-    include Schema::Validation::Not
-
-    # @private
-    def internal_validate_keywords(result_builder)
-      internal_validate_ref(result_builder, throw_result: true)
-
-      # 5.1.  Validation keywords for numeric instances (number and integer)
-
-      # 5.1.1.  multipleOf
-      internal_validate_multipleOf(result_builder)
-
-      # 5.1.2.  maximum and exclusiveMaximum
-      internal_validate_maximum(result_builder)
-
-      # 5.1.3.  minimum and exclusiveMinimum
-      internal_validate_minimum(result_builder)
-
-      # 5.2.  Validation keywords for strings
-
-      # 5.2.1.  maxLength
-      internal_validate_maxLength(result_builder)
-
-      # 5.2.2.  minLength
-      internal_validate_minLength(result_builder)
-
-      # 5.2.3.  pattern
-      internal_validate_pattern(result_builder)
-
-      # 5.3.  Validation keywords for arrays
-
-      # 5.3.1.  additionalItems and items
-      internal_validate_items(result_builder)
-
-      # 5.3.2.  maxItems
-      internal_validate_maxItems(result_builder)
-
-      # 5.3.3.  minItems
-      internal_validate_minItems(result_builder)
-
-      # 5.3.4.  uniqueItems
-      internal_validate_uniqueItems(result_builder)
-
-      # 5.4.  Validation keywords for objects
-
-      # 5.4.1.  maxProperties
-      internal_validate_maxProperties(result_builder)
-
-      # 5.4.2.  minProperties
-      internal_validate_minProperties(result_builder)
-
-      # 5.4.3.  required
-      internal_validate_required(result_builder)
-
-      # 5.4.4.  additionalProperties, properties and patternProperties
-      internal_validate_properties(result_builder)
-
-      # 5.4.5.  dependencies
-      internal_validate_dependencies(result_builder)
-
-      # 5.5.  Validation keywords for any instance type
-
-      # 5.5.1.  enum
-      internal_validate_enum(result_builder)
-
-      # 5.5.2.  type
-      internal_validate_type(result_builder)
-
-      # 5.5.3.  allOf
-      internal_validate_allOf(result_builder)
-
-      # 5.5.4.  anyOf
-      internal_validate_anyOf(result_builder)
-
-      # 5.5.5.  oneOf
-      internal_validate_oneOf(result_builder)
-
-      # 5.5.6.  not
-      internal_validate_not(result_builder)
-    end
-  end
-end