jsi 0.3.0 → 0.4.0

data/lib/jsi/metaschema_node.rb

@@ -24,7 +24,7 @@ module JSI
   # its schema is the metaschema.
   class MetaschemaNode
     include PathedNode
-    include Memoize
+    include Util::Memoize
 
     # not every MetaschemaNode is actually an Enumerable, but it's better to include Enumerable on
     # the class than to conditionally extend the instance.
@@ -49,39 +49,39 @@ module JSI
       end
 
       instance_for_schema = node_document
-      schema_ptr = node_ptr.reference_tokens.inject(root_schema_ptr) do |ptr0, tok|
+      schema_ptrs = node_ptr.reference_tokens.inject(Set.new << root_schema_ptr) do |ptrs, tok|
         if instance_for_schema.respond_to?(:to_ary)
-          ptr1 = ptr0 && ptr0.schema_subschema_ptr_for_index(node_document, tok)
+          subschema_ptrs_for_token = ptrs.map do |ptr|
+            ptr.schema_subschema_ptrs_for_index(node_document, tok)
+          end.inject(Set.new, &:|)
         else
-          ptr1 = ptr0 && ptr0.schema_subschema_ptr_for_property_name(node_document, tok)
+          subschema_ptrs_for_token = ptrs.map do |ptr|
+            ptr.schema_subschema_ptrs_for_property_name(node_document, tok)
+          end.inject(Set.new, &:|)
         end
         instance_for_schema = instance_for_schema[tok]
-        ptr2 = ptr1 && ptr1.deref(node_document)
-        ptr3 = ptr2 && ptr2.schema_match_ptr_to_instance(node_document, instance_for_schema)
-        ptr3 # only God may judge my variable names
+        ptrs_for_instance = subschema_ptrs_for_token.map do |ptr|
+          ptr.schema_match_ptrs_to_instance(node_document, instance_for_schema)
+        end.inject(Set.new, &:|)
+        ptrs_for_instance
       end
 
-      @schema = if schema_ptr
+      @jsi_schemas = schema_ptrs.map do |schema_ptr|
         if schema_ptr == node_ptr
           self
         else
           new_node(node_ptr: schema_ptr)
         end
-      else
-        nil
-      end
+      end.to_set
 
-      if schema_ptr
-        if schema_ptr == metaschema_root_ptr
+      @jsi_schemas.each do |schema|
+        if schema.node_ptr == metaschema_root_ptr
           extend JSI::Schema
         end
-        if schema_ptr == node_ptr
+        if schema.node_ptr == node_ptr
           extend Metaschema
         end
-      end
-
-      if @schema
-        extend(JSI::SchemaClasses.accessor_module_for_schema(@schema, conflicting_modules: [Metaschema, Schema, MetaschemaNode, PathedArrayNode, PathedHashNode]))
+        extend(JSI::SchemaClasses.accessor_module_for_schema(schema, conflicting_modules: [Metaschema, Schema, MetaschemaNode, PathedArrayNode, PathedHashNode]))
       end
 
       # workarounds
@@ -106,8 +106,8 @@ module JSI
     attr_reader :metaschema_root_ptr
     # ptr to the schema of the root of the node_document
     attr_reader :root_schema_ptr
-    # a JSI::Schema describing this MetaschemaNode
-    attr_reader :schema
+    # JSI::Schemas describing this MetaschemaNode
+    attr_reader :jsi_schemas
 
     # @return [MetaschemaNode] document root MetaschemaNode
     def document_root_node
@@ -134,7 +134,7 @@ module JSI
         raise(NoMethodError, "cannot subcript (using token: #{token.inspect}) from content: #{node_content.pretty_inspect.chomp}")
       end
 
-      jsi_memoize(:[], token, value, token_in_range) do |token, value, token_in_range|
+      result = jsi_memoize(:[], token, value, token_in_range) do |token, value, token_in_range|
         if token_in_range
           value_node = new_node(node_ptr: node_ptr[token])
 
