jsi 0.2.0 → 0.6.0

data/lib/jsi/ptr.rb

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+module JSI
+    # a representation to work with JSON Pointer, as described by RFC 6901 https://tools.ietf.org/html/rfc6901
+    #
+    # a pointer is a sequence of tokens pointing to a node in a document.
+    class Ptr
+      class Error < StandardError
+      end
+
+      # raised when attempting to parse a JSON Pointer string with invalid syntax
+      class PointerSyntaxError < Error
+      end
+
+      # raised when a pointer refers to a path in a document that could not be resolved
+      class ResolutionError < Error
+      end
+
+      # instantiates a pointer or returns the given pointer
+      # @param ary_ptr [#to_ary, JSI::Ptr] an array of tokens, or a pointer
+      # @return [JSI::Ptr]
+      def self.ary_ptr(ary_ptr)
+        if ary_ptr.is_a?(Ptr)
+          ary_ptr
+        else
+          new(ary_ptr)
+        end
+      end
+
+      # instantiates a pointer from the given tokens.
+      #
+      #     JSI::Ptr[]
+      #
+      # instantes a root pointer.
+      #
+      #     JSI::Ptr['a', 'b']
+      #     JSI::Ptr['a']['b']
+      #
+      # are both ways to instantiate a pointer with tokens ['a', 'b']. the latter example chains the
+      # class .[] method with the instance #[] method.
+      #
+      # @param tokens any number of tokens
+      # @return [JSI::Ptr]
+      def self.[](*tokens)
+        new(tokens)
+      end
+
+      # parse a URI-escaped fragment and instantiate as a JSI::Ptr
+      #
+      #     JSI::Ptr.from_fragment('/foo/bar')
+      #     => JSI::Ptr["foo", "bar"]
+      #
+      # with URI escaping:
+      #
+      #     JSI::Ptr.from_fragment('/foo%20bar')
+      #     => JSI::Ptr["foo bar"]
+      #
+      # @param fragment [String] a fragment containing a pointer
+      # @return [JSI::Ptr]
+      # @raise [JSI::Ptr::PointerSyntaxError] when the fragment does not contain a pointer with
+      #   valid pointer syntax
+      def self.from_fragment(fragment)
+        from_pointer(Addressable::URI.unescape(fragment))
+      end
+
+      # parse a pointer string and instantiate as a JSI::Ptr
+      #
+      #     JSI::Ptr.from_pointer('/foo')
+      #     => JSI::Ptr["foo"]
+      #
+      #     JSI::Ptr.from_pointer('/foo~0bar/baz~1qux')
+      #     => JSI::Ptr["foo~bar", "baz/qux"]
+      #
+      # @param pointer_string [String] a pointer string
+      # @return [JSI::Ptr]
+      # @raise [JSI::Ptr::PointerSyntaxError] when the pointer_string does not have valid pointer syntax
+      def self.from_pointer(pointer_string)
+        tokens = pointer_string.split('/', -1).map! do |piece|
+          piece.gsub('~1', '/').gsub('~0', '~')
+        end
+        if tokens[0] == ''
+          new(tokens[1..-1])
+        elsif tokens.empty?
+          new(tokens)
+        else
+          raise(PointerSyntaxError, "Invalid pointer syntax in #{pointer_string.inspect}: pointer must begin with /")
+        end
+      end
+
+      # initializes a JSI::Ptr from the given tokens.
+      #
+      # @param tokens [Array<Object>]
+      def initialize(tokens)
+        unless tokens.respond_to?(:to_ary)
+          raise(TypeError, "tokens must be an array. got: #{tokens.inspect}")
+        end
+        @tokens = tokens.to_ary.map(&:freeze).freeze
+      end
+
+      attr_reader :tokens
+
+      # @private @deprecated
+      alias_method :reference_tokens, :tokens
+
+      # takes a root json document and evaluates this pointer through the document, returning the value
+      # pointed to by this pointer.
+      #
+      # @param document [#to_ary, #to_hash] the document against which we will evaluate this pointer
+      # @param a arguments are passed to each invocation of `#[]`
+      # @return [Object] the content of the document pointed to by this pointer
+      # @raise [JSI::Ptr::ResolutionError] the document does not contain the path this pointer references
+      def evaluate(document, *a)
+        res = tokens.inject(document) do |value, token|
+          _, child = node_subscript_token_child(value, token, *a)
+          child
+        end
+        res
+      end
+
+      # the pointer string representation of this pointer
+      # @return [String]
+      def pointer
+        tokens.map { |t| '/' + t.to_s.gsub('~', '~0').gsub('/', '~1') }.join('')
+      end
+
+      # the fragment string representation of this pointer
+      # @return [String]
+      def fragment
+        Addressable::URI.escape(pointer)
+      end
+
+      # a URI consisting of a fragment containing this pointer's fragment string representation
+      # @return [Addressable::URI]
+      def uri
+        Addressable::URI.new(fragment: fragment)
+      end
+
+      # whether this pointer is empty, i.e. it has no tokens
+      # @return [Boolean]
+      def empty?
+        tokens.empty?
+      end
+
+      # whether this is a root pointer, indicated by an empty array of tokens
+      # @return [Boolean]
+      alias_method :root?, :empty?
+
+      # pointer to the parent of where this pointer points
+      # @return [JSI::Ptr]
+      # @raise [JSI::Ptr::Error] if this pointer has no parent (points to the root)
+      def parent
+        if root?
+          raise(Ptr::Error, "cannot access parent of root pointer: #{pretty_inspect.chomp}")
+        else
+          Ptr.new(tokens[0...-1])
+        end
+      end
+
+      # whether this pointer contains the other_ptr - that is, whether this pointer is an ancestor
+      # of `other_ptr`, a child pointer. `contains?` is inclusive; a pointer does contain itself.
+      # @return [Boolean]
+      def contains?(other_ptr)
+        self.tokens == other_ptr.tokens[0...self.tokens.size]
+      end
+
+      # part of this pointer relative to the given ancestor_ptr
+      # @return [JSI::Ptr]
+      # @raise [JSI::Ptr::Error] if the given ancestor_ptr is not an ancestor of this pointer
+      def ptr_relative_to(ancestor_ptr)
+        unless ancestor_ptr.contains?(self)
+          raise(Error, "ancestor_ptr #{ancestor_ptr.inspect} is not ancestor of #{inspect}")
+        end
+        Ptr.new(tokens[ancestor_ptr.tokens.size..-1])
+      end
+
+      # a pointer with the tokens of this one plus the given `ptr`'s.
+      # @param ptr [JSI::Ptr, #to_ary]
+      # @return [JSI::Ptr]
+      def +(ptr)
+        if ptr.is_a?(Ptr)
+          ptr_tokens = ptr.tokens
+        elsif ptr.respond_to?(:to_ary)
+          ptr_tokens = ptr
+        else
+          raise(TypeError, "ptr must be a JSI::Ptr or Array of tokens; got: #{ptr.inspect}")
+        end
+        Ptr.new(self.tokens + ptr_tokens)
+      end
+
+      # a pointer consisting of the first `n` of our tokens
+      # @param n [Integer]
+      # @return [JSI::Ptr]
+      # @raise [ArgumentError] if n is not between 0 and the size of our tokens
+      def take(n)
+        unless (0..tokens.size).include?(n)
+          raise(ArgumentError, "n not in range (0..#{tokens.size}): #{n.inspect}")
+        end
+        Ptr.new(tokens.take(n))
+      end
+
+      # appends the given token to this pointer's tokens and returns the result
+      #
+      # @param token [Object]
+      # @return [JSI::Ptr] pointer to a child node of this pointer with the given token
+      def [](token)
+        Ptr.new(tokens + [token])
+      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
+      # of the given document, which is then returned. the structure and contents of the document outside
+      # the path pointed to by this pointer is not modified.
+      #
+      # @param document [Object] the document to apply this pointer to
+      # @yield [Object] the content this pointer applies to in the given document
+      #   the block must result in the new content which will be placed in the modified document copy.
+      # @return [Object] a copy of the given document, with the content this pointer applies to
+      #   replaced by the result of the block
+      def modified_document_copy(document, &block)
+        # we need to preserve the rest of the document, but modify the content at our path.
+        #
+        # this is actually a bit tricky. we can't modify the original document, obviously.
+        # we could do a deep copy, but that's expensive. instead, we make a copy of each array
+        # or hash in the path above the node we point to. this node's content is modified by the
+        # caller, and that is recursively merged up to the document root.
+        if empty?
+          Typelike.modified_copy(document, &block)
+        else
+          car = tokens[0]
+          cdr = Ptr.new(tokens[1..-1])
+          token, document_child = node_subscript_token_child(document, car)
+          modified_document_child = cdr.modified_document_copy(document_child, &block)
+          if modified_document_child.object_id == document_child.object_id
+            document
+          else
+            modified_document = document.respond_to?(:[]=) ? document.dup :
+              document.respond_to?(:to_hash) ? document.to_hash.dup :
+              document.respond_to?(:to_ary) ? document.to_ary.dup :
+              raise(Bug) # not possible; node_subscript_token_child would have raised
+            modified_document[token] = modified_document_child
+            modified_document
+          end
+        end
+      end
+
+      # a string representation of this pointer
+      # @return [String]
+      def inspect
+        "#{self.class.name}[#{tokens.map(&:inspect).join(", ")}]"
+      end
+
+      alias_method :to_s, :inspect
+
+      # pointers are equal if the tokens are equal
+      def jsi_fingerprint
+        {class: Ptr, tokens: tokens}
+      end
+      include Util::FingerprintHash
+
+      private
+
+      def node_subscript_token_child(value, token, *a)
+        if value.respond_to?(:to_ary)
+          if token.is_a?(String) && token =~ /\A\d|[1-9]\d+\z/
+            token = token.to_i
+          elsif token == '-'
+            # per rfc6901, - refers "to the (nonexistent) member after the last array element" and is
+            # expected to raise an error condition.
+            raise(ResolutionError, "Invalid resolution: #{token.inspect} refers to a nonexistent element in array #{value.inspect}")
+          end
+          unless token.is_a?(Integer)
+            raise(ResolutionError, "Invalid resolution: #{token.inspect} is not an integer and cannot be resolved in array #{value.inspect}")
+          end
+          unless (0...(value.respond_to?(:size) ? value : value.to_ary).size).include?(token)
+            raise(ResolutionError, "Invalid resolution: #{token.inspect} is not a valid index of #{value.inspect}")
+          end
+
+          child = (value.respond_to?(:[]) ? value : value.to_ary)[token, *a]
+        elsif value.respond_to?(:to_hash)
+          unless (value.respond_to?(:key?) ? value : value.to_hash).key?(token)
+            raise(ResolutionError, "Invalid resolution: #{token.inspect} is not a valid key of #{value.inspect}")
+          end
+
+          child = (value.respond_to?(:[]) ? value : value.to_hash)[token, *a]
+        else
+          raise(ResolutionError, "Invalid resolution: #{token.inspect} cannot be resolved in #{value.inspect}")
+        end
+        [token, child]
+      end
+    end
+end

