jsi 0.2.1 → 0.3.0

data/lib/jsi/base/to_rb.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSI
   class Base
     class << self

data/lib/jsi/jsi_coder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSI
   # this is an ActiveRecord serialization coder intended to serialize between
   # JSON-compatible objects on the database side, and a JSI instance loaded on
@@ -19,24 +21,27 @@ module JSI
   #       arms_serialize 'preferences', [:jsi, Preferences], :json
   #     end
   #
-  # the column data may be either a single instance of the loaded class
+  # the column data may be either a single instance of the schema class
   # (represented as one json object) or an array of them (represented as a json
   # array of json objects), indicated by the keyword argument `array`.
   class JSICoder
-    # @param loaded_class [Class] the JSI::Base subclass which #load will instantiate
-    # @param array [Boolean] whether the dumped data represent one instance of loaded_class,
-    #   or an array of them. note that it may be preferable to have loaded_class simply be
-    #   an array schema class.
-    def initialize(loaded_class, array: false)
-      @loaded_class = loaded_class
+    # @param schema [JSI::Schema, JSI::SchemaModule, Class < JSI::Base] a schema, a JSI schema class, or
+    #   a JSI schema module. #load will instantiate column data using the JSI schema represented.
+    # @param array [Boolean] whether the dumped data represent one instance of the schema,
+    #   or an array of them. note that it may be preferable to simply use an array schema.
+    def initialize(schema, array: false)
+      unless schema.respond_to?(:new_jsi)
+        raise(ArgumentError, "not a JSI schema, class, or module: #{schema.inspect}")
+      end
+      @schema = schema
       @array = array
     end
 
-    # loads the database column to instances of #loaded_class
+    # loads the database column to JSI instances of our schema
     #
     # @param data [Object, Array, nil] the dumped schema instance(s) of the JSI(s)
-    # @return [loaded_class instance, Array<loaded_class instance>, nil] the JSI or JSIs
-    #   containing the schema instance(s), or nil if data is nil
+    # @return [JSI::Base, Array<JSI::Base>, nil] the JSI or JSIs containing the schema
+    #   instance(s), or nil if data is nil
     def load(data)
       return nil if data.nil?
       object = if @array
@@ -50,8 +55,8 @@ module JSI
       object
     end
 
-    # @param object [loaded_class instance, Array<loaded_class instance>, nil] the JSI or array
-    #   of JSIs containing the schema instance(s)
+    # @param object [JSI::Base, Array<JSI::Base>, nil] the JSI or array of JSIs containing
+    #   the schema instance(s)
     # @return [Object, Array, nil] the schema instance(s) of the JSI(s), or nil if object is nil
     def dump(object)
       return nil if object.nil?
@@ -72,12 +77,12 @@ module JSI
 
     private
     # @param data [Object]
-    # @return [loaded_class]
+    # @return [JSI::Base]
     def load_object(data)
-      @loaded_class.new(data)
+      @schema.new_jsi(data)
     end
 
-    # @param object [loaded_class]
+    # @param object [JSI::Base, Object]
     # @return [Object]
     def dump_object(object)
       JSI::Typelike.as_json(object)

data/lib/jsi/json-schema-fragments.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "json-schema"
 
 # apply the changes from https://github.com/ruby-json-schema/json-schema/pull/382 

data/lib/jsi/json.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSI
   module JSON
     autoload :Node, 'jsi/json/node'

data/lib/jsi/json/node.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSI
   module JSON
     # JSI::JSON::Node is an abstraction of a node within a JSON document.
@@ -22,55 +24,45 @@ module JSI
     # return a copy of the document with the content of the node modified.
     # the original node's document and content are untouched.
     class Node
+      include Enumerable
       include PathedNode
 
-      def self.new_doc(document)
-        new_by_type(document, JSI::JSON::Pointer.new([]))
+      def self.new_doc(node_document)
+        new_by_type(node_document, JSI::JSON::Pointer.new([]))
       end
 
       # if the content of the document at the given pointer is Hash-like, returns
       # a HashNode; if Array-like, returns ArrayNode. otherwise returns a
       # regular Node, although Nodes are for the most part instantiated from
       # Hash or Array-like content.
-      def self.new_by_type(document, pointer)
-        content = pointer.evaluate(document)
+      def self.new_by_type(node_document, node_ptr)
+        content = node_ptr.evaluate(node_document)
         if content.respond_to?(:to_hash)