@@ -148,6 +148,7 @@ module JSI
           nil
         end
       end
+      result
     end
 
     # if this MetaschemaNode is a $ref then the $ref is followed. otherwise this MetaschemaNode is returned.
@@ -186,13 +187,13 @@ module JSI
 
     # @return [Array<String>]
     def object_group_text
-      if schema
-        class_n_schema = "#{self.class} (#{schema.node_ptr.fragment})"
+      if jsi_schemas.any?
+        class_n_schemas = "#{self.class} (#{jsi_schemas.map { |s| s.node_ptr.uri }.join(' ')})"
       else
-        class_n_schema = self.class.to_s
+        class_n_schemas = self.class.to_s
       end
       [
-        class_n_schema,
+        class_n_schemas,
         is_a?(Metaschema) ? "Metaschema" : is_a?(Schema) ? "Schema" : nil,
         *(node_content.respond_to?(:object_group_text) ? node_content.object_group_text : []),
       ].compact
@@ -202,7 +203,7 @@ module JSI
     def jsi_fingerprint
       {class: self.class, node_document: node_document}.merge(our_initialize_params)
     end
-    include FingerprintHash
+    include Util::FingerprintHash
 
     private
 

data/lib/jsi/schema.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
 module JSI
-  # JSI::Schema represents a JSON Schema. initialized from a Hash-like schema
-  # object, JSI::Schema is a relatively simple class to abstract useful methods
-  # applied to a JSON Schema.
+  # JSI::Schema is a module which extends instances which represent JSON schemas.
+  #
+  # the content of an instance which is a JSI::Schema (referred to in this context as schema_content) is
+  # expected to be a Hash (JSON object) or a Boolean.
   module Schema
     class Error < StandardError
     end
@@ -12,8 +13,6 @@ module JSI
     class NotASchemaError < Error
     end
 
-    include Memoize
-
     # JSI::Schema::DescribesSchema: a schema which describes another schema. this module
     # extends a JSI::Schema instance and indicates that JSIs which instantiate the schema
     # are themselves also schemas.
@@ -109,14 +108,13 @@ module JSI
           parent_auri = Addressable::URI.parse(parent_id)
           if parent_auri.fragment
             # add onto the fragment
-            parent_id_path = JSI::JSON::Pointer.from_fragment('#' + parent_auri.fragment).reference_tokens
+            parent_id_path = JSI::JSON::Pointer.from_fragment(parent_auri.fragment).reference_tokens
             path_from_id_node = parent_id_path + path_from_id_node
             parent_auri.fragment = nil
           #else: no fragment so parent_id good as is
           end
 
-          fragment = JSI::JSON::Pointer.new(path_from_id_node).fragment
-          schema_id = parent_auri.to_s + fragment
+          schema_id = parent_auri.merge(fragment: JSI::JSON::Pointer.new(path_from_id_node).fragment).to_s
 
           schema_id
         else
@@ -130,17 +128,20 @@ module JSI
       JSI::SchemaClasses.module_for_schema(self)
     end
 
-    # @return [Class subclassing JSI::Base] shortcut for JSI.class_for_schema(schema)
+    # @return [Class < JSI::Base] a JSI class for this one schema
     def jsi_schema_class
-      JSI.class_for_schema(self)
+      JSI.class_for_schemas(Set[self])
     end
 
-    # calls #new on the class for this schema with the given arguments. for parameters,
-    # see JSI::Base#initialize documentation.
+    # instantiates the given other_instance as a JSI::Base class for schemas matched from this schema to the
+    # other_instance.
+    #
+    # any parameters are passed to JSI::Base#initialize, but none are normally used.
     #
-    # @return [JSI::Base] a JSI whose schema is this schema and whose instance is the given instance
+    # @return [JSI::Base] a JSI whose instance is the given instance and whose schemas are matched from this
+    #   schema.
     def new_jsi(other_instance, *a, &b)