data/lib/jsi/schema/application/child_application/contains.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Application::ChildApplication::Contains
+    # @private
+    def internal_applicate_contains(idx, instance, &block)
+      if schema_content.key?('contains')
+        contains_schema = subschema(['contains'])
+
+        if contains_schema.instance_valid?(instance[idx])
+          yield contains_schema
+        end
+      end
+    end
+  end
+end

data/lib/jsi/schema/application/child_application/draft04.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Application::ChildApplication::Draft04
+    include Schema::Application::ChildApplication
+    include Schema::Application::ChildApplication::Items
+    include Schema::Application::ChildApplication::Properties
+
+    # @private
+    def internal_child_applicate_keywords(token, instance, &block)
+      if instance.respond_to?(:to_ary)
+        # 5.3.1.  additionalItems and items
+        internal_applicate_items(token, &block)
+      end
+
+      if instance.respond_to?(:to_hash)
+        # 5.4.4.  additionalProperties, properties and patternProperties
+        internal_applicate_properties(token, &block)
+      end
+    end
+  end
+end

data/lib/jsi/schema/application/child_application/draft06.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Application::ChildApplication::Draft06
+    include Schema::Application::ChildApplication
+    include Schema::Application::ChildApplication::Items
+    include Schema::Application::ChildApplication::Contains
+    include Schema::Application::ChildApplication::Properties
+
+    # @private
+    def internal_child_applicate_keywords(token, instance, &block)
+      if instance.respond_to?(:to_ary)
+        # json-schema-validation 6.9.  items
+        # json-schema-validation 6.10.  additionalItems
+        internal_applicate_items(token, &block)
+
+        # json-schema-validation 6.14.  contains
+        internal_applicate_contains(token, instance, &block)
+      end
+
+      if instance.respond_to?(:to_hash)
+        # json-schema-validation 6.18.  properties
+        # json-schema-validation 6.19.  patternProperties
+        # json-schema-validation 6.20.  additionalProperties
+        internal_applicate_properties(token, &block)
+      end
+    end
+  end
+end