-          HashNode.new(document, pointer)
+          HashNode.new(node_document, node_ptr)
         elsif content.respond_to?(:to_ary)
-          ArrayNode.new(document, pointer)
+          ArrayNode.new(node_document, node_ptr)
         else
-          Node.new(document, pointer)
+          Node.new(node_document, node_ptr)
         end
       end
 
       # a Node represents the content of a document at a given pointer.
-      def initialize(document, pointer)
-        unless pointer.is_a?(JSI::JSON::Pointer)
-          raise(TypeError, "pointer must be a JSI::JSON::Pointer. got: #{pointer.pretty_inspect.chomp} (#{pointer.class})")
+      def initialize(node_document, node_ptr)
+        unless node_ptr.is_a?(JSI::JSON::Pointer)
+          raise(TypeError, "node_ptr must be a JSI::JSON::Pointer. got: #{node_ptr.pretty_inspect.chomp} (#{node_ptr.class})")
         end
-        if document.is_a?(JSI::JSON::Node)
-          raise(TypeError, "document of a Node should not be another JSI::JSON::Node: #{document.inspect}")
+        if node_document.is_a?(JSI::JSON::Node)
+          raise(TypeError, "node_document of a Node should not be another JSI::JSON::Node: #{node_document.inspect}")
         end
-        @document = document
-        @pointer = pointer
+        @node_document = node_document
+        @node_ptr = node_ptr
       end
 
       # the document containing this Node at our pointer
-      attr_reader :document
+      attr_reader :node_document
 
       # JSI::JSON::Pointer pointing to this node within its document
-      attr_reader :pointer
-
-      # @return [Array<Object>] the path of this node; an array of reference_tokens of the pointer
-      def path
-        pointer.reference_tokens
-      end
-
-      alias_method :node_document, :document
-      alias_method :node_ptr, :pointer
-
-      # the raw content of this Node from the underlying document at this Node's pointer.
-      alias_method :content, :node_content
+      attr_reader :node_ptr
 
       # returns content at the given subscript - call this the subcontent.
       #
@@ -82,14 +74,8 @@ module JSI
       # if this node's content is a $ref - that is, a hash with a $ref attribute - and the subscript is
       # not a key of the hash, then the $ref is followed before returning the subcontent.
       def [](subscript)
-        ptr = self.pointer
-        content = self.content
-        if content.respond_to?(:to_hash) && !(content.respond_to?(:key?) ? content : content.to_hash).key?(subscript)
-          pointer.deref(document) do |deref_ptr|
-            ptr = deref_ptr
-            content = ptr.evaluate(document)
-          end
-        end
+        ptr = self.node_ptr
+        content = self.node_content
         unless content.respond_to?(:[])
           if content.respond_to?(:to_hash)
             content = content.to_hash
@@ -105,9 +91,9 @@ module JSI
           raise(e.class, e.message + "\nsubscripting with #{subscript.pretty_inspect.chomp} (#{subscript.class}) from #{content.class.inspect}. content is: #{content.pretty_inspect.chomp}", e.backtrace)
         end
         if subcontent.respond_to?(:to_hash)
-          HashNode.new(document, ptr[subscript])
+          HashNode.new(node_document, ptr[subscript])
         elsif subcontent.respond_to?(:to_ary)
-          ArrayNode.new(document, ptr[subscript])
+          ArrayNode.new(node_document, ptr[subscript])
         else
           subcontent
         end
@@ -116,9 +102,9 @@ module JSI
       # assigns the given subscript of the content to the given value. the document is modified in place.
       def []=(subscript, value)
         if value.is_a?(Node)
-          content[subscript] = value.content
+          node_content[subscript] = value.node_content
         else
-          content[subscript] = value
+          node_content[subscript] = value
         end
       end
 
@@ -132,49 +118,32 @@ module JSI
       #   (e.g. a $ref to an external document, which is not yet supported), the block is not called.
       # @return [JSI::JSON::Node] dereferenced node, or this node
       def deref(&block)
-        pointer.deref(document) do |deref_ptr|
-          return Node.new_by_type(document, deref_ptr).tap(&(block || Util::NOOP))
+        node_ptr_deref do |deref_ptr|
+          return Node.new_by_type(node_document, deref_ptr).tap(&(block || Util::NOOP))
         end
         return self
       end
 
       # a Node at the root of the document
