jsi 0.1.0 → 0.2.0

data/lib/jsi/pathed_node.rb

@@ -0,0 +1,113 @@
+module JSI
+  # including class MUST define
+  # - #node_document [Object] returning the document
+  # - #node_ptr [JSI::JSON::Pointer] returning a pointer for the node path in the document
+  # - #document_root_node [JSI::PathedNode] returning a PathedNode pointing at the document root
+  # - #parent_node [JSI::PathedNode] returning the parent node of this PathedNode
+  # - #deref [JSI::PathedNode] following a $ref
+  #
+  # given these, this module represents the node in the document at the path.
+  #
+  # the node content (#node_content) is the result of evaluating the node document at the path.
+  module PathedNode
+    def node_content
+      content = node_ptr.evaluate(node_document)
+      content
+    end
+
+    def node_ptr_deref(&block)
+      node_ptr.deref(node_document, &block)
+    end
+  end
+
+  # module extending a {JSI::PathedNode} object when its node_content is Hash-like (responds to #to_hash)
+  module PathedHashNode
+    # yields each hash key and value of this node.
+    #
+    # each yielded key is the same as a key of the node content hash,
+    # and each yielded value is the result of self[key] (see #[]).
+    #
+    # returns an Enumerator if no block is given.
+    #
+    # @yield [Object, Object] each key and value of this hash node
+    # @return [self, Enumerator]
+    def each(&block)
+      return to_enum(__method__) { node_content_hash_pubsend(:size) } unless block_given?
+      if block.arity > 1
+        node_content_hash_pubsend(:each_key) { |k| yield k, self[k] }
+      else
+        node_content_hash_pubsend(:each_key) { |k| yield [k, self[k]] }
+      end
+      self
+    end
+
+    # @return [Hash] a hash in which each key is a key of the node_content hash and
+    #   each value is the result of self[key] (see #[]).
+    def to_hash
+      {}.tap { |h| each_key { |k| h[k] = self[k] } }
+    end
+
+    include Hashlike
+
+    # @param method_name [String, Symbol]
+    # @param *a, &b are passed to the invocation of method_name
+    # @return [Object] the result of calling method method_name on the node_content or its #to_hash
+    def node_content_hash_pubsend(method_name, *a, &b)
+      if node_content.respond_to?(method_name)
+        node_content.public_send(method_name, *a, &b)
+      else
+        node_content.to_hash.public_send(method_name, *a, &b)
+      end
+    end
+
+    # methods that don't look at the value; can skip the overhead of #[] (invoked by #to_hash)
+    SAFE_KEY_ONLY_METHODS.each do |method_name|
+      define_method(method_name) do |*a, &b|
+        node_content_hash_pubsend(method_name, *a, &b)
+      end
+    end
+  end
+
+  module PathedArrayNode
+    # yields each array element of this node.
+    #
+    # each yielded element is the result of self[index] for each index of our array (see #[]).
+    #
+    # returns an Enumerator if no block is given.
+    #
+    # @yield [Object] each element of this array node
+    # @return [self, Enumerator]
+    def each
+      return to_enum(__method__) { node_content_ary_pubsend(:size) } unless block_given?
+      node_content_ary_pubsend(:each_index) { |i| yield(self[i]) }
+      self
+    end
+
+    # @return [Array] an array, the same size as the node_content, in which the
+    #   element at each index is the result of self[index] (see #[])
+    def to_ary
+      to_a
+    end
+
+    include Arraylike
+
+    # @param method_name [String, Symbol]
+    # @param *a, &b are passed to the invocation of method_name
+    # @return [Object] the result of calling method method_name on the node_content or its #to_ary
+    def node_content_ary_pubsend(method_name, *a, &b)
+      if node_content.respond_to?(method_name)
+        node_content.public_send(method_name, *a, &b)
+      else
+        node_content.to_ary.public_send(method_name, *a, &b)
+      end
+    end
+
+    # methods that don't look at the value; can skip the overhead of #[] (invoked by #to_a).
+    # we override these methods from Arraylike
+    SAFE_INDEX_ONLY_METHODS.each do |method_name|
+      define_method(method_name) do |*a, &b|
+        node_content_ary_pubsend(method_name, *a, &b)
+      end
+    end
+  end
+end

data/lib/jsi/schema.rb

@@ -8,6 +8,9 @@ module JSI
     include Memoize
 
     class << self
+      # @param schema_object [#to_hash, Boolean, JSI::Schema] an object to be instantiated as a schema.
+      #   if it's already a schema, it is returned as-is.
+      # @return [JSI::Schema]
       def from_object(schema_object)
         if schema_object.is_a?(Schema)
           schema_object
