jsi 0.4.0 → 0.6.0

data/lib/jsi/pathed_node.rb

@@ -1,31 +1,21 @@
 # frozen_string_literal: true
 
 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
+  # this module represents a node in a document.
   #
-  # given these, this module represents the node in the document at the path.
+  # including class MUST define
   #
-  # the node content (#node_content) is the result of evaluating the node document at the path.
+  # - `#jsi_document` [Object] the document
+  # - `#jsi_ptr` [JSI::Ptr] a pointer to the node in the document
   module PathedNode
-    # @return [Object] the content of this node
-    def node_content
-      content = node_ptr.evaluate(node_document)
+    # the content of this node
+    def jsi_node_content
+      content = jsi_ptr.evaluate(jsi_document)
       content
     end
-
-    # @yield [JSI::JSON::Pointer] if a block is given (optional), this will yield a deref'd pointer
-    # @return [JSI::JSON::Pointer] our node_ptr, derefed against our node_document
-    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 extending a {JSI::PathedNode} object when its jsi_node_content is Hash-like (responds to #to_hash)
   module PathedHashNode
     # yields each hash key and value of this node.
     #
@@ -34,41 +24,45 @@ module JSI
     #
     # returns an Enumerator if no block is given.
     #
+    # @param a arguments are passed to `#[]`
     # @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?
+    # @return [self, Enumerator] an Enumerator if invoked without a block; otherwise self
+    def each(*a, &block)
+      return to_enum(__method__) { jsi_node_content_hash_pubsend(:size) } unless block
       if block.arity > 1
-        node_content_hash_pubsend(:each_key) { |k| yield k, self[k] }
+        jsi_node_content_hash_pubsend(:each_key) { |k| yield k, self[k, *a] }
       else
-        node_content_hash_pubsend(:each_key) { |k| yield [k, self[k]] }
+        jsi_node_content_hash_pubsend(:each_key) { |k| yield [k, self[k, *a]] }
       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] } }
+    # a hash in which each key is a key of the jsi_node_content hash and each value is the
+    # result of `self[key]`
+    # @param a arguments are passed to `#[]`
+    # @return [Hash]
+    def to_hash(*a)
+      {}.tap { |h| jsi_node_content_hash_pubsend(:each_key) { |k| h[k] = self[k, *a] } }
     end
 
     include Hashlike
 
+    # invokes the method with the given name on the jsi_node_content (if defined) or its #to_hash
     # @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)
+    # @param a arguments and block are passed to the invocation of method_name
+    # @return [Object] the result of calling method method_name on the jsi_node_content or its #to_hash
+    def jsi_node_content_hash_pubsend(method_name, *a, &b)
+      if jsi_node_content.respond_to?(method_name)
+        jsi_node_content.public_send(method_name, *a, &b)
       else
-        node_content.to_hash.public_send(method_name, *a, &b)
+        jsi_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)
+        jsi_node_content_hash_pubsend(method_name, *a, &b)
       end
     end
   end
@@ -80,30 +74,34 @@ module JSI
     #
     # returns an Enumerator if no block is given.
     #
+    # @param a arguments are passed to `#[]`
     # @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]) }
+    # @return [self, Enumerator] an Enumerator if invoked without a block; otherwise self
+    def each(*a, &block)
+      return to_enum(__method__) { jsi_node_content_ary_pubsend(:size) } unless block
+      jsi_node_content_ary_pubsend(:each_index) { |i| yield(self[i, *a]) }
       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
+    # an array, the same size as the jsi_node_content, in which the element at each index is the
+    # result of `self[index]`
+    # @param a arguments are passed to `#[]`
+    # @return [Array]
+    def to_ary(*a)
+      to_a(*a)
     end
 
     include Arraylike
 
+    # invokes the method with the given name on the jsi_node_content (if defined) or its #to_ary
     # @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)
+    # @param a arguments and block are passed to the invocation of method_name
+    # @return [Object] the result of calling method method_name on the jsi_node_content or its #to_ary
+    def jsi_node_content_ary_pubsend(method_name, *a, &b)
+      if jsi_node_content.respond_to?(method_name)
+        jsi_node_content.public_send(method_name, *a, &b)
       else
-        node_content.to_ary.public_send(method_name, *a, &b)
+        jsi_node_content.to_ary.public_send(method_name, *a, &b)
       end
     end
 
@@ -111,7 +109,7 @@ module JSI
     # 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)
+        jsi_node_content_ary_pubsend(method_name, *a, &b)
       end
     end
   end

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