data/lib/jsi/schema/application/child_application/draft07.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Application::ChildApplication::Draft07
+    include Schema::Application::ChildApplication
+    include Schema::Application::ChildApplication::Items
+    include Schema::Application::ChildApplication::Contains
+    include Schema::Application::ChildApplication::Properties
+
+    # @private
+    def internal_child_applicate_keywords(token, instance, &block)
+      if instance.respond_to?(:to_ary)
+        # 6.4.1.  items
+        # 6.4.2.  additionalItems
+        internal_applicate_items(token, &block)
+
+        # 6.4.6.  contains
+        internal_applicate_contains(token, instance, &block)
+      end
+
+      if instance.respond_to?(:to_hash)
+        # 6.5.4.  properties
+        # 6.5.5.  patternProperties
+        # 6.5.6.  additionalProperties
+        internal_applicate_properties(token, &block)
+      end
+    end
+  end
+end

data/lib/jsi/schema/application/child_application/items.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Application::ChildApplication::Items
+    # @private
+    def internal_applicate_items(idx, &block)
+      if schema_content['items'].respond_to?(:to_ary)
+        if schema_content['items'].each_index.to_a.include?(idx)
+          yield subschema(['items', idx])
+        elsif schema_content.key?('additionalItems')
+          yield subschema(['additionalItems'])
+        end
+      elsif schema_content.key?('items')
+        yield subschema(['items'])
+      end
+    end
+  end
+end

