Support custom content encodings and media types

This exposes hooks for the `contentEncoding` and `contentMediaType`
keywords, similar to the existing custom formats behavior. The provided
callables must return a tuple comprised of a validation boolean and
annotation of any type. The validation boolean is ignored in draft
2019-09 and 2020-12, because the [specification][0] says:

> They do not function as validation assertions; a malformed string-encoded document MUST NOT cause the containing instance to be considered invalid.

Drafts 7 and earlier will return a validation error based on the
validation boolean. From the [specification][1]:

> Implementations MAY support the "contentMediaType" and "contentEncoding" keywords as validation assertions.

All drafts forward the returned annotation as an annotation in the
overall result.

I don't love the API here, since it requires returning an array even
when it's ignored in the latest drafts, but I couldn't come up with
anything better.

Closes: #137

[0]: https://json-schema.org/draft/2020-12/json-schema-validation#section-8.1
[1]: https://json-schema.org/draft-07/draft-handrews-json-schema-validation-01#rfc.section.8.2

Author: davishmcclurg

README.md

@@ -180,6 +180,28 @@ JSONSchemer.schema(
   # default: true
   format: true,
 
+  # custom content encodings
+  # only `base64` is available by default
+  content_encodings: {
+    # return [success, annotation] tuple
+    'urlsafe_base64' => proc do |instance|
+      [true, Base64.urlsafe_decode64(instance)]
+    rescue
+      [false, nil]
+    end
+  },
+
+  # custom content media types
+  # only `application/json` is available by default
+  content_media_types: {
+    # return [success, annotation] tuple
+    'text/csv' => proc do |instance|
+      [true, CSV.parse(instance)]
+    rescue
+      [false, nil]
+    end
+  },
+
   # insert default property values during validation
   # true/false
   # default: false

lib/json_schemer.rb

@@ -20,6 +20,7 @@
 require 'json_schemer/format/uri_template'
 require 'json_schemer/format/email'
 require 'json_schemer/format'
+require 'json_schemer/content'
 require 'json_schemer/errors'
 require 'json_schemer/cached_resolver'
 require 'json_schemer/ecma_regexp'
@@ -146,6 +147,8 @@ def draft202012
         Draft202012::SCHEMA,
         :base_uri => Draft202012::BASE_URI,
         :formats => Draft202012::FORMATS,
+        :content_encodings => Draft202012::CONTENT_ENCODINGS,
+        :content_media_types => Draft202012::CONTENT_MEDIA_TYPES,
         :ref_resolver => Draft202012::Meta::SCHEMAS.to_proc,
         :regexp_resolver => 'ecma'
       )
@@ -156,6 +159,8 @@ def draft201909
         Draft201909::SCHEMA,
         :base_uri => Draft201909::BASE_URI,
         :formats => Draft201909::FORMATS,
+        :content_encodings => Draft201909::CONTENT_ENCODINGS,
+        :content_media_types => Draft201909::CONTENT_MEDIA_TYPES,
         :ref_resolver => Draft201909::Meta::SCHEMAS.to_proc,
         :regexp_resolver => 'ecma'
       )
@@ -167,6 +172,8 @@ def draft7
         :vocabulary => { 'json-schemer://draft7' => true },
         :base_uri => Draft7::BASE_URI,
         :formats => Draft7::FORMATS,
+        :content_encodings => Draft7::CONTENT_ENCODINGS,
+        :content_media_types => Draft7::CONTENT_MEDIA_TYPES,
         :regexp_resolver => 'ecma'
       )
     end
@@ -177,6 +184,8 @@ def draft6
         :vocabulary => { 'json-schemer://draft6' => true },
         :base_uri => Draft6::BASE_URI,
         :formats => Draft6::FORMATS,
+        :content_encodings => Draft6::CONTENT_ENCODINGS,
+        :content_media_types => Draft6::CONTENT_MEDIA_TYPES,
         :regexp_resolver => 'ecma'
       )
     end
@@ -187,6 +196,8 @@ def draft4
         :vocabulary => { 'json-schemer://draft4' => true },
         :base_uri => Draft4::BASE_URI,
         :formats => Draft4::FORMATS,
+        :content_encodings => Draft4::CONTENT_ENCODINGS,
+        :content_media_types => Draft4::CONTENT_MEDIA_TYPES,
         :regexp_resolver => 'ecma'
       )
     end

lib/json_schemer/content.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module ContentEncoding
+    BASE64 = proc do |instance|
+      [true, Base64.strict_decode64(instance)]
+    rescue
+      [false, nil]
+    end
+  end
+
+  module ContentMediaType
+    JSON = proc do |instance|
+      [true, ::JSON.parse(instance)]
+    rescue
+      [false, nil]
+    end
+  end
+end

lib/json_schemer/draft201909/meta.rb

@@ -3,6 +3,8 @@ module JSONSchemer
   module Draft201909
     BASE_URI = URI('https://json-schema.org/draft/2019-09/schema')
     FORMATS = Draft202012::FORMATS