@@ -17,36 +20,30 @@ module JSI
       end
     end
 
-    # initializes a schema from a given JSI::Base, JSI::JSON::Node, or hash.
-    # @param schema_object [JSI::Base, #to_hash] the schema
+    # initializes a schema from a given JSI::Base, JSI::JSON::Node, or hash. Boolean schemas are
+    # instantiated as their equivalent hash ({} for true and {"not" => {}} for false).
+    #
+    # @param schema_object [JSI::Base, #to_hash, Boolean] the schema
     def initialize(schema_object)
       if schema_object.is_a?(JSI::Schema)
         raise(TypeError, "will not instantiate Schema from another Schema: #{schema_object.pretty_inspect.chomp}")
-      elsif schema_object.is_a?(JSI::Base)
-        @schema_jsi = JSI.deep_stringify_symbol_keys(schema_object.deref)
-        @schema_node = @schema_jsi.instance
-      elsif schema_object.is_a?(JSI::JSON::HashNode)
-        @schema_jsi = nil
+      elsif schema_object.is_a?(JSI::PathedNode)
         @schema_node = JSI.deep_stringify_symbol_keys(schema_object.deref)
       elsif schema_object.respond_to?(:to_hash)
-        @schema_jsi = nil
         @schema_node = JSI::JSON::Node.new_doc(JSI.deep_stringify_symbol_keys(schema_object))
+      elsif schema_object == true
+        @schema_node = JSI::JSON::Node.new_doc({})
+      elsif schema_object == false
+        @schema_node = JSI::JSON::Node.new_doc({"not" => {}})
       else
         raise(TypeError, "cannot instantiate Schema from: #{schema_object.pretty_inspect.chomp}")
       end
     end
 
-    # @return [JSI::JSON::Node] a JSI::JSON::Node for the schema
+    # @return [JSI::PathedNode] a JSI::PathedNode (JSI::JSON::Node or JSI::Base) for the schema
     attr_reader :schema_node
 
-    # @return [JSI::Base, nil] a JSI for this schema, if a metaschema is known; otherwise nil
-    attr_reader :schema_jsi
-
-    # @return [JSI::Base, JSI::JSON::Node] either a JSI::Base subclass or a
-    #   JSI::JSON::Node for the schema
-    def schema_object
-      @schema_jsi || @schema_node
-    end
+    alias_method :schema_object, :schema_node
 
     # @return [JSI::Base, JSI::JSON::Node, Object] property value from the schema_object
     # @param property_name [String, Object] property name to access from the schema_object
@@ -69,7 +66,7 @@ module JSI
           # look at 'id' if node_for_id is a schema, or the document root.
           # decide whether to look at '$id' for all parent nodes or also just schemas.
           if node_for_id.respond_to?(:to_hash)
-            if node_for_id.path.empty? || node_for_id.object_id == schema_node.object_id
+            if node_for_id.node_ptr.root? || node_for_id.object_id == schema_node.object_id
               # I'm only looking at 'id' for the document root and the schema node
               # until I track what parents are schemas.
               parent_id = node_for_id['$id'] || node_for_id['id']
@@ -80,30 +77,30 @@ module JSI
             end
           end
 
-          if parent_id || node_for_id.path.empty?
+          if parent_id || node_for_id.node_ptr.root?
             done = true
           else
-            path_from_id_node.unshift(node_for_id.path.last)
+            path_from_id_node.unshift(node_for_id.node_ptr.reference_tokens.last)
             node_for_id = node_for_id.parent_node
           end
         end
         if parent_id
           parent_auri = Addressable::URI.parse(parent_id)
         else
-          node_for_id = schema_node.document_node
-          validator = ::JSON::Validator.new(node_for_id.content, nil)
+          node_for_id = schema_node.document_root_node
+          validator = ::JSON::Validator.new(Typelike.as_json(node_for_id), nil)
           # TODO not good instance_exec'ing into another library's ivars
           parent_auri = validator.instance_exec { @base_schema }.uri
         end
         if parent_auri.fragment
           # add onto the fragment
