jsi 0.6.0 → 0.8.0

data/lib/jsi/schema/ref.rb

@@ -1,30 +1,45 @@
 # 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)
+  # 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
-    # @param ref_schema [JSI::Schema] a schema from which the reference originated
-    def initialize(ref, ref_schema = nil)
+    # @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 = Addressable::URI.parse(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 instance_variable_defined?(:@deref_schema)
+      return @deref_schema if @deref_schema
 
       schema_resource_root = nil
       check_schema_resource_root = -> {
@@ -36,7 +51,7 @@ module JSI
         end
       }
 
-      ref_uri_nofrag = ref_uri.merge(fragment: nil)
+      ref_uri_nofrag = ref_uri.merge(fragment: nil).freeze
 
       if ref_uri_nofrag.empty?
         unless ref_schema
@@ -49,28 +64,34 @@ module JSI
         # 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
+        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)
+          ref_abs_uri = ref_schema.jsi_resource_ancestor_uri.join(ref_uri_nofrag).freeze
         else
           ref_abs_uri = nil
         end
         if ref_abs_uri
-          schema_resource_root = JSI.schema_registry.find(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_key do |k|
-              if Addressable::URI.parse(ref_schema.jsi_document['schemas'][k]['id']) == ref_uri_nofrag
+            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
@@ -84,7 +105,7 @@ module JSI
         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) }
+          resolve_fragment_ptr = -> (ptr) { schema_resource_root.jsi_descendent_node(ptr) }
         end
       end
 
@@ -137,7 +158,11 @@ module JSI
 
     # @return [String]
     def inspect