-      JSI.class_for_schema(match_to_instance(other_instance)).new(other_instance, *a, &b)
+      JSI.class_for_schemas(match_to_instance(other_instance)).new(other_instance, *a, &b)
     end
 
     # @return [Boolean] does this schema itself describe a schema?
@@ -148,60 +149,48 @@ module JSI
       is_a?(JSI::Schema::DescribesSchema)
     end
 
-    # if this schema is a oneOf, allOf, anyOf schema, #match_to_instance finds
-    # one of the subschemas that matches the given instance and returns it. if
-    # there are no matching *Of schemas, this schema is returned.
+    # checks this schema for applicators ($ref, allOf, etc.) which should be applied to the given instance.
+    # returns these as a Set of {JSI::Schema}s.
     #
-    # @param other_instance [Object] the instance to which to attempt to match *Of subschemas
-    # @return [JSI::Schema] a matched subschema, or this schema (self)
+    # the returned set will contain this schema itself, unless this schema contains a $ref keyword.
+    #
+    # @param other_instance [Object] the instance to check any applicators against
+    # @return [Set<JSI::Schema>] matched applicator schemas
     def match_to_instance(other_instance)
-      ptr = node_ptr
-      ptr = ptr.deref(node_document)
-      ptr = ptr.schema_match_ptr_to_instance(node_document, other_instance)
-      if ptr
+      node_ptr.schema_match_ptrs_to_instance(node_document, other_instance).map do |ptr|
         ptr.evaluate(document_root_node).tap { |subschema| jsi_ensure_subschema_is_schema(subschema, ptr) }
-      else
-        self
-      end
+      end.to_set
     end
 
-    # @param property_name [String] the property name for which to find a subschema
-    # @return [JSI::Schema, nil] a subschema from `properties`, `patternProperties`, or `additionalProperties` for the given token
-    def subschema_for_property(property_name)
-      jsi_memoize(:subschema_for_property, property_name) do |property_name|
-        ptr = node_ptr
-        ptr = ptr.deref(node_document)
-        ptr = ptr.schema_subschema_ptr_for_property_name(node_document, property_name)
-        if ptr
-          ptr = ptr.deref(node_document)
+    # returns a set of subschemas of this schema for the given property name, from keywords
+    #   `properties`, `patternProperties`, and `additionalProperties`.
+    #
+    # @param property_name [String] the property name for which to find subschemas
+    # @return [Set<JSI::Schema>] subschemas of this schema for the given property_name
+    def subschemas_for_property_name(property_name)
+      jsi_memoize(:subschemas_for_property_name, property_name) do |property_name|
+        node_ptr.schema_subschema_ptrs_for_property_name(node_document, property_name).map do |ptr|
           ptr.evaluate(document_root_node).tap { |subschema| jsi_ensure_subschema_is_schema(subschema, ptr) }
-        else
-          nil
-        end
+        end.to_set
       end
     end
 
-    # @param index [Integer] the array index for which to find a subschema
-    # @return [JSI::Schema, nil] a subschema from `items` or `additionalItems` for the given token
-    def subschema_for_index(index)
-      jsi_memoize(:subschema_for_index, index) do |index|
-        ptr = node_ptr
-        ptr = ptr.deref(node_document)
-        ptr = ptr.schema_subschema_ptr_for_index(node_document, index)
-        if ptr
-          ptr = ptr.deref(node_document)
+    # returns a set of subschemas of this schema for the given array index, from keywords
+    #   `items` and `additionalItems`.
+    #
+    # @param index [Integer] the array index for which to find subschemas
+    # @return [Set<JSI::Schema>] subschemas of this schema for the given array index
+    def subschemas_for_index(index)
+      jsi_memoize(:subschemas_for_index, index) do |index|
+        node_ptr.schema_subschema_ptrs_for_index(node_document, index).map do |ptr|
           ptr.evaluate(document_root_node).tap { |subschema| jsi_ensure_subschema_is_schema(subschema, ptr) }
