Better error messages

This adds more descriptive error messages that are defined in keyword
classes. It also differentiates "type" (classic output format) and
"error" to make things a little more clear.

The new "error" key in the classic output format is a slight behavior
change, but it seems unlikely to break things.

I don't love the "instance at `/whatever`" and "instance at root"
wording, but I had trouble coming up with something generic. Hopefully
these can be improved in the future.

Author: davishmcclurg

README.md

@@ -50,7 +50,8 @@ schemer.validate({ 'abc' => 10 }).to_a
 #      "schema"=>{"type"=>"integer", "minimum"=>11},
 #      "schema_pointer"=>"/properties/abc",
 #      "root_schema"=>{"type"=>"object", "properties"=>{"abc"=>{"type"=>"integer", "minimum"=>11}}},
-#      "type"=>"minimum"}]
+#      "type"=>"minimum",
+#      "error"=>"number at `/abc` is less than: 11"}]
 
 # default property values
 
@@ -91,7 +92,8 @@ JSONSchemer.validate_schema({ '$id' => '#invalid' }).to_a
 #      "schema"=>{"$ref"=>"#/$defs/uriReferenceString", "$comment"=>"Non-empty fragments not allowed.", "pattern"=>"^[^#]*#?$"},
 #      "schema_pointer"=>"/properties/$id",
 #      "root_schema"=>{...meta schema},
-#      "type"=>"pattern"}]
+#      "type"=>"pattern",
+#      "error"=>"string at `/$id` does not match pattern: ^[^#]*#?$"}]
 
 JSONSchemer.schema({ '$id' => 'valid' }).valid_schema?
 # => true
@@ -102,7 +104,8 @@ JSONSchemer.schema({ '$id' => '#invalid' }).validate_schema.to_a
 #      "schema"=>{"$ref"=>"#/$defs/uriReferenceString", "$comment"=>"Non-empty fragments not allowed.", "pattern"=>"^[^#]*#?$"},
 #      "schema_pointer"=>"/properties/$id",
 #      "root_schema"=>{...meta schema},