-      %Q(\#<#{self.class.name} #{ref}>)
+      -%Q(\#<#{self.class.name} #{ref}>)
+    end
+
+    def to_s
+      inspect
     end
 
     # pretty-prints a representation of self to the given printer
@@ -150,10 +175,12 @@ module JSI
       q.text '>'
     end
 
-    # @private
+    # see {Util::Private::FingerprintHash}
+    # @api private
     def jsi_fingerprint
-      {class: self.class, ref: ref, ref_schema: ref_schema}
+      {class: self.class, ref: ref, ref_schema: ref_schema}.freeze
     end
-    include Util::FingerprintHash
+
+    include(Util::FingerprintHash::Immutable)
   end
 end

data/lib/jsi/schema/schema_ancestor_node.rb

@@ -4,39 +4,49 @@ 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.
-    # @private
+    # This may be the absolute schema URI of an ancestor 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.
-    # @private
+    # @api 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
+    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,
+    # If this node is a schema with an id, this is its absolute URI; otherwise an ancestor 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
+      (is_a?(Schema) && schema_absolute_uri) || jsi_schema_base_uri
     end
 
-    # a schema at or below this node with the given anchor.
+    # 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 = jsi_anchor_subschemas_map[anchor]
+      subschemas = @anchor_subschemas_map[anchor: anchor]
       if subschemas.size == 1
         subschemas.first
       else
@@ -44,76 +54,69 @@ module JSI
       end
     end
 
-    # schemas at or below node with the given anchor.
+    # All schemas at or below this node with the given anchor.
     #
-    # @return [Array<JSI::Schema>]
+    # @return [Set<JSI::Schema>]
     def jsi_anchor_subschemas(anchor)
-      jsi_anchor_subschemas_map[anchor]
+      @anchor_subschemas_map[anchor: anchor]
     end
 
     private
 
-    def jsi_document=(jsi_document)
-      @jsi_document = jsi_document
+    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)
-      unless jsi_ptr.is_a?(Ptr)
-        raise(TypeError, "jsi_ptr must be a JSI::Ptr; got: #{jsi_ptr.inspect}")
-      end
+      #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)
-      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
+      #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)
-      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
+      #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.ancestor_of?(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
 
-    def jsi_anchor_subschemas_map
-      jsi_memomap(__method__) do |anchor|
-        jsi_each_child_node.select do |node|
+    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.freeze
-      end
+        end.to_set.freeze
+    end
+
+    # @return [Util::MemoMap]
+    def jsi_memomap(**options, &block)
+      jsi_memomap_class.new(**options, &block)
     end
   end
 end

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

@@ -4,7 +4,7 @@ module JSI
   module Schema::Validation::ArrayLength
     # @private
     def internal_validate_maxItems(result_builder)
-      if schema_content.key?('maxItems')
+      if keyword?('maxItems')
         value = schema_content['maxItems']
         # The value of this keyword MUST be a non-negative integer.
         if internal_integer?(value) && value >= 0
@@ -24,7 +24,7 @@ module JSI
 
     # @private
     def internal_validate_minItems(result_builder)
-      if schema_content.key?('minItems')
+      if keyword?('minItems')
         value = schema_content['minItems']
         # The value of this keyword MUST be a non-negative integer.
         if internal_integer?(value) && value >= 0
@@ -45,7 +45,7 @@ module JSI
   module Schema::Validation::UniqueItems
     # @private
     def internal_validate_uniqueItems(result_builder)
-      if schema_content.key?('uniqueItems')
+      if keyword?('uniqueItems')
         value = schema_content['uniqueItems']
         # The value of this keyword MUST be a boolean.
         if value == false

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

@@ -4,7 +4,7 @@ module JSI
   module Schema::Validation::Const
     # @private
     def internal_validate_const(result_builder)
-      if schema_content.key?('const')
+      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

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

@@ -4,13 +4,13 @@ module JSI
   module Schema::Validation::Contains
     # @private
     def internal_validate_contains(result_builder)
-      if schema_content.key?('contains')
+      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(['contains'], [i])
+            results[i] = result_builder.child_subschema_validate(i, ['contains'])
           end
           result_builder.validate(
             results.values.any?(&:valid?),

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

@@ -4,7 +4,7 @@ module JSI
   module Schema::Validation::Dependencies
     # @private
     def internal_validate_dependencies(result_builder)
-      if schema_content.key?('dependencies')
+      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.

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

@@ -4,18 +4,19 @@ module JSI
   module Schema::Validation::Draft04::MinMax
     # @private
     def internal_validate_maximum(result_builder)
-      if schema_content.key?('exclusiveMaximum')
+      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 !schema_content.key?('maximum')
+        #> If "exclusiveMaximum" is present, "maximum" MUST also be present.
+        if !keyword?('maximum')
           result_builder.schema_error('`exclusiveMaximum` has no effect without adjacent `maximum` keyword', 'exclusiveMaximum')
         end
       end
 
-      if schema_content.key?('maximum')
+      if keyword?('maximum')
         value = schema_content['maximum']
         # The value of "maximum" MUST be a JSON number.
         if value.is_a?(Numeric)
@@ -47,18 +48,19 @@ module JSI
 
     # @private
     def internal_validate_minimum(result_builder)
-      if schema_content.key?('exclusiveMinimum')
+      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 !schema_content.key?('minimum')
+        #> If "exclusiveMinimum" is present, "minimum" MUST also be present.
+        if !keyword?('minimum')
           result_builder.schema_error('`exclusiveMinimum` has no effect without adjacent `minimum` keyword', 'exclusiveMinimum')
         end
       end
 
-      if schema_content.key?('minimum')
+      if keyword?('minimum')
         value = schema_content['minimum']
         # The value of "minimum" MUST be a JSON number.
         if value.is_a?(Numeric)

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

@@ -4,8 +4,6 @@ module JSI
   module Schema::Validation::Draft04
     autoload :MinMax, 'jsi/schema/validation/draft04/minmax'
 
-    include Schema::Validation::Core
-
     include Schema::Validation::Ref
 
     include Schema::Validation::MultipleOf

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

@@ -2,8 +2,6 @@
 
 module JSI
   module Schema::Validation::Draft06
-    include Schema::Validation::Core
-
     include Schema::Validation::Ref
     include Schema::Validation::AllOf
     include Schema::Validation::AnyOf

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

@@ -2,8 +2,6 @@
 
 module JSI
   module Schema::Validation::Draft07
-    include Schema::Validation::Core
-
     include Schema::Validation::Ref
 
     include Schema::Validation::Type

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

@@ -4,7 +4,7 @@ module JSI
   module Schema::Validation::Enum
     # @private
     def internal_validate_enum(result_builder)
-      if schema_content.key?('enum')
+      if keyword?('enum')
         value = schema_content['enum']
         # The value of this keyword MUST be an array. This array SHOULD have at least one element.
         # Elements in the array SHOULD be unique.

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

@@ -4,7 +4,7 @@ module JSI
   module Schema::Validation::IfThenElse
     # @private
     def internal_validate_ifthenelse(result_builder)
-      if schema_content.key?('if')
+      if keyword?('if')
         # This keyword's value MUST be a valid JSON Schema.
         # This validation outcome of this keyword's subschema has no direct effect on the overall validation
         # result. Rather, it controls which of the "then" or "else" keywords are evaluated.
@@ -13,7 +13,7 @@ module JSI
         result_builder.merge_schema_issues(if_result)
 
         if if_result.valid?
-          if schema_content.key?('then')
+          if keyword?('then')
             then_result = result_builder.inplace_subschema_validate(['then'])
             result_builder.validate(
               then_result.valid?,
@@ -23,7 +23,7 @@ module JSI
             )
           end
         else
-          if schema_content.key?('else')
+          if keyword?('else')
             else_result = result_builder.inplace_subschema_validate(['else'])
             result_builder.validate(
               else_result.valid?,
@@ -34,10 +34,10 @@ module JSI
           end
         end
       else
-        if schema_content.key?('then')
+        if keyword?('then')
           result_builder.schema_warning('`then` has no effect without adjacent `if` keyword', 'then')
         end
-        if schema_content.key?('else')
+        if keyword?('else')
           result_builder.schema_warning('`else` has no effect without adjacent `if` keyword', 'else')
         end
       end

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

@@ -4,7 +4,7 @@ module JSI
   module Schema::Validation::Items
     # @private
     def internal_validate_items(result_builder)
-      if schema_content.key?('items')
+      if keyword?('items')
         value = schema_content['items']
         # The value of "items" MUST be either a valid JSON Schema or an array of valid JSON Schemas.
         if value.respond_to?(:to_ary)
@@ -14,9 +14,9 @@ module JSI
             results = {}
             result_builder.instance.each_index do |i|
               if i < value.size
-                results[i] = result_builder.child_subschema_validate(['items', i], [i])
-              elsif schema_content.key?('additionalItems')
-                results[i] = result_builder.child_subschema_validate(['additionalItems'], [i])
+                results[i] = result_builder.child_subschema_validate(i, ['items', i])
+              elsif keyword?('additionalItems')
+                results[i] = result_builder.child_subschema_validate(i, ['additionalItems'])
               end
             end
             result_builder.validate(
@@ -31,7 +31,7 @@ module JSI
           # against that schema.
           if result_builder.instance.respond_to?(:to_ary)
             results = result_builder.instance.each_index.map do |i|
-              result_builder.child_subschema_validate(['items'], [i])
+              result_builder.child_subschema_validate(i, ['items'])
             end
             result_builder.validate(
               results.all?(&:valid?),
@@ -40,12 +40,12 @@ module JSI
               results: results,
             )
           end
-          if schema_content.key?('additionalItems')
+          if keyword?('additionalItems')
             result_builder.schema_warning('`additionalItems` has no effect when adjacent `items` keyword is not an array', 'items')
           end
         end
       else
-        if schema_content.key?('additionalItems')
+        if keyword?('additionalItems')
           result_builder.schema_warning('`additionalItems` has no effect without adjacent `items` keyword', 'items')
         end
       end

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

@@ -4,7 +4,7 @@ module JSI
   module Schema::Validation::Not
     # @private
     def internal_validate_not(result_builder)
-      if schema_content.key?('not')
+      if keyword?('not')
         # This keyword's value MUST be a valid JSON Schema.
         # An instance is valid against this keyword if it fails to validate successfully against the schema
         # defined by this keyword.

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

@@ -4,7 +4,7 @@ module JSI
   module Schema::Validation::MultipleOf
     # @private
     def internal_validate_multipleOf(result_builder)
-      if schema_content.key?('multipleOf')
+      if keyword?('multipleOf')
         value = schema_content['multipleOf']
         # The value of "multipleOf" MUST be a number, strictly greater than 0.
         if value.is_a?(Numeric) && value > 0
@@ -36,7 +36,7 @@ module JSI
   module Schema::Validation::MinMax
     # @private
     def internal_validate_maximum(result_builder)
-      if schema_content.key?('maximum')
+      if keyword?('maximum')
         value = schema_content['maximum']
         # The value of "maximum" MUST be a number, representing an inclusive upper limit for a numeric instance.
         if value.is_a?(Numeric)
@@ -57,7 +57,7 @@ module JSI
 
     # @private
     def internal_validate_exclusiveMaximum(result_builder)
-      if schema_content.key?('exclusiveMaximum')
+      if keyword?('exclusiveMaximum')
         value = schema_content['exclusiveMaximum']
         # The value of "exclusiveMaximum" MUST be number, representing an exclusive upper limit for a numeric instance.
         if value.is_a?(Numeric)
@@ -78,7 +78,7 @@ module JSI
 
     # @private
     def internal_validate_minimum(result_builder)
-      if schema_content.key?('minimum')
+      if keyword?('minimum')
         value = schema_content['minimum']
         # The value of "minimum" MUST be a number, representing an inclusive lower limit for a numeric instance.
         if value.is_a?(Numeric)
@@ -99,7 +99,7 @@ module JSI
 
     # @private
     def internal_validate_exclusiveMinimum(result_builder)
-      if schema_content.key?('exclusiveMinimum')
+      if keyword?('exclusiveMinimum')
         value = schema_content['exclusiveMinimum']
         # The value of "exclusiveMinimum" MUST be number, representing an exclusive lower limit for a numeric instance.
         if value.is_a?(Numeric)

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

@@ -4,7 +4,7 @@ module JSI
   module Schema::Validation::MinMaxProperties
     # @private
     def internal_validate_maxProperties(result_builder)
-      if schema_content.key?('maxProperties')
+      if keyword?('maxProperties')
         value = schema_content['maxProperties']
         # The value of this keyword MUST be a non-negative integer.
         if internal_integer?(value) && value >= 0
@@ -24,7 +24,7 @@ module JSI
 
     # @private
     def internal_validate_minProperties(result_builder)
-      if schema_content.key?('minProperties')
+      if keyword?('minProperties')
         value = schema_content['minProperties']
         # The value of this keyword MUST be a non-negative integer.
         if internal_integer?(value) && value >= 0

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

@@ -4,7 +4,7 @@ module JSI
   module Schema::Validation::Pattern
     # @private
     def internal_validate_pattern(result_builder)
-      if schema_content.key?('pattern')
+      if keyword?('pattern')
         value = schema_content['pattern']
         # The value of this keyword MUST be a string.
         if value.respond_to?(:to_str)
@@ -22,7 +22,7 @@ module JSI
                 keyword: 'pattern',
               )
             rescue RegexpError => e
-              result_builder.schema_error("`pattern` is not a valid regular expression: #{e.message}", 'pattern')
+              result_builder.schema_error(-"`pattern` is not a valid regular expression: #{e.message}", 'pattern')
             end
           end
         else