data/lib/jsi/schema/application/child_application/properties.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Application::ChildApplication::Properties
+    # @private
+    def internal_applicate_properties(property_name, &block)
+      apply_additional = true
+      if schema_content.key?('properties') && schema_content['properties'].respond_to?(:to_hash) && schema_content['properties'].key?(property_name)
+        apply_additional = false
+        yield subschema(['properties', property_name])
+      end
+      if schema_content['patternProperties'].respond_to?(:to_hash)
+        schema_content['patternProperties'].each_key do |pattern|
+          if pattern.respond_to?(:to_str) && property_name.to_s =~ Regexp.new(pattern) # TODO map pattern to ruby syntax
+            apply_additional = false
+            yield subschema(['patternProperties', pattern])
+          end
+        end
+      end
+      if apply_additional && schema_content.key?('additionalProperties')
+        yield subschema(['additionalProperties'])
+      end
+    end
+  end
+end

data/lib/jsi/schema/application/child_application.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Application::ChildApplication
+    autoload :Draft04, 'jsi/schema/application/child_application/draft04'
+    autoload :Draft06, 'jsi/schema/application/child_application/draft06'
+    autoload :Draft07, 'jsi/schema/application/child_application/draft07'
+
+    autoload :Items, 'jsi/schema/application/child_application/items'
+    autoload :Contains, 'jsi/schema/application/child_application/contains'
+    autoload :Properties, 'jsi/schema/application/child_application/properties'
+
+    # a set of child applicator subschemas of this schema which apply to the child of the given instance
+    # on the given token.
+    #
+    # @param token [Object] the array index or object property name for the child instance
+    # @param instance [Object] the instance to check any child applicators against
+    # @return [JSI::SchemaSet] child applicator subschemas of this schema for the given token
+    #   of the instance
+    def child_applicator_schemas(token, instance)
+      SchemaSet.new(each_child_applicator_schema(token, instance))
+    end
+
+    # yields each child applicator subschema (from properties, items, etc.) which applies to the child of
+    # the given instance on the given token.
+    #
+    # @param (see #child_applicator_schemas)
+    # @yield [JSI::Schema]
+    # @return [nil, Enumerator] an Enumerator if invoked without a block; otherwise nil
+    def each_child_applicator_schema(token, instance, &block)
+      return to_enum(__method__, token, instance) unless block
+
+      if schema_content.respond_to?(:to_hash)
+        internal_child_applicate_keywords(token, instance, &block)
+      end
+
+      nil
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Application::Draft04
+    include Schema::Application::InplaceApplication::Draft04
+    include Schema::Application::ChildApplication::Draft04
+  end
+end

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Application::Draft06
+    include Schema::Application::InplaceApplication::Draft06
+    include Schema::Application::ChildApplication::Draft06
+  end
+end

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Application::Draft07
+    include Schema::Application::InplaceApplication::Draft07
+    include Schema::Application::ChildApplication::Draft07
+  end
+end