-        else
-          nil
-        end
+        end.to_set
       end
     end
 
-    # @return [Set] any object property names this schema indicates may be
-    #   present on its instances. this includes, if present: keys of this
-    #   schema's "properties" object; entries of this schema's array of
-    #   "required" property keys. if this schema has allOf subschemas, those
-    #   schemas are checked (recursively) for their described object property names.
+    # @return [Set] any object property names this schema indicates may be present on its instances.
+    #   this includes any keys of this schema's "properties" object and any entries of this schema's
+    #   array of "required" property keys.
     def described_object_property_names
       jsi_memoize(:described_object_property_names) do
         Set.new.tap do |property_names|
@@ -211,12 +200,6 @@ module JSI
           if node_content.respond_to?(:to_hash) && node_content['required'].respond_to?(:to_ary)
             property_names.merge(node_content['required'].to_ary)
           end
-          # we should look at dependencies (TODO).
-          if respond_to?(:to_hash) && self['allOf'].respond_to?(:to_ary)
-            self['allOf'].select{ |s| s.is_a?(JSI::Schema) }.map(&:deref).map do |allOf_schema|
-              property_names.merge(allOf_schema.described_object_property_names)
-            end
-          end
         end
       end
     end

data/lib/jsi/schema_classes.rb

@@ -11,11 +11,11 @@ module JSI
 
     # @return [String]
     def inspect
-      idfrag = schema.schema_id || schema.node_ptr.fragment
+      uri = schema.schema_id || schema.node_ptr.uri
       if name
-        "#{name} (#{idfrag})"
+        "#{name} (#{uri})"
       else
-        "(JSI Schema Module: #{idfrag})"
+        "(JSI Schema Module: #{uri})"
       end
     end
 
@@ -29,16 +29,16 @@ module JSI
   # this module is just a namespace for schema classes.
   module SchemaClasses
     class << self
-      include Memoize
-
-      # see {JSI.class_for_schema}
-      def class_for_schema(schema_object)
-        jsi_memoize(:class_for_schema, JSI::Schema.from_object(schema_object)) do |schema|
-          Class.new(Base).instance_exec(schema) do |schema|
-            define_singleton_method(:schema) { schema }
-            define_method(:schema) { schema }
-            include(schema.jsi_schema_module)
-
+      include Util::Memoize
+
+      # see {JSI.class_for_schemas}
+      def class_for_schemas(schema_objects)
+        schemas = schema_objects.map { |schema_object| JSI::Schema.from_object(schema_object) }.to_set
+        jsi_memoize(:class_for_schemas, schemas) do |schemas|
+          Class.new(Base).instance_exec(schemas) do |schemas|
+            define_singleton_method(:jsi_class_schemas) { schemas }
+            define_method(:jsi_schemas) { schemas }
+            schemas.each { |schema| include(schema.jsi_schema_module) }
             jsi_class = self
             define_method(:jsi_class) { jsi_class }
 
@@ -61,11 +61,13 @@ module JSI
 
               extend SchemaModule
 
-              include JSI::SchemaClasses.accessor_module_for_schema(schema, conflicting_modules: [JSI::Base, JSI::BaseArray, JSI::BaseHash])
+              include JSI::SchemaClasses.accessor_module_for_schema(schema, conflicting_modules: [JSI::Base, JSI::PathedArrayNode, JSI::PathedHashNode])
 
               @possibly_schema_node = schema
               extend(SchemaModulePossibly)
-              extend(JSI::SchemaClasses.accessor_module_for_schema(schema.schema, conflicting_modules: [Module, SchemaModule, SchemaModulePossibly]))
+              schema.jsi_schemas.each do |schema_schema|
+                extend(JSI::SchemaClasses.accessor_module_for_schema(schema_schema, conflicting_modules: [Module, SchemaModule, SchemaModulePossibly]))
+              end
             end
           end
         end
