jsi-dev 0.0.8 → 0.0.10

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

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module JSI
-  module Schema::Validation::Properties
-    # @private
-    def internal_validate_properties(result_builder)
-      evaluated_property_names = Set[]
-
-      if keyword?('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(
-                  property_name,
-                  ['properties', 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 keyword?('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(
-                      property_name,
-                      ['patternProperties', value_property_pattern],
-                    )
-                  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 keyword?('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(
-                property_name,
-                ['additionalProperties'],
-              )
-            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

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module JSI
-  module Schema::Validation::PropertyNames
-    # @private
-    def internal_validate_propertyNames(result_builder)
-      if keyword?('propertyNames')
-        # The value of "propertyNames" MUST be a valid JSON Schema.
-        #
-        # If the instance is an object, this keyword validates if every property name in the instance
-        # validates against the provided schema. Note the property name that the schema is testing will
-        # always be a string.
-        if 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

@@ -1,40 +0,0 @@
-# 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 keyword?('$ref')
-        value = schema_content['$ref']
-
-        if value.respond_to?(:to_str)
-          schema_ref = self.schema_ref
-
-          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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module JSI
-  module Schema::Validation::Required
-    # @private
-    def internal_validate_required(result_builder)
-      if keyword?('required')
-        value = schema_content['required']
-        # The value of this keyword MUST be an array. Elements of this array, if any, MUST be strings, and MUST be unique.
-        if value.respond_to?(:to_ary)
-          if 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

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module JSI
-  module Schema::Validation::AllOf
-    # @private
-    def internal_validate_allOf(result_builder)
-      if keyword?('allOf')
-        value = schema_content['allOf']
-        # This keyword's value MUST be a non-empty array. Each item of the array MUST be a valid JSON Schema.
-        if value.respond_to?(:to_ary)
-          # An instance validates successfully against this keyword if it validates successfully against all
-          # schemas defined by this keyword's value.
-          allOf_results = value.each_index.map do |i|
-            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 keyword?('anyOf')
-        value = schema_content['anyOf']
-        # This keyword's value MUST be a non-empty array. Each item of the array MUST be a valid JSON Schema.
-        if value.respond_to?(:to_ary)
-          # An instance validates successfully against this keyword if it validates successfully against at
-          # least one schema defined by this keyword's value.
-          # Note that when annotations are being collected, all subschemas MUST be examined so that
-          # annotations are collected from each subschema that validates successfully.
-          anyOf_results = value.each_index.map do |i|
-            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 keyword?('oneOf')
-        value = schema_content['oneOf']
-        # This keyword's value MUST be a non-empty array. Each item of the array MUST be a valid JSON Schema.
-        if value.respond_to?(:to_ary)
-          # An instance validates successfully against this keyword if it validates successfully against
-          # exactly one schema defined by this keyword's value.
-          oneOf_results = value.each_index.map do |i|
-            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

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module JSI
-  module Schema::Validation::StringLength
-    # @private
-    def internal_validate_maxLength(result_builder)
-      if keyword?('maxLength')
-        value = schema_content['maxLength']
-        # The value of this keyword MUST be a non-negative integer.
-        if internal_integer?(value) && value >= 0
-          if 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 keyword?('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

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

data/lib/jsi/schema/validation.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module JSI
-  module Schema::Validation
-    autoload :Draft04, 'jsi/schema/validation/draft04'
-    autoload :Draft06, 'jsi/schema/validation/draft06'
-    autoload :Draft07, 'jsi/schema/validation/draft07'
-
-    # ref application
-    autoload :Ref, 'jsi/schema/validation/ref'
-
-    # inplace subschema application
-    autoload :AllOf, 'jsi/schema/validation/someof'
-    autoload :AnyOf, 'jsi/schema/validation/someof'
-    autoload :OneOf, 'jsi/schema/validation/someof'
-    autoload :IfThenElse, 'jsi/schema/validation/ifthenelse'
-
-    # child subschema application
-    autoload :Items,    'jsi/schema/validation/items'
-    autoload :Contains,  'jsi/schema/validation/contains'
-    autoload :Properties, 'jsi/schema/validation/properties'
-
-    # property names subschema application
-    autoload :PropertyNames, 'jsi/schema/validation/property_names'
-
-    # any type validation
-    autoload :Type, 'jsi/schema/validation/type'
-    autoload :Enum, 'jsi/schema/validation/enum'
-    autoload :Const, 'jsi/schema/validation/const'
-    autoload :Not,  'jsi/schema/validation/not'
-
-    # object validation
-    autoload :Required,    'jsi/schema/validation/required'
-    autoload :Dependencies, 'jsi/schema/validation/dependencies'
-    autoload :MinMaxProperties, 'jsi/schema/validation/object'
-
-    # array validation
-    autoload :ArrayLength, 'jsi/schema/validation/array'
-    autoload :UniqueItems, 'jsi/schema/validation/array'
-
-    # string validation
-    autoload :StringLength, 'jsi/schema/validation/string'
-    autoload :Pattern, 'jsi/schema/validation/pattern'
-
-    # numeric validation
-    autoload :MultipleOf, 'jsi/schema/validation/numeric'
-    autoload :MinMax,    'jsi/schema/validation/numeric'
-  end
-end

data/lib/jsi/schema_registry.rb

@@ -1,190 +0,0 @@
-# frozen_string_literal: true
-
-module JSI
-  class SchemaRegistry
-    # an exception raised when an attempt is made to register a resource using a URI which is already
-    # registered with another resource
-    class Collision < StandardError
-    end
-
-    # an exception raised when an attempt is made to access (register or find) a resource of the
-    # registry using a URI which is not absolute (it is a relative URI or it contains a fragment)
-    class NonAbsoluteURI < StandardError
-    end
-
-    # an exception raised when a URI we are looking for has not been registered
-    class ResourceNotFound < StandardError
-      attr_accessor :uri
-    end
-
-    def initialize
-      @resources = {}
-      @autoload_uris = {}
-      @resources_mutex = Mutex.new
-    end
-
-    # registers the given resource and/or schema resources it contains in the registry.
-    #
-    # each descendent node of the resource (including the resource itself) is registered if it is a schema
-    # that has an absolute URI (generally defined by the '$id' keyword).
-    #
-    # the given resource itself will be registered, whether or not it is a schema, if it is the root
-    # of its document and was instantiated with the option `uri` specified.
-    #
-    # @param resource [JSI::Base] a JSI containing resources to register
-    # @return [void]
-    def register(resource)
-      unless resource.is_a?(JSI::Base)
-        raise(ArgumentError, "resource must be a JSI::Base. got: #{resource.pretty_inspect.chomp}")
-      end
-      unless resource.is_a?(JSI::Schema) || resource.jsi_ptr.root?
-        # unsure, should this be allowed? the given JSI is not a "resource" as we define it, but
-        # if this check is removed it will just register any resources (schemas) below the given JSI.
-        raise(ArgumentError, "undefined behavior: registration of a JSI which is not a schema and is not at the root of a document")
-      end
-
-      # allow for registration of resources at the root of a document whether or not they are schemas.
-      # jsi_schema_base_uri at the root comes from the `uri` parameter to new_jsi / new_schema.
-      if resource.jsi_schema_base_uri && resource.jsi_ptr.root?
-        register_single(resource.jsi_schema_base_uri, resource)
-      end
-
-      resource.jsi_each_descendent_node do |node|
-        if node.is_a?(JSI::Schema) && node.schema_absolute_uri
-          register_single(node.schema_absolute_uri, node)
-        end
-      end
-
-      nil
-    end
-
-    # takes a URI identifying a resource to be loaded by the given block
-    # when a reference to the URI is followed.
-    #
-    # for example:
-    #
-    #     JSI.schema_registry.autoload_uri('http://example.com/schema.json') do
-    #       JSI.new_schema({
-    #         '$schema' => 'http://json-schema.org/draft-07/schema#',
-    #         '$id' => 'http://example.com/schema.json',
-    #         'title' => 'my schema',
-    #       })
-    #     end
-    #
-    # the block would normally load JSON from the filesystem or similar.
-    #
-    # @param uri [Addressable::URI]
-    # @yieldreturn [JSI::Base] a JSI instance containing the resource identified by the given uri
-    # @return [void]
-    def autoload_uri(uri, &block)
-      uri = ensure_uri_absolute(uri)
-      mutating
-      unless block
-        raise(ArgumentError, ["#{SchemaRegistry}#autoload_uri must be invoked with a block", "URI: #{uri}"].join("\n"))
-      end
-      if @autoload_uris.key?(uri)
-        raise(Collision, ["already registered URI for autoload", "URI: #{uri}", "loader: #{@autoload_uris[uri]}"].join("\n"))
-      end
-      @autoload_uris[uri] = block
-      nil
-    end
-
-    # @param uri [Addressable::URI, #to_str]
-    # @return [JSI::Base]
-    # @raise [JSI::SchemaRegistry::ResourceNotFound]
-    def find(uri)
-      uri = ensure_uri_absolute(uri)
-      if @autoload_uris.key?(uri)
-        autoloaded = @autoload_uris[uri].call
-        register(autoloaded)
-        @autoload_uris.delete(uri)
-      end
-      if !@resources.key?(uri)
-        if autoloaded
-          msg = [
-            "URI #{uri} was registered with autoload_uri but the result did not contain a resource with that URI.",
-            "the resource resulting from autoload_uri was:",
-            autoloaded.pretty_inspect.chomp,
-          ]
-        else
-          msg = ["URI #{uri} is not registered. registered URIs:", *(@resources.keys | @autoload_uris.keys)]
-        end
-        raise(ResourceNotFound.new(msg.join("\n")).tap { |e| e.uri = uri })
-      end
-      @resources[uri]
-    end
-
-    def inspect
-      [
-        '#<JSI::SchemaRegistry',
-        *[['autoload', @autoload_uris.keys], ['resources', @resources.keys]].map do |label, uris|
-          [
-            "  #{label} (#{uris.size})#{uris.empty? ? "" : ":"}",
-            *uris.map do |uri|
-              "    #{uri}"
-            end,
-          ]
-        end.inject([], &:+),
-        '>',
-      ].join("\n").freeze
-    end
-
-    alias_method :to_s, :inspect
-
-    def dup
-      self.class.new.tap do |reg|
-        @resources.each do |uri, resource|
-          reg.register_single(uri, resource)
-        end
-        @autoload_uris.each do |uri, autoload|
-          reg.autoload_uri(uri, &autoload)
-        end
-      end
-    end
-
-    def freeze
-      @resources.freeze
-      @autoload_uris.freeze
-      @resources_mutex = nil
-      super
-    end
-
-    protected
-    # @param uri [Addressable::URI]
-    # @param resource [JSI::Base]
-    # @return [void]
-    def register_single(uri, resource)
-      mutating
-      @resources_mutex.synchronize do
-        ensure_uri_absolute(uri)
-        if @resources.key?(uri)
-          if @resources[uri] != resource
-            raise(Collision, "URI collision on #{uri}.\nexisting:\n#{@resources[uri].pretty_inspect.chomp}\nnew:\n#{resource.pretty_inspect.chomp}")
-          end
-        else
-          @resources[uri] = resource
-        end
-      end
-      nil
-    end
-
-    private
-
-    def ensure_uri_absolute(uri)
-      uri = Util.uri(uri)
-      if uri.fragment
-        raise(NonAbsoluteURI, "#{self.class} only registers absolute URIs. cannot access URI with fragment: #{uri}")
-      end
-      if uri.relative?
-        raise(NonAbsoluteURI, "#{self.class} only registers absolute URIs. cannot access relative URI: #{uri}")
-      end
-      uri
-    end
-
-    def mutating
-      if frozen?
-        raise(FrozenError, "cannot modify frozen #{self.class}")
-      end
-    end
-  end
-end