-      def document_node
-        Node.new_doc(document)
-      end
-
-      alias_method :document_root_node, :document_node
-
-      # @return [Boolean] whether this node is the root of its document
-      def root_node?
-        pointer.root?
+      def document_root_node
+        Node.new_doc(node_document)
       end
 
       # the parent of this node. if this node is the document root, raises
       # JSI::JSON::Pointer::ReferenceError.
       def parent_node
-        Node.new_by_type(document, pointer.parent)
-      end
-
-      # the pointer path to this node within the document, per RFC 6901 https://tools.ietf.org/html/rfc6901
-      def pointer_path
-        pointer.pointer
-      end
-
-      # the pointer fragment to this node within the document, per RFC 6901 https://tools.ietf.org/html/rfc6901
-      def fragment
-        pointer.fragment
+        Node.new_by_type(node_document, node_ptr.parent)
       end
 
       # returns a jsonifiable representation of this node's content
       def as_json(*opt)
-        Typelike.as_json(content, *opt)
+        Typelike.as_json(node_content, *opt)
       end
 
       # takes a block. the block is yielded the content of this node. the block MUST return a modified
       # copy of that content (and NOT modify the object it is given).
       def modified_copy(&block)
-        Node.new_by_type(pointer.modified_document_copy(document, &block), pointer)
+        Node.new_by_type(node_ptr.modified_document_copy(node_document, &block), node_ptr)
       end
 
       def dup
@@ -185,36 +154,36 @@ module JSI
       # @return [Array<String>]
       def object_group_text
         [
+          self.class.inspect,
           "fragment=#{node_ptr.fragment.inspect}",
         ] + (node_content.respond_to?(:object_group_text) ? node_content.object_group_text : [])
       end
 
       # a string representing this node
       def inspect
-        "\#<#{self.class.inspect}#{JSI.object_group_str(object_group_text)} #{node_content.inspect}>"
+        "\#<#{object_group_text.join(' ')} #{node_content.inspect}>"
       end
 
       # pretty-prints a representation this node to the given printer
       def pretty_print(q)