-          parent_id_path = JSI::JSON::Pointer.new(: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(:reference_tokens, path_from_id_node).fragment
+        fragment = JSI::JSON::Pointer.new(path_from_id_node).fragment
         schema_id = parent_auri.to_s + fragment
 
         schema_id
@@ -111,26 +108,35 @@ module JSI
     end
 
     # @return [Class subclassing JSI::Base] shortcut for JSI.class_for_schema(schema)
-    def schema_class
+    def jsi_schema_class
       JSI.class_for_schema(self)
     end
 
+    alias_method :schema_class, :jsi_schema_class
+
+    # calls #new on the class for this schema with the given arguments. for parameters,
+    # see JSI::Base#initialize documentation.
+    #
+    # @return [JSI::Base] a JSI whose schema is this schema and whose instance is the given instance
+    def new_jsi(other_instance, *a, &b)
+      jsi_schema_class.new(other_instance, *a, &b)
+    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.
     #
-    # @param instance [Object] the instance to which to attempt to match *Of subschemas
+    # @param other_instance [Object] the instance to which to attempt to match *Of subschemas
     # @return [JSI::Schema] a matched subschema, or this schema (self)
-    def match_to_instance(instance)
+    def match_to_instance(other_instance)
       # matching oneOf is good here. one schema for one instance.
       # matching anyOf is okay. there could be more than one schema matched. it's often just one. if more
       #   than one is a match, you just get the first one.
-      instance = instance.deref if instance.is_a?(JSI::JSON::Node)
       %w(oneOf anyOf).select { |k| schema_node[k].respond_to?(:to_ary) }.each do |someof_key|
         schema_node[someof_key].map(&:deref).map do |someof_node|
           someof_schema = self.class.new(someof_node)
-          if someof_schema.validate(instance)
-            return someof_schema.match_to_instance(instance)
+          if someof_schema.validate_instance(other_instance)
+            return someof_schema.match_to_instance(other_instance)
           end
         end
       end
@@ -227,33 +233,33 @@ module JSI
 
     # @return [Array<String>] array of schema validation error messages for
     #   the given instance against this schema
-    def fully_validate(instance)
-      ::JSON::Validator.fully_validate(JSI::Typelike.as_json(schema_node.document), JSI::Typelike.as_json(instance), fragment: schema_node.fragment)
+    def fully_validate_instance(other_instance)
+      ::JSON::Validator.fully_validate(JSI::Typelike.as_json(schema_node.node_document), JSI::Typelike.as_json(other_instance), fragment: schema_node.node_ptr.fragment)
     end
 
     # @return [true, false] whether the given instance validates against this schema
-    def validate(instance)
-      ::JSON::Validator.validate(JSI::Typelike.as_json(schema_node.document), JSI::Typelike.as_json(instance), fragment: schema_node.fragment)
+    def validate_instance(other_instance)
+      ::JSON::Validator.validate(JSI::Typelike.as_json(schema_node.node_document), JSI::Typelike.as_json(other_instance), fragment: schema_node.node_ptr.fragment)
     end
 
     # @return [true] if this method does not raise, it returns true to
     #   indicate the instance is valid against this schema
     # @raise [::JSON::Schema::ValidationError] raises if the instance has
     #   validation errors against this schema
-    def validate!(instance)
-      ::JSON::Validator.validate!(JSI::Typelike.as_json(schema_node.document), JSI::Typelike.as_json(instance), fragment: schema_node.fragment)
+    def validate_instance!(other_instance)
+      ::JSON::Validator.validate!(JSI::Typelike.as_json(schema_node.node_document), JSI::Typelike.as_json(other_instance), fragment: schema_node.node_ptr.fragment)
     end
 
     # @return [Array<String>] array of schema validation error messages for
     #   this schema, validated against its metaschema. a default metaschema
     #   is assumed if the schema does not specify a $schema.
     def fully_validate_schema
-      ::JSON::Validator.fully_validate(JSI::Typelike.as_json(schema_node.document), [], fragment: schema_node.fragment, validate_schema: true, list: true)
+      ::JSON::Validator.fully_validate(JSI::Typelike.as_json(schema_node.node_document), [], fragment: schema_node.node_ptr.fragment, validate_schema: true, list: true)
     end
 
     # @return [true, false] whether this schema validates against its metaschema
     def validate_schema
-      ::JSON::Validator.validate(JSI::Typelike.as_json(schema_node.document), [], fragment: schema_node.fragment, validate_schema: true, list: true)
+      ::JSON::Validator.validate(JSI::Typelike.as_json(schema_node.node_document), [], fragment: schema_node.node_ptr.fragment, validate_schema: true, list: true)
     end
 
     # @return [true] if this method does not raise, it returns true to
@@ -261,7 +267,7 @@ module JSI
     # @raise [::JSON::Schema::ValidationError] raises if this schema has
     #   validation errors against its metaschema
     def validate_schema!
-      ::JSON::Validator.validate!(JSI::Typelike.as_json(schema_node.document), [], fragment: schema_node.fragment, validate_schema: true, list: true)
+      ::JSON::Validator.validate!(JSI::Typelike.as_json(schema_node.node_document), [], fragment: schema_node.node_ptr.fragment, validate_schema: true, list: true)
     end
 
     # @return [String] a string for #instance and #pretty_print including the schema_id
@@ -298,7 +304,7 @@ module JSI
 
     # @return [Object] an opaque fingerprint of this Schema for FingerprintHash
     def fingerprint
-      {class: self.class, schema_node: schema_node}
+      {class: self.class, schema_ptr: schema_node.node_ptr, schema_document: JSI::Typelike.as_json(schema_node.node_document)}
     end
     include FingerprintHash
   end

data/lib/jsi/schema_classes.rb

@@ -0,0 +1,86 @@
+module JSI
+  # this module is just a namespace for schema classes.
+  module SchemaClasses
+    # JSI::SchemaClasses[schema_id] returns a class for the schema with the
+    # given id, the same class as returned from JSI.class_for_schema.
+    #
+    # @param schema_id [String] absolute schema id as returned by {JSI::Schema#schema_id}
+    # @return [Class subclassing JSI::Base] the class for that schema
+    def self.[](schema_id)
+      @classes_by_id[schema_id]
+    end
+    @classes_by_id = {}
+
+    class << self
+      include Memoize
+
+      # see {JSI.class_for_schema}
+      def class_for_schema(schema_object)
+        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(JSI::SchemaClasses.module_for_schema(schema, conflicting_modules: [Base, BaseArray, BaseHash]))
+
+            jsi_class = self
+            define_method(:jsi_class) { jsi_class }
+
+            SchemaClasses.instance_exec(self) { |klass| @classes_by_id[klass.schema_id] = klass }
+
+            self
+          end
+        end
+      end
+
+      # a module for the given schema, with accessor methods for any object
+      # property names the schema identifies. also has a singleton method
+      # called #schema to access the {JSI::Schema} this module represents.
+      #
+      # accessor methods are defined on these modules so that methods can be
+      # defined on {JSI.class_for_schema} classes without method redefinition
+      # warnings. additionally, these overriding instance methods can call
+      # `super` to invoke the normal accessor behavior.
+      #
+      # no property names that are the same as existing method names on the JSI
+      # class will be defined. users should use #[] and #[]= to access properties
+      # whose names conflict with existing methods.
+      def SchemaClasses.module_for_schema(schema_object, conflicting_modules: [])
+        schema__ = JSI::Schema.from_object(schema_object)
+        memoize(:module_for_schema, schema__, conflicting_modules) do |schema_, conflicting_modules_|
+          Module.new.tap do |m|
+            m.instance_exec(schema_) do |schema|
+              define_singleton_method(:schema) { schema }
+              define_singleton_method(:schema_id) do
+                schema.schema_id
+              end
+              define_singleton_method(:inspect) do
+                %Q(#<Module for Schema: #{schema_id}>)
+              end
+
+              conflicting_instance_methods = (conflicting_modules_ + [m]).map do |mod|
+                mod.instance_methods + mod.private_instance_methods
+              end.inject(Set.new, &:|)
+              accessors_to_define = schema.described_object_property_names.map(&:to_s) - conflicting_instance_methods.map(&:to_s)
+              accessors_to_define.each do |property_name|
+                define_method(property_name) do
+                  if respond_to?(:[])
+                    self[property_name]
+                  else
+                    raise(NoMethodError, "schema instance of class #{self.class} does not respond to []; cannot call reader '#{property_name}'. instance is #{instance.pretty_inspect.chomp}")
+                  end
+                end
+                define_method("#{property_name}=") do |value|
+                  if respond_to?(:[]=)
+                    self[property_name] = value
+                  else
+                    raise(NoMethodError, "schema instance of class #{self.class} does not respond to []=; cannot call writer '#{property_name}='. instance is #{instance.pretty_inspect.chomp}")
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsi/simple_wrap.rb

@@ -0,0 +1,7 @@
+module JSI
+  SimpleWrap = JSI.class_for_schema({"additionalProperties": {"$ref": "#"}, "items": {"$ref": "#"}})
+
+  # SimpleWrap is a JSI class which recursively wraps nested structures
+  class SimpleWrap
+  end
+end

data/lib/jsi/typelike_modules.rb

@@ -36,12 +36,8 @@ module JSI
     # @raise [TypeError] when the object (or an object nested with a hash or
     #   array of object) cannot be expressed as json
     def self.as_json(object, *opt)
-      if object.is_a?(JSI::Schema)
-        as_json(object.schema_object, *opt)
-      elsif object.is_a?(JSI::Base)
-        as_json(object.instance, *opt)
-      elsif object.is_a?(JSI::JSON::Node)
-        as_json(object.content, *opt)
+      if object.is_a?(JSI::PathedNode)
+        as_json(object.node_content, *opt)
       elsif object.respond_to?(:to_hash)
         (object.respond_to?(:map) ? object : object.to_hash).map do |k, v|
           unless k.is_a?(Symbol) || k.respond_to?(:to_str)
@@ -78,7 +74,7 @@ module JSI
     SAFE_KEY_VALUE_METHODS = %w(< <= > >= any? assoc compact dig each_pair each_value fetch fetch_values has_value? invert key merge rassoc reject select to_h to_proc transform_values value? values values_at)
     DESTRUCTIVE_METHODS = %w(clear delete delete_if keep_if reject! replace select! shift)
     # these return a modified copy
-    safe_modified_copy_methods = %w(compact merge)
+    safe_modified_copy_methods = %w(compact)
     # select and reject will return a modified copy but need the yielded block variable value from #[]
     safe_kv_block_modified_copy_methods = %w(select reject)
     SAFE_METHODS = SAFE_KEY_ONLY_METHODS | SAFE_KEY_VALUE_METHODS
@@ -88,7 +84,7 @@ module JSI
     end
     safe_modified_copy_methods.each do |method_name|
       define_method(method_name) do |*a, &b|
-        JSI::Typelike.modified_copy(self) do |object_to_modify|
+        modified_copy do |object_to_modify|
           responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_hash
           responsive_object.public_send(method_name, *a, &b)
         end
@@ -96,7 +92,7 @@ module JSI
     end
     safe_kv_block_modified_copy_methods.each do |method_name|
       define_method(method_name) do |*a, &b|
-        JSI::Typelike.modified_copy(self) do |object_to_modify|
+        modified_copy do |object_to_modify|
           responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_hash
           responsive_object.public_send(method_name, *a) do |k, _v|
             b.call(k, self[k])
@@ -105,6 +101,38 @@ module JSI
       end
     end
 
+    # the same as Hash#update
+    # @param other [#to_hash] the other hash to update this hash from
+    # @yield [key, oldval, newval] for entries with duplicate keys, the value of each duplicate key
+    #   is determined by calling the block with the key, its value in hsh and its value in other_hash.
+    # @return self, updated with other
+    # @raise [TypeError] when `other` does not respond to #to_hash
+    def update(other, &block)
+      unless other.respond_to?(:to_hash)
+        raise(TypeError, "cannot update with argument that does not respond to #to_hash: #{other.pretty_inspect.chomp}")
+      end
+      self_respondingto_key = self.respond_to?(:key?) ? self : to_hash
+      other.to_hash.each_pair do |key, value|
+        if block_given? && self_respondingto_key.key?(key)
+          value = yield(key, self[key], value)
+        end
+        self[key] = value
+      end
+      self
+    end
+
+    alias_method :merge!, :update
+
+    # the same as Hash#merge
+    # @param other [#to_hash] the other hash to merge into this
+    # @yield [key, oldval, newval] for entries with duplicate keys, the value of each duplicate key
+    #   is determined by calling the block with the key, its value in hsh and its value in other_hash.
+    # @return duplicate of this hash with the other hash merged in
+    # @raise [TypeError] when `other` does not respond to #to_hash
+    def merge(other, &block)
+      dup.update(other, &block)
+    end
+
     # @return [String] basically the same #inspect as Hash, but has the
     #   class name and, if responsive, self's #object_group_text
     def inspect
@@ -168,7 +196,7 @@ module JSI
     end
     safe_modified_copy_methods.each do |method_name|
       define_method(method_name) do |*a, &b|
-        JSI::Typelike.modified_copy(self) do |object_to_modify|
+        modified_copy do |object_to_modify|
           responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_ary
           responsive_object.public_send(method_name, *a, &b)
         end
@@ -176,7 +204,7 @@ module JSI
     end
     safe_el_block_methods.each do |method_name|
       define_method(method_name) do |*a, &b|
-        JSI::Typelike.modified_copy(self) do |object_to_modify|
+        modified_copy do |object_to_modify|
           i = 0
           responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_ary
           responsive_object.public_send(method_name, *a) do |_e|