jsi 0.7.0 → 0.8.0

data/lib/jsi/schema/schema_ancestor_node.rb

@@ -4,9 +4,21 @@ 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.
+    # 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
@@ -14,25 +26,27 @@ module JSI
     # resources which are ancestors of this JSI in the document. this does not include self.
     # @api private
     # @return [Array<JSI::Schema>]
-    def jsi_schema_resource_ancestors
-      return @jsi_schema_resource_ancestors if instance_variable_defined?(:@jsi_schema_resource_ancestors)
-      Util::EMPTY_ARY
-    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
       (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: anchor]
+      subschemas = @anchor_subschemas_map[anchor: anchor]
       if subschemas.size == 1
         subschemas.first
       else
@@ -40,74 +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]
+      @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)
-      raise(Bug, "jsi_ptr not #{Ptr}: #{jsi_ptr.inspect}") unless jsi_ptr.is_a?(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)
-      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 = Util::EMPTY_ARY
-      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: |
+    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/contains.rb

@@ -10,7 +10,7 @@ module JSI
         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/draft04/minmax.rb

@@ -10,6 +10,7 @@ module JSI
         unless [true, false].include?(value)
           result_builder.schema_error('`exclusiveMaximum` is not true or false', 'exclusiveMaximum')
         end
+        #> 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
@@ -53,6 +54,7 @@ module JSI
         unless [true, false].include?(value)
           result_builder.schema_error('`exclusiveMinimum` is not true or false', 'exclusiveMinimum')
         end
+        #> 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

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/items.rb

@@ -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])
+                results[i] = result_builder.child_subschema_validate(i, ['items', i])
               elsif keyword?('additionalItems')
-                results[i] = result_builder.child_subschema_validate(['additionalItems'], [i])
+                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?),

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

@@ -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

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

@@ -19,8 +19,8 @@ module JSI
               if value.key?(property_name)
                 evaluated_property_names << property_name
                 results[property_name] = result_builder.child_subschema_validate(
+                  property_name,
                   ['properties', property_name],
-                  [property_name],
                 )
               end
             end
@@ -54,8 +54,8 @@ module JSI
                   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],
-                      [property_name],
                     )
                   end
                 rescue ::RegexpError
@@ -83,11 +83,11 @@ module JSI
           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'],
-                [property_name],
               )
             end
-          end.compact
+          end
           result_builder.validate(
             results.values.all?(&:valid?),
             'instance object additional properties are not all valid against `additionalProperties` schema value',

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

@@ -10,7 +10,7 @@ module JSI
         value = schema_content['$ref']
 
         if value.respond_to?(:to_str)
-          schema_ref = jsi_memoize(:ref) { Schema::Ref.new(value, self) }
+          schema_ref = self.schema_ref('$ref')
 
           if result_builder.visited_refs.include?(schema_ref)
             result_builder.schema_error('self-referential schema structure', '$ref')

data/lib/jsi/schema/validation.rb

@@ -2,8 +2,6 @@
 
 module JSI
   module Schema::Validation
-    autoload :Core, 'jsi/schema/validation/core'
-
     autoload :Draft04, 'jsi/schema/validation/draft04'
     autoload :Draft06, 'jsi/schema/validation/draft06'
     autoload :Draft07, 'jsi/schema/validation/draft07'