+    CONTENT_ENCODINGS = Draft202012::CONTENT_ENCODINGS
+    CONTENT_MEDIA_TYPES = Draft202012::CONTENT_MEDIA_TYPES
     SCHEMA = {
       '$schema' => 'https://json-schema.org/draft/2019-09/schema',
       '$id' => 'https://json-schema.org/draft/2019-09/schema',

lib/json_schemer/draft202012/meta.rb

@@ -23,6 +23,12 @@ module Draft202012
       'relative-json-pointer' => Format::RELATIVE_JSON_POINTER,
       'regex' => Format::REGEX
     }
+    CONTENT_ENCODINGS = {
+      'base64' => ContentEncoding::BASE64
+    }
+    CONTENT_MEDIA_TYPES = {
+      'application/json' => ContentMediaType::JSON
+    }
     SCHEMA = {
       '$schema' => 'https://json-schema.org/draft/2020-12/schema',
       '$id' => 'https://json-schema.org/draft/2020-12/schema',

lib/json_schemer/draft202012/vocab/content.rb

@@ -4,21 +4,29 @@ module Draft202012
     module Vocab
       module Content
         class ContentEncoding < Keyword
+          def parse
+            root.fetch_content_encoding(value) { raise UnknownContentEncoding, value }
+          end
+
           def validate(instance, instance_location, keyword_location, _context)
             return result(instance, instance_location, keyword_location, true) unless instance.is_a?(String)
 
-            _valid, annotation = Format.decode_content_encoding(instance, value)
+            _valid, annotation = parsed.call(instance)
 
             result(instance, instance_location, keyword_location, true, :annotation => annotation)
           end
         end
 
         class ContentMediaType < Keyword
+          def parse
+            root.fetch_content_media_type(value) { raise UnknownContentMediaType, value }
+          end
+
           def validate(instance, instance_location, keyword_location, context)
             return result(instance, instance_location, keyword_location, true) unless instance.is_a?(String)
 
             decoded_instance = context.adjacent_results[ContentEncoding]&.annotation || instance
-            _valid, annotation = Format.parse_content_media_type(decoded_instance, value)
+            _valid, annotation = parsed.call(decoded_instance)
 
             result(instance, instance_location, keyword_location, true, :annotation => annotation)
           end

lib/json_schemer/draft4/meta.rb

@@ -6,6 +6,8 @@ module Draft4
     FORMATS.delete('uri-reference')
     FORMATS.delete('uri-template')
     FORMATS.delete('json-pointer')
+    CONTENT_ENCODINGS = Draft6::CONTENT_ENCODINGS
+    CONTENT_MEDIA_TYPES = Draft6::CONTENT_MEDIA_TYPES
     SCHEMA = {
       'id' => 'http://json-schema.org/draft-04/schema#',
       '$schema' => 'http://json-schema.org/draft-04/schema#',

lib/json_schemer/draft6/meta.rb

@@ -11,6 +11,8 @@ module Draft6
     FORMATS.delete('iri-reference')
     FORMATS.delete('relative-json-pointer')
     FORMATS.delete('regex')
+    CONTENT_ENCODINGS = Draft7::CONTENT_ENCODINGS
+    CONTENT_MEDIA_TYPES = Draft7::CONTENT_MEDIA_TYPES
     SCHEMA = {
       '$schema' => 'http://json-schema.org/draft-06/schema#',
       '$id' => 'http://json-schema.org/draft-06/schema#',

lib/json_schemer/draft7/meta.rb

@@ -5,6 +5,8 @@ module Draft7
     FORMATS = Draft201909::FORMATS.dup
     FORMATS.delete('duration')
     FORMATS.delete('uuid')
+    CONTENT_ENCODINGS = Draft201909::CONTENT_ENCODINGS
+    CONTENT_MEDIA_TYPES = Draft201909::CONTENT_MEDIA_TYPES
     SCHEMA = {
       '$schema' => 'http://json-schema.org/draft-07/schema#',
       '$id' => 'http://json-schema.org/draft-07/schema#',

lib/json_schemer/draft7/vocab/validation.rb

@@ -35,21 +35,21 @@ def validate(instance, instance_location, keyword_location, context)
           end
         end
 
-        class ContentEncoding < Keyword
+        class ContentEncoding < Draft202012::Vocab::Content::ContentEncoding
           def error(formatted_instance_location:, **)
             "string at #{formatted_instance_location} could not be decoded using encoding: #{value}"
           end
 
           def validate(instance, instance_location, keyword_location, _context)
             return result(instance, instance_location, keyword_location, true) unless instance.is_a?(String)
 
-            valid, annotation = Format.decode_content_encoding(instance, value)
+            valid, annotation = parsed.call(instance)
 
             result(instance, instance_location, keyword_location, valid, :annotation => annotation)
           end
         end
 
-        class ContentMediaType < Keyword
+        class ContentMediaType < Draft202012::Vocab::Content::ContentMediaType
           def error(formatted_instance_location:, **)
             "string at #{formatted_instance_location} could not be parsed using media type: #{value}"
           end
@@ -58,7 +58,7 @@ def validate(instance, instance_location, keyword_location, context)
             return result(instance, instance_location, keyword_location, true) unless instance.is_a?(String)
 
             decoded_instance = context.adjacent_results[ContentEncoding]&.annotation || instance
-            valid, annotation = Format.parse_content_media_type(decoded_instance, value)
+            valid, annotation = parsed.call(decoded_instance)
 
             result(instance, instance_location, keyword_location, valid, :annotation => annotation)
           end