-        q.instance_exec(self) do |obj|
-          text "\#<#{obj.class.inspect}#{JSI.object_group_str(obj.object_group_text)}"
-          group_sub {
-            nest(2) {
-              breakable ' '
-              pp obj.content
-            }
+        q.text '#<'
+        q.text object_group_text.join(' ')
+        q.group_sub {
+          q.nest(2) {
+            q.breakable ' '
+            q.pp node_content
           }
-          breakable ''
-          text '>'
-        end
+        }
+        q.breakable ''
+        q.text '>'
       end
 
       # fingerprint for equality (see FingerprintHash). two nodes are equal if they are both nodes
       # (regardless of type, e.g. one may be a Node and the other may be a HashNode) within equal
       # documents at equal pointers. note that this means two nodes with the same content may not be
       # considered equal.
-      def fingerprint
-        {class: JSI::JSON::Node, document: document, pointer: pointer}
+      def jsi_fingerprint
+        {class: JSI::JSON::Node, node_document: node_document, node_ptr: node_ptr}
       end
       include FingerprintHash
     end
@@ -222,25 +191,13 @@ module JSI
     # a JSI::JSON::Node whose content is Array-like (responds to #to_ary)
     # and includes Array methods from Arraylike
     class ArrayNode < Node
-      include Enumerable
       include PathedArrayNode
-
-      # returns a jsonifiable representation of this node's content
-      def as_json(*opt) # needs redefined after including Enumerable
-        Typelike.as_json(content, *opt)
-      end
     end
 
     # a JSI::JSON::Node whose content is Hash-like (responds to #to_hash)
     # and includes Hash methods from Hashlike
     class HashNode < Node
-      include Enumerable
       include PathedHashNode
-
-      # returns a jsonifiable representation of this node's content
-      def as_json(*opt) # needs redefined after including Enumerable
-        Typelike.as_json(content, *opt)
-      end
     end
   end
 end

data/lib/jsi/json/pointer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'addressable/uri'
 
 module JSI
@@ -195,6 +197,104 @@ module JSI
         Pointer.new(reference_tokens + [token], type: @type)
       end
 
+      # given this Pointer points to a schema in the given document, returns a pointer
+      # to a subschema of that schema for the given property name.
+      #
+      # @param document [#to_hash, #to_ary, Object] document containing the schema this pointer points to
+      # @param property_name [Object] the property name for which to find a subschema
+      # @return [JSI::JSON::Pointer, nil] a pointer to a subschema in the document for the property_name, or nil
+      def schema_subschema_ptr_for_property_name(document, property_name)
+        ptr = self
+        schema = ptr.evaluate(document)
+        if !schema.respond_to?(:to_hash)
+          nil
+        else
+          if schema.key?('properties') && schema['properties'].respond_to?(:to_hash) && schema['properties'].key?(property_name)
+            ptr['properties'][property_name]
+          else
+            # TODO this is rather incorrect handling of patternProperties and additionalProperties
+            if schema['patternProperties'].respond_to?(:to_hash)
+              pattern_schema_name = schema['patternProperties'].keys.detect do |pattern|
+                property_name.to_s =~ Regexp.new(pattern) # TODO map pattern to ruby syntax
+              end
+            end
+            if pattern_schema_name
+              ptr['patternProperties'][pattern_schema_name]
+            else
+              if schema.key?('additionalProperties')
+                ptr['additionalProperties']
+              else
+                nil
+              end
+            end
+          end
+        end
+      end
+
+      # given this Pointer points to a schema in the given document, returns a pointer
+      # to a subschema of that schema for the given array index.
+      #
+      # @param document [#to_hash, #to_ary, Object] document containing the schema this pointer points to
+      # @param idx [Object] the array index for which to find a subschema
+      # @return [JSI::JSON::Pointer, nil] a pointer to a subschema in the document for array index idx, or nil
+      def schema_subschema_ptr_for_index(document, idx)
+        ptr = self
+        schema = ptr.evaluate(document)
+        if !schema.respond_to?(:to_hash)
+          nil
+        else
+          if schema.key?('items') || schema.key?('additionalItems')
+            if schema['items'].respond_to?(:to_ary)
+              if schema['items'].each_index.to_a.include?(idx)
+                ptr['items'][idx]
+              elsif schema.key?('additionalItems')
+                ptr['additionalItems']
+              else
+                nil
+              end
+            elsif schema.key?('items')
+              ptr['items']
+            else
+              nil
+            end
+          else
+            nil
+          end
+        end
+      end
+
+      # given this Pointer points to a schema in the given document, this matches
+      # any oneOf or anyOf subschema of the schema which the given instance validates
+      # against. if a subschema is matched, a pointer to that schema is returned; if not,
+      # self is returned.
+      #
+      # @param document [#to_hash, #to_ary, Object] document containing the schema
+      #   this pointer points to
+      # @param instance [Object] the instance to which to attempt to match *Of subschemas
+      # @return [JSI::JSON::Pointer] either a pointer to a *Of subschema in the document,
+      #   or self if no other subschema was matched
+      def schema_match_ptr_to_instance(document, instance)
+        ptr = self
+        schema = ptr.evaluate(document)
+        if schema.respond_to?(:to_hash)
+          # matching oneOf is good here. one schema for one instance.
+          # matching anyOf is fine. there could be more than one schema matched but it's usually just
+          #   one. if more than one is a match, you just get the first one.
+          someof_token = %w(oneOf anyOf).detect { |k| schema[k].respond_to?(:to_ary) }
+          if someof_token
+            someof_ptr = ptr[someof_token].deref(document)
+            someof_ptr.evaluate(document).each_index do |i|
+              someof_schema_ptr = someof_ptr[i].deref(document)
+              valid = ::JSON::Validator.validate(JSI::Typelike.as_json(document), JSI::Typelike.as_json(instance), fragment: someof_schema_ptr.fragment)
+              if valid
+                return someof_schema_ptr.schema_match_ptr_to_instance(document, instance)
+              end
+            end
+          end
+        end
+        return ptr
+      end
+
       # takes a document and a block. the block is yielded the content of the given document at this
       # pointer's location. the block must result a modified copy of that content (and MUST NOT modify
       # the object it is given). this modified copy of that content is incorporated into a modified copy
@@ -302,13 +402,10 @@ module JSI
         "#<#{self.class.inspect} #{representation_s}>"
       end
 
-      # @return [String] string representation of this Pointer
-      def to_s
-        inspect
-      end
+      alias_method :to_s, :inspect
 
       # pointers are equal if the reference_tokens are equal, regardless of @type
-      def fingerprint
+      def jsi_fingerprint
         {class: JSI::JSON::Pointer, reference_tokens: reference_tokens}
       end
       include FingerprintHash