data/lib/jsi/schema/application/inplace_application/dependencies.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Application::InplaceApplication::Dependencies
+    # @private
+    def internal_applicate_dependencies(instance, visited_refs, &block)
+      if schema_content.key?('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.
+        if value.respond_to?(:to_hash)
+          value.each_pair do |property_name, dependency|
+            if dependency.respond_to?(:to_ary)
+              # noop: array-form dependencies has no inplace applicator schema
+            else
+              # If the dependency value is a subschema, and the dependency key is a
+              # property in the instance, the entire instance must validate against
+              # the dependency value.
+              if instance.respond_to?(:to_hash) && instance.key?(property_name)
+                subschema(['dependencies', property_name]).each_inplace_applicator_schema(instance, visited_refs: visited_refs, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsi/schema/application/inplace_application/draft04.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Application::InplaceApplication::Draft04
+    include Schema::Application::InplaceApplication
+    include Schema::Application::InplaceApplication::Ref
+    include Schema::Application::InplaceApplication::Dependencies
+    include Schema::Application::InplaceApplication::SomeOf
+
+    # @private
+    def internal_inplace_applicate_keywords(instance, visited_refs, &block)
+      internal_applicate_ref(instance, visited_refs, throw_done: true, &block)
+
+      # self is the first applicator schema if $ref has not short-circuited it
+      yield self
+
+      # 5.4.5.  dependencies
+      internal_applicate_dependencies(instance, visited_refs, &block)
+
+      # 5.5.3.  allOf
+      # 5.5.4.  anyOf
+      # 5.5.5.  oneOf
+      internal_applicate_someOf(instance, visited_refs, &block)
+    end
+  end
+end

data/lib/jsi/schema/application/inplace_application/draft06.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Application::InplaceApplication::Draft06
+    include Schema::Application::InplaceApplication
+    include Schema::Application::InplaceApplication::Ref
+    include Schema::Application::InplaceApplication::Dependencies
+    include Schema::Application::InplaceApplication::SomeOf
+
+    # @private
+    def internal_inplace_applicate_keywords(instance, visited_refs, &block)
+      # json-schema 8.  Schema references with $ref
+      internal_applicate_ref(instance, visited_refs, throw_done: true, &block)
+
+      # self is the first applicator schema if $ref has not short-circuited it
+      yield self
+
+      # json-schema-validation 6.21.  dependencies
+      internal_applicate_dependencies(instance, visited_refs, &block)
+
+      # json-schema-validation 6.26.  allOf
+      # json-schema-validation 6.27.  anyOf
+      # json-schema-validation 6.28.  oneOf
+      internal_applicate_someOf(instance, visited_refs, &block)
+    end
+  end
+end

data/lib/jsi/schema/application/inplace_application/draft07.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Application::InplaceApplication::Draft07
+    include Schema::Application::InplaceApplication
+    include Schema::Application::InplaceApplication::Ref
+    include Schema::Application::InplaceApplication::Dependencies
+    include Schema::Application::InplaceApplication::IfThenElse
+    include Schema::Application::InplaceApplication::SomeOf
+
+    # @private
+    def internal_inplace_applicate_keywords(instance, visited_refs, &block)
+      # json-schema 8.  Schema references with $ref
+      internal_applicate_ref(instance, visited_refs, throw_done: true, &block)
+
+      # self is the first applicator schema if $ref has not short-circuited it
+      block.call(self)
+
+      # 6.5.7.  dependencies
+      internal_applicate_dependencies(instance, visited_refs, &block)
+
+      # 6.6.1.  if
+      # 6.6.2.  then
+      # 6.6.3.  else
+      internal_applicate_ifthenelse(instance, visited_refs, &block)
+
+      # 6.7.1.  allOf
+      # 6.7.2.  anyOf
+      # 6.7.3.  oneOf
+      internal_applicate_someOf(instance, visited_refs, &block)
+    end
+  end
+end

data/lib/jsi/schema/application/inplace_application/ifthenelse.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Application::InplaceApplication::IfThenElse
+    # @private
+    def internal_applicate_ifthenelse(instance, visited_refs, &block)
+      if schema_content.key?('if')
+        if subschema(['if']).instance_valid?(instance)
+          if schema_content.key?('then')
+            subschema(['then']).each_inplace_applicator_schema(instance, visited_refs: visited_refs, &block)
+          end
+        else
+          if schema_content.key?('else')
+            subschema(['else']).each_inplace_applicator_schema(instance, visited_refs: visited_refs, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsi/schema/application/inplace_application/ref.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module JSI
+  module Schema::Application::InplaceApplication::Ref
+    # @private
+    def internal_applicate_ref(instance, visited_refs, throw_done: false, &block)
+      if schema_content['$ref'].respond_to?(:to_str)
+        ref = jsi_memoize(:ref) { Schema::Ref.new(schema_content['$ref'], self) }
+        unless visited_refs.include?(ref)
+          ref.deref_schema.each_inplace_applicator_schema(instance, visited_refs: visited_refs + [ref], &block)
+          if throw_done
+            throw(:jsi_application_done)
+          end
+        end
+      end
+    end
+  end
+end