-#      "type"=>"pattern"}]
+#      "type"=>"pattern",
+#      "error"=>"string at `/$id` does not match pattern: ^[^#]*#?$"}]
 ```
 
 ## Options

lib/json_schemer/draft201909/vocab/applicator.rb

@@ -4,6 +4,10 @@ module Draft201909
     module Vocab
       module Applicator
         class Items < Keyword
+          def error(formatted_instance_location:, **)
+            "array items at #{formatted_instance_location} do not match `items` schema(s)"
+          end
+
           def parse
             if value.is_a?(Array)
               value.map.with_index do |subschema, index|
@@ -32,6 +36,10 @@ def validate(instance, instance_location, keyword_location, context)
         end
 
         class AdditionalItems < Keyword
+          def error(formatted_instance_location:, **)
+            "array items at #{formatted_instance_location} do not match `additionalItems` schema"
+          end
+
           def parse
             subschema(value)
           end
@@ -51,6 +59,10 @@ def validate(instance, instance_location, keyword_location, context)
         end
 
         class UnevaluatedItems < Keyword
+          def error(formatted_instance_location:, **)
+            "array items at #{formatted_instance_location} do not match `unevaluatedItems` schema"
+          end
+
           def parse
             subschema(value)
           end

lib/json_schemer/draft202012/vocab/applicator.rb

@@ -4,6 +4,10 @@ module Draft202012
     module Vocab
       module Applicator
         class AllOf < Keyword
+          def error(formatted_instance_location:, **)
+            "value at #{formatted_instance_location} does not match all `allOf` schemas"
+          end
+
           def parse
             value.map.with_index do |subschema, index|
               subschema(subschema, index.to_s)
@@ -19,6 +23,10 @@ def validate(instance, instance_location, keyword_location, context)
         end
 
         class AnyOf < Keyword
+          def error(formatted_instance_location:, **)
+            "value at #{formatted_instance_location} does not match any `anyOf` schemas"
+          end
+
           def parse
             value.map.with_index do |subschema, index|
               subschema(subschema, index.to_s)
@@ -34,6 +42,10 @@ def validate(instance, instance_location, keyword_location, context)
         end
 
         class OneOf < Keyword
+          def error(formatted_instance_location:, **)
+            "value at #{formatted_instance_location} does not match exactly one `oneOf` schema"
+          end
+
           def parse
             value.map.with_index do |subschema, index|
               subschema(subschema, index.to_s)
@@ -50,6 +62,10 @@ def validate(instance, instance_location, keyword_location, context)
         end
 
         class Not < Keyword
+          def error(formatted_instance_location:, **)
+            "value at #{formatted_instance_location} matches `not` schema"
+          end
+
           def parse
             subschema(value)
           end
@@ -72,28 +88,42 @@ def validate(instance, instance_location, keyword_location, context)
         end
 
         class Then < Keyword
+          def error(formatted_instance_location:, **)
+            "value at #{formatted_instance_location} does not match conditional `then` schema"
+          end
+
           def parse
             subschema(value)
           end
 
           def validate(instance, instance_location, keyword_location, context)
             return unless context.adjacent_results.key?(If) && context.adjacent_results.fetch(If).annotation
-            parsed.validate_instance(instance, instance_location, keyword_location, context)
+            subschema_result = parsed.validate_instance(instance, instance_location, keyword_location, context)
+            result(instance, instance_location, keyword_location, subschema_result.valid, subschema_result.nested)
           end
         end
 
         class Else < Keyword
+          def error(formatted_instance_location:, **)
+            "value at #{formatted_instance_location} does not match conditional `else` schema"
+          end
+
           def parse
             subschema(value)
           end
 
           def validate(instance, instance_location, keyword_location, context)
             return unless context.adjacent_results.key?(If) && !context.adjacent_results.fetch(If).annotation
-            parsed.validate_instance(instance, instance_location, keyword_location, context)
+            subschema_result = parsed.validate_instance(instance, instance_location, keyword_location, context)
+            result(instance, instance_location, keyword_location, subschema_result.valid, subschema_result.nested)
           end
         end
 
         class DependentSchemas < Keyword
+          def error(formatted_instance_location:, **)
+            "value at #{formatted_instance_location} does not match applicable `dependentSchemas` schemas"
+          end
+
           def parse
             value.each_with_object({}) do |(key, subschema), out|
               out[key] = subschema(subschema, key)
@@ -114,6 +144,10 @@ def validate(instance, instance_location, keyword_location, context)
         end
 
         class PrefixItems < Keyword
+          def error(formatted_instance_location:, **)
+            "array items at #{formatted_instance_location} do not match corresponding `prefixItems` schemas"
+          end
+
           def parse
             value.map.with_index do |subschema, index|
               subschema(subschema, index.to_s)
@@ -132,6 +166,10 @@ def validate(instance, instance_location, keyword_location, context)
         end
 
         class Items < Keyword
+          def error(formatted_instance_location:, **)
+            "array items at #{formatted_instance_location} do not match `items` schema"
+          end
+
           def parse
             subschema(value)
           end
@@ -151,6 +189,10 @@ def validate(instance, instance_location, keyword_location, context)
         end
 
         class Contains < Keyword
+          def error(formatted_instance_location:, **)
+            "array at #{formatted_instance_location} does not contain enough items that match `contains` schema"
+          end
+
           def parse
             subschema(value)
           end
@@ -174,6 +216,10 @@ def validate(instance, instance_location, keyword_location, context)
         end
 
         class Properties < Keyword
+          def error(formatted_instance_location:, **)
+            "object properties at #{formatted_instance_location} do not match corresponding `properties` schemas"
+          end
+
           def parse
             value.each_with_object({}) do |(property, subschema), out|
               out[property] = subschema(subschema, property)
@@ -214,6 +260,10 @@ def validate(instance, instance_location, keyword_location, context)
         end
 
         class PatternProperties < Keyword
+          def error(formatted_instance_location:, **)
+            "object properties at #{formatted_instance_location} do not match corresponding `patternProperties` schemas"
+          end
+
           def parse
             value.each_with_object({}) do |(pattern, subschema), out|
               out[pattern] = subschema(subschema, pattern)
@@ -241,6 +291,14 @@ def validate(instance, instance_location, keyword_location, context)
         end
 
         class AdditionalProperties < Keyword
+          def error(formatted_instance_location:, **)
+            "object properties at #{formatted_instance_location} do not match `additionalProperties` schema"
+          end
+
+          def false_schema_error(formatted_instance_location:, **)
+            "object property at #{formatted_instance_location} is not defined and schema does not allow additional properties"
+          end
+
           def parse
             subschema(value)
           end
@@ -265,6 +323,10 @@ def validate(instance, instance_location, keyword_location, context)
         end
 
         class PropertyNames < Keyword
+          def error(formatted_instance_location:, **)
+            "object property names at #{formatted_instance_location} do not match `propertyNames` schema"
+          end
+
           def parse
             subschema(value)
           end
@@ -281,6 +343,10 @@ def validate(instance, instance_location, keyword_location, context)
         end
 
         class Dependencies < Keyword
+          def error(formatted_instance_location:, **)
+            "object at #{formatted_instance_location} either does not match applicable `dependencies` schemas or is missing required `dependencies` properties"
+          end
+
           def parse
             value.each_with_object({}) do |(key, value), out|
               out[key] = value.is_a?(Array) ? value : subschema(value, key)

lib/json_schemer/draft202012/vocab/format_annotation.rb

@@ -12,6 +12,10 @@ class Format < Keyword
             true
           end
 
+          def error(formatted_instance_location:, **)
+            "value at #{formatted_instance_location} does not match format: #{value}"
+          end
+
           def parse
             root.format && root.formats.fetch(value) { root.meta_schema.formats.fetch(value, DEFAULT_FORMAT) }
           end

lib/json_schemer/draft202012/vocab/format_assertion.rb

@@ -10,6 +10,10 @@ class Format < Keyword
             !instance.is_a?(String) || valid_spec_format?(instance, value)
           end
 
+          def error(formatted_instance_location:, **)
+            "value at #{formatted_instance_location} does not match format: #{value}"
+          end
+
           def parse
             root.format && root.formats.fetch(value) { root.meta_schema.formats.fetch(value, DEFAULT_FORMAT) }
           end

lib/json_schemer/draft202012/vocab/unevaluated.rb

@@ -4,6 +4,10 @@ module Draft202012
     module Vocab
       module Unevaluated
         class UnevaluatedItems < Keyword
+          def error(formatted_instance_location:, **)
+            "array items at #{formatted_instance_location} do not match `unevaluatedItems` schema"
+          end
+
           def parse
             subschema(value)
           end
@@ -43,6 +47,10 @@ def collect_unevaluated_items(result, instance_location, unevaluated_items)
         end
 
         class UnevaluatedProperties < Keyword
+          def error(formatted_instance_location:, **)
+            "object properties at #{formatted_instance_location} do not match `unevaluatedProperties` schema"
+          end
+
           def parse
             subschema(value)
           end