@@ -78,6 +80,9 @@ module JSI
       # @return [Module] a module of accessors (setters and getters) for described property names of the given
       #   schema
       def accessor_module_for_schema(schema, conflicting_modules: )
+        unless schema.is_a?(JSI::Schema)
+          raise(JSI::Schema::NotASchemaError, "not a schema: #{schema.pretty_inspect.chomp}")
+        end
         jsi_memoize(:accessor_module_for_schema, schema, conflicting_modules) do |schema, conflicting_modules|
           Module.new.tap do |m|
             m.module_eval do
@@ -143,7 +148,9 @@ module JSI
         raise(TypeError, "cannot instantiate NotASchemaModule for a JSI::Schema node: #{node.pretty_inspect.chomp}")
       end
       @possibly_schema_node = node
-      extend(JSI::SchemaClasses.accessor_module_for_schema(node.schema, conflicting_modules: [NotASchemaModule, SchemaModulePossibly]))
+      node.jsi_schemas.each do |schema|
+        extend(JSI::SchemaClasses.accessor_module_for_schema(schema, conflicting_modules: [NotASchemaModule, SchemaModulePossibly]))
+      end
     end
 
     include SchemaModulePossibly

data/lib/jsi/util.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module JSI
+  # JSI::Util classes, modules, constants, and methods are INTERNAL and will be added and removed without warning.
+  # do not rely on them.
   module Util
     # a proc which does nothing
     NOOP = -> (*_) { }
@@ -16,7 +18,7 @@ module JSI
     # the return if you need to ensure it is not the same instance as the
     # argument instance.
     #
-    # @param hash [#to_hash] the hash from which to convert symbol keys to strings
+    # @param hashlike [#to_hash] the hash from which to convert symbol keys to strings
     # @return [same class as the param `hash`, or Hash if the former cannot be done] a
     #    hash(-like) instance containing no symbol keys
     def stringify_symbol_keys(hashlike)
@@ -65,43 +67,42 @@ module JSI
       proc { |f| f.call(f) }.call(proc { |f| yield proc { |*x| f.call(f).call(*x) } })
     end
     module_function :ycomb
-  end
-  public
-  extend Util
 
-  module FingerprintHash
-    # overrides BasicObject#==
-    def ==(other)
-      object_id == other.object_id || (other.respond_to?(:jsi_fingerprint) && other.jsi_fingerprint == self.jsi_fingerprint)
-    end
+    module FingerprintHash
+      # overrides BasicObject#==
+      def ==(other)
+        object_id == other.object_id || (other.respond_to?(:jsi_fingerprint) && other.jsi_fingerprint == self.jsi_fingerprint)
+      end
 
-    alias_method :eql?, :==
+      alias_method :eql?, :==
 
-    # overrides Kernel#hash
-    def hash
-      jsi_fingerprint.hash
+      # overrides Kernel#hash
+      def hash
+        jsi_fingerprint.hash
+      end
     end
-  end
 
-  module Memoize
-    def jsi_memoize(key, *args_)
-      @jsi_memos ||= {}
-      @jsi_memos[key] ||= Hash.new do |h, args|
-        h[args] = yield(*args)
+    module Memoize
+      def jsi_memoize(key, *args_)
+        @jsi_memos ||= {}
+        @jsi_memos[key] ||= Hash.new do |h, args|
+          h[args] = yield(*args)
+        end
+        @jsi_memos[key][args_]
       end
-      @jsi_memos[key][args_]
-    end
 
-    def jsi_clear_memo(key, *args)
-      @jsi_memos ||= {}
-      if @jsi_memos[key]
-        if args.empty?
-          @jsi_memos[key].clear
-        else
-          @jsi_memos[key].delete(args)
+      def jsi_clear_memo(key, *args)
+        @jsi_memos ||= {}
+        if @jsi_memos[key]
+          if args.empty?
+            @jsi_memos[key].clear
+          else
+            @jsi_memos[key].delete(args)
+          end
         end
       end
     end
   end
-  extend Memoize
+  public
+  extend Util
 end