json_schemer 2.0.0 → 2.1.1

data/lib/json_schemer/draft6/meta.rb

@@ -2,6 +2,17 @@
 module JSONSchemer
   module Draft6
     BASE_URI = URI('http://json-schema.org/draft-06/schema#')
+    FORMATS = Draft7::FORMATS.dup
+    FORMATS.delete('date')
+    FORMATS.delete('time')
+    FORMATS.delete('idn-email')
+    FORMATS.delete('idn-hostname')
+    FORMATS.delete('iri')
+    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#',

data/lib/json_schemer/draft7/meta.rb

@@ -2,6 +2,11 @@
 module JSONSchemer
   module Draft7
     BASE_URI = URI('http://json-schema.org/draft-07/schema#')
+    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#',

data/lib/json_schemer/draft7/vocab/validation.rb

@@ -35,7 +35,7 @@ module JSONSchemer
           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
@@ -43,13 +43,13 @@ module JSONSchemer
           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 @@ module JSONSchemer
             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

data/lib/json_schemer/format.rb

@@ -1,15 +1,76 @@
 # frozen_string_literal: true
 module JSONSchemer
   module Format
-    include Duration
-    include Email
-    include Hostname
-    include JSONPointer
-    include URITemplate
+    # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-7.3
+    DATE_TIME = proc do |instance, _format|
+      !instance.is_a?(String) || valid_date_time?(instance)
+    end
+    DATE = proc do |instance, _format|
+      !instance.is_a?(String) || valid_date_time?("#{instance}T04:05:06.123456789+07:00")
+    end
+    TIME = proc do |instance, _format|
+      !instance.is_a?(String) || valid_date_time?("2001-02-03T#{instance}")
+    end
+    DURATION = proc do |instance, _format|
+      !instance.is_a?(String) || valid_duration?(instance)
+    end
+    # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-7.3.2
+    EMAIL = proc do |instance, _format|
+      !instance.is_a?(String) || instance.ascii_only? && valid_email?(instance)
+    end
+    IDN_EMAIL = proc do |instance, _format|
+      !instance.is_a?(String) || valid_email?(instance)
+    end
+    # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-7.3.3
+    HOSTNAME = proc do |instance, _format|
+      !instance.is_a?(String) || instance.ascii_only? && valid_hostname?(instance)
+    end
+    IDN_HOSTNAME = proc do |instance, _format|
+      !instance.is_a?(String) || valid_hostname?(instance)
+    end
+    # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-7.3.4
+    IPV4 = proc do |instance, _format|
+      !instance.is_a?(String) || valid_ip?(instance, Socket::AF_INET)
+    end
+    IPV6 = proc do |instance, _format|
+      !instance.is_a?(String) || valid_ip?(instance, Socket::AF_INET6)
+    end
+    # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-7.3.5
+    URI = proc do |instance, _format|
+      !instance.is_a?(String) || valid_uri?(instance)
+    end
+    URI_REFERENCE = proc do |instance, _format|
+      !instance.is_a?(String) || valid_uri_reference?(instance)
+    end
+    IRI = proc do |instance, _format|
+      !instance.is_a?(String) || valid_uri?(iri_escape(instance))
+    end
+    IRI_REFERENCE = proc do |instance, _format|
+      !instance.is_a?(String) || valid_uri_reference?(iri_escape(instance))
+    end
+    UUID = proc do |instance, _format|
+      !instance.is_a?(String) || valid_uuid?(instance)
+    end
+    # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-7.3.6
+    URI_TEMPLATE = proc do |instance, _format|
+      !instance.is_a?(String) || valid_uri_template?(instance)
+    end
+    # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-7.3.7
+    JSON_POINTER = proc do |instance, _format|
+      !instance.is_a?(String) || valid_json_pointer?(instance)
+    end
+    RELATIVE_JSON_POINTER = proc do |instance, _format|
+      !instance.is_a?(String) || valid_relative_json_pointer?(instance)
+    end
+    # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-7.3.8
+    REGEX = proc do |instance, _format|
+      !instance.is_a?(String) || valid_regex?(instance)
+    end
 
     DATE_TIME_OFFSET_REGEX = /(Z|[\+\-]([01][0-9]|2[0-3]):[0-5][0-9])\z/i.freeze
-    HOUR_24_REGEX = /T24/.freeze
-    LEAP_SECOND_REGEX = /T\d{2}:\d{2}:6/.freeze
+    DATE_TIME_SEPARATOR_CHARACTER_CLASS = '[Tt\s]'
+    HOUR_24_REGEX = /#{DATE_TIME_SEPARATOR_CHARACTER_CLASS}24:/.freeze
+    LEAP_SECOND_REGEX = /#{DATE_TIME_SEPARATOR_CHARACTER_CLASS}\d{2}:\d{2}:6/.freeze
     IP_REGEX = /\A[\h:.]+\z/.freeze
     INVALID_QUERY_REGEX = /\s/.freeze
     IRI_ESCAPE_REGEX = /[^[:ascii:]]/
@@ -20,6 +81,12 @@ module JSONSchemer
     end.freeze
 
     class << self
+      include Duration
+      include Email
+      include Hostname
+      include JSONPointer
+      include URITemplate
+
       def percent_encode(data, regexp)
         data = data.dup
         data.force_encoding(Encoding::ASCII_8BIT)
@@ -27,126 +94,55 @@ module JSONSchemer
         data.force_encoding(Encoding::US_ASCII)
       end
 
-      def decode_content_encoding(data, content_encoding)
-        case content_encoding
-        when 'base64'
-          begin
-            [true, Base64.strict_decode64(data)]
-          rescue
-            [false, nil]
-          end
-        else
-          raise UnknownContentEncoding, content_encoding
-        end
+      def valid_date_time?(data)
+        return false if HOUR_24_REGEX.match?(data)
+        datetime = DateTime.rfc3339(data)
+        return false if LEAP_SECOND_REGEX.match?(data) && datetime.new_offset.strftime('%H:%M') != '23:59'
+        DATE_TIME_OFFSET_REGEX.match?(data)
+      rescue ArgumentError
+        false
       end
 
-      def parse_content_media_type(data, content_media_type)
-        case content_media_type
-        when 'application/json'
-          begin
-            [true, JSON.parse(data)]
-          rescue
-            [false, nil]
-          end
-        else
-          raise UnknownContentMediaType, content_media_type
-        end
+      def valid_ip?(data, family)
+        IPAddr.new(data, family)
+        IP_REGEX.match?(data)
+      rescue IPAddr::Error
+        false
       end
-    end
 
-    def valid_spec_format?(data, format)
-      case format
-      when 'date-time'
-        valid_date_time?(data)
-      when 'date'
-        valid_date_time?("#{data}T04:05:06.123456789+07:00")
-      when 'time'
-        valid_date_time?("2001-02-03T#{data}")
-      when 'email'
-        data.ascii_only? && valid_email?(data)
-      when 'idn-email'
-        valid_email?(data)
-      when 'hostname'
-        data.ascii_only? && valid_hostname?(data)
-      when 'idn-hostname'
-        valid_hostname?(data)
-      when 'ipv4'
-        valid_ip?(data, Socket::AF_INET)
-      when 'ipv6'
-        valid_ip?(data, Socket::AF_INET6)
-      when 'uri'
-        valid_uri?(data)
-      when 'uri-reference'
-        valid_uri_reference?(data)
-      when 'iri'
-        valid_uri?(iri_escape(data))
-      when 'iri-reference'
-        valid_uri_reference?(iri_escape(data))
-      when 'uri-template'
-        valid_uri_template?(data)
-      when 'json-pointer'
-        valid_json_pointer?(data)
-      when 'relative-json-pointer'
-        valid_relative_json_pointer?(data)
-      when 'regex'
-        valid_regex?(data)
-      when 'duration'
-        valid_duration?(data)
-      when 'uuid'
-        valid_uuid?(data)
-      else
-        raise UnknownFormat, format
+      def parse_uri_scheme(data)
+        scheme, _userinfo, _host, _port, _registry, _path, opaque, query, _fragment = ::URI::RFC3986_PARSER.split(data)
+        # ::URI::RFC3986_PARSER.parse allows spaces in these and I don't think it should
+        raise ::URI::InvalidURIError if INVALID_QUERY_REGEX.match?(query) || INVALID_QUERY_REGEX.match?(opaque)
+        scheme
       end
-    end
-
-    def valid_date_time?(data)
-      return false if HOUR_24_REGEX.match?(data)
-      datetime = DateTime.rfc3339(data)
-      return false if LEAP_SECOND_REGEX.match?(data) && datetime.new_offset.strftime('%H:%M') != '23:59'
-      DATE_TIME_OFFSET_REGEX.match?(data)
-    rescue ArgumentError
-      false
-    end
-
-    def valid_ip?(data, family)
-      IPAddr.new(data, family)
-      IP_REGEX.match?(data)
-    rescue IPAddr::Error
-      false
-    end
-
-    def parse_uri_scheme(data)
-      scheme, _userinfo, _host, _port, _registry, _path, opaque, query, _fragment = URI::RFC3986_PARSER.split(data)
-      # URI::RFC3986_PARSER.parse allows spaces in these and I don't think it should
-      raise URI::InvalidURIError if INVALID_QUERY_REGEX.match?(query) || INVALID_QUERY_REGEX.match?(opaque)
-      scheme
-    end
 
-    def valid_uri?(data)
-      !!parse_uri_scheme(data)
-    rescue URI::InvalidURIError
-      false
-    end
+      def valid_uri?(data)
+        !!parse_uri_scheme(data)
+      rescue ::URI::InvalidURIError
+        false
+      end
 
-    def valid_uri_reference?(data)
-      parse_uri_scheme(data)
-      true
-    rescue URI::InvalidURIError
-      false
-    end
+      def valid_uri_reference?(data)
+        parse_uri_scheme(data)
+        true
+      rescue ::URI::InvalidURIError
+        false
+      end
 
-    def iri_escape(data)
-      Format.percent_encode(data, IRI_ESCAPE_REGEX)
-    end
+      def iri_escape(data)
+        Format.percent_encode(data, IRI_ESCAPE_REGEX)
+      end
 
-    def valid_regex?(data)
-      !!EcmaRegexp.ruby_equivalent(data)
-    rescue InvalidEcmaRegexp
-      false
-    end
+      def valid_regex?(data)
+        !!EcmaRegexp.ruby_equivalent(data)
+      rescue InvalidEcmaRegexp
+        false
+      end
 
-    def valid_uuid?(data)
-      UUID_REGEX.match?(data) || NIL_UUID == data
+      def valid_uuid?(data)
+        UUID_REGEX.match?(data) || NIL_UUID == data
+      end
     end
   end
 end

data/lib/json_schemer/keyword.rb

@@ -26,6 +26,18 @@ module JSONSchemer
       @schema_pointer ||= "#{parent.schema_pointer}/#{escaped_keyword}"
     end
 
+    def error_key
+      keyword
+    end
+
+    def fetch(key)
+      parsed.fetch(parsed.is_a?(Array) ? key.to_i : key)
+    end
+
+    def parsed_schema
+      parsed.is_a?(Schema) ? parsed : nil
+    end
+
   private
 
     def parse

data/lib/json_schemer/openapi30/document.rb

@@ -1584,8 +1584,7 @@ module JSONSchemer
                 'type' => 'string'
               },
               'operationRef' => {
-                'type' => 'string',
-                'format' => 'uri-reference'
+                'type' => 'string'
               },
               'parameters' => {
                 'type' => 'object',

data/lib/json_schemer/openapi30/meta.rb

@@ -2,6 +2,12 @@
 module JSONSchemer
   module OpenAPI30
     BASE_URI = URI('json-schemer://openapi30/schema')
+    # https://spec.openapis.org/oas/v3.0.3#data-types
+    FORMATS = OpenAPI31::FORMATS.merge(
+      'byte' => proc { |instance, _value| ContentEncoding::BASE64.call(instance).first },
+      'binary' => proc { |instance, _value| instance.is_a?(String) && instance.encoding == Encoding::ASCII_8BIT },
+      'date' => Format::DATE
+    )
     SCHEMA = {
       'id' => 'json-schemer://openapi30/schema',
       '$schema' => 'http://json-schema.org/draft-04/schema#',

data/lib/json_schemer/openapi31/document.rb

@@ -270,8 +270,7 @@ module JSONSchemer
             'type' => 'object',
             'properties' => {
               'url' => {
-                'type' => 'string',
-                'format' => 'uri-reference'
+                'type' => 'string'
               },
               'description' => {
                 'type' => 'string'
@@ -1054,8 +1053,7 @@ module JSONSchemer
             'type' => 'object',
             'properties' => {
               'operationRef' => {
-                'type' => 'string',
-                'format' => 'uri-reference'
+                'type' => 'string'
               },
               'operationId' => {
                 'type' => 'string'

data/lib/json_schemer/openapi31/meta.rb

@@ -2,6 +2,14 @@
 module JSONSchemer
   module OpenAPI31
     BASE_URI = URI('https://spec.openapis.org/oas/3.1/dialect/base')
+    # https://spec.openapis.org/oas/v3.1.0#data-types
+    FORMATS = {
+      'int32' => proc { |instance, _format| instance.is_a?(Integer) && instance.bit_length <= 32 },
+      'int64' => proc { |instance, _format| instance.is_a?(Integer) && instance.bit_length <= 64 },
+      'float' => proc { |instance, _format| instance.is_a?(Float) },
+      'double' => proc { |instance, _format| instance.is_a?(Float) },
+      'password' => proc { |_instance, _format| true }
+    }
     SCHEMA = {
       '$id' => 'https://spec.openapis.org/oas/3.1/dialect/base',
       '$schema' => 'https://json-schema.org/draft/2020-12/schema',

data/lib/json_schemer/openapi31/vocab/base.rb

@@ -34,7 +34,8 @@ module JSONSchemer
         end
 
         class Discriminator < Keyword
-          include Format::JSONPointer
+          # https://spec.openapis.org/oas/v3.1.0#components-object
+          FIXED_FIELD_REGEX = /\A[a-zA-Z0-9\.\-_]+$\z/
 
           attr_accessor :skip_ref_once
 
@@ -42,43 +43,80 @@ module JSONSchemer
             "value at #{formatted_instance_location} does not match `discriminator` schema"
           end
 
-          def validate(instance, instance_location, keyword_location, context)
-            property_name = value.fetch('propertyName')
-            mapping = value['mapping'] || {}
+          def mapping
+            @mapping ||= value['mapping'] || {}
+          end
+
+          def subschemas_by_property_value
+            @subschemas_by_property_value ||= if schema.parsed.key?('anyOf') || schema.parsed.key?('oneOf')
+              subschemas = schema.parsed['anyOf']&.parsed || []
+              subschemas += schema.parsed['oneOf']&.parsed || []
 
-            return result(instance, instance_location, keyword_location, true) unless instance.is_a?(Hash) && instance.key?(property_name)
+              subschemas_by_ref = {}
+              subschemas_by_schema_name = {}
 
-            property = instance.fetch(property_name)
-            ref = mapping.fetch(property, property)
+              subschemas.each do |subschema|
+                subschema_ref = subschema.parsed.fetch('$ref').parsed
+                subschemas_by_ref[subschema_ref] = subschema
 
-            ref_schema = nil
-            unless ref.start_with?('#') && valid_json_pointer?(ref.delete_prefix('#'))
-              ref_schema = begin
-                root.resolve_ref(URI.join(schema.base_uri, "#/components/schemas/#{ref}"))
-              rescue InvalidRefPointer
-                nil
+                if subschema_ref.start_with?('#/components/schemas/')
+                  schema_name = subschema_ref.delete_prefix('#/components/schemas/')
+                  subschemas_by_schema_name[schema_name] = subschema if FIXED_FIELD_REGEX.match?(schema_name)
+                end
               end
-            end
-            ref_schema ||= root.resolve_ref(URI.join(schema.base_uri, ref))
 
-            return if skip_ref_once == ref_schema.absolute_keyword_location
+              explicit_mapping = mapping.transform_values do |schema_name_or_ref|
+                subschemas_by_schema_name.fetch(schema_name_or_ref) { subschemas_by_ref.fetch(schema_name_or_ref) }
+              end
 
-            nested = []
+              implicit_mapping = subschemas_by_schema_name.reject do |_schema_name, subschema|
+                explicit_mapping.value?(subschema)
+              end
 
-            if schema.parsed.key?('anyOf') || schema.parsed.key?('oneOf')
-              subschemas = schema.parsed['anyOf']&.parsed || []
-              subschemas += schema.parsed['oneOf']&.parsed || []
-              subschemas.each do |subschema|
-                if subschema.parsed.fetch('$ref').ref_schema.absolute_keyword_location == ref_schema.absolute_keyword_location
-                  nested << subschema.validate_instance(instance, instance_location, keyword_location, context)
+              implicit_mapping.merge(explicit_mapping)
+            else
+              Hash.new do |hash, property_value|
+                schema_name_or_ref = mapping.fetch(property_value, property_value)
+
+                subschema = nil
+
+                if FIXED_FIELD_REGEX.match?(schema_name_or_ref)
+                  subschema = begin
+                    schema.ref("#/components/schemas/#{schema_name_or_ref}")
+                  rescue InvalidRefPointer
+                    nil
+                  end
+                end
+
+                subschema ||= begin
+                  schema.ref(schema_name_or_ref)
+                rescue InvalidRefResolution, UnknownRef
+                  nil
                 end
+
+                hash[property_value] = subschema
               end
-            else
-              ref_schema.parsed['allOf']&.skip_ref_once = schema.absolute_keyword_location
-              nested << ref_schema.validate_instance(instance, instance_location, keyword_location, context)
             end
+          end
+
+          def validate(instance, instance_location, keyword_location, context)
+            return result(instance, instance_location, keyword_location, true) unless instance.is_a?(Hash)
+
+            property_name = value.fetch('propertyName')
+
+            return result(instance, instance_location, keyword_location, false) unless instance.key?(property_name)
+
+            property_value = instance.fetch(property_name)
+            subschema = subschemas_by_property_value[property_value]
+
+            return result(instance, instance_location, keyword_location, false) unless subschema
+
+            return if skip_ref_once == subschema.absolute_keyword_location
+            subschema.parsed['allOf']&.skip_ref_once = schema.absolute_keyword_location
+
+            subschema_result = subschema.validate_instance(instance, instance_location, keyword_location, context)
 
-            result(instance, instance_location, keyword_location, (nested.any? && nested.all?(&:valid)), nested)
+            result(instance, instance_location, keyword_location, subschema_result.valid, subschema_result.nested)
           ensure
             self.skip_ref_once = nil
           end

data/lib/json_schemer/output.rb

@@ -5,14 +5,15 @@ module JSONSchemer
 
     attr_reader :keyword, :schema
 
+    def x_error
+      return @x_error if defined?(@x_error)
+      @x_error = schema.parsed['x-error']&.message(error_key)
+    end
+
   private
 
     def result(instance, instance_location, keyword_location, valid, nested = nil, type: nil, annotation: nil, details: nil, ignore_nested: false)
-      if valid
-        Result.new(self, instance, instance_location, keyword_location, valid, nested, type, annotation, details, ignore_nested, 'annotations')
-      else
-        Result.new(self, instance, instance_location, keyword_location, valid, nested, type, annotation, details, ignore_nested, 'errors')
-      end
+      Result.new(self, instance, instance_location, keyword_location, valid, nested, type, annotation, details, ignore_nested, valid ? 'annotations' : 'errors')
     end
 
     def escaped_keyword

data/lib/json_schemer/result.rb

@@ -1,10 +1,15 @@
 # frozen_string_literal: true
 module JSONSchemer
-  Result = Struct.new(:source, :instance, :instance_location, :keyword_location, :valid, :nested, :type, :annotation, :details, :ignore_nested, :nested_key) do
-    CLASSIC_ERROR_TYPES = Hash.new do |hash, klass|
-      hash[klass] = klass.name.rpartition('::').last.sub(/\A[[:alpha:]]/, &:downcase)
-    end
+  CATCHALL = '*'
+  I18N_SEPARATOR = "\x1F" # unit separator
+  I18N_SCOPE = 'json_schemer'
+  I18N_ERRORS_SCOPE = "#{I18N_SCOPE}#{I18N_SEPARATOR}errors"
+  X_ERROR_REGEX = /%\{(instance|instanceLocation|keywordLocation|absoluteKeywordLocation)\}/
+  CLASSIC_ERROR_TYPES = Hash.new do |hash, klass|
+    hash[klass] = klass.name.rpartition('::').last.sub(/\A[[:alpha:]]/, &:downcase)
+  end
 
+  Result = Struct.new(:source, :instance, :instance_location, :keyword_location, :valid, :nested, :type, :annotation, :details, :ignore_nested, :nested_key) do
     def output(output_format)
       case output_format
       when 'classic'
@@ -24,10 +29,59 @@ module JSONSchemer
 
     def error
       return @error if defined?(@error)
-      resolved_instance_location = Location.resolve(instance_location)
-      @error = source.error(
-        :formatted_instance_location => resolved_instance_location.empty? ? 'root' : "`#{resolved_instance_location}`",
-        :details => details
+      if source.x_error
+        # not using sprintf because it warns: "too many arguments for format string"
+        @error = source.x_error.gsub(
+          X_ERROR_REGEX,
+          '%{instance}' => instance,
+          '%{instanceLocation}' => Location.resolve(instance_location),
+          '%{keywordLocation}' => Location.resolve(keyword_location),
+          '%{absoluteKeywordLocation}' => source.absolute_keyword_location
+        )
+        @x_error = true
+      else
+        resolved_instance_location = Location.resolve(instance_location)
+        formatted_instance_location = resolved_instance_location.empty? ? 'root' : "`#{resolved_instance_location}`"
+        @error = source.error(:formatted_instance_location => formatted_instance_location, :details => details)
+        if i18n?
+          begin
+            @error = i18n!
+            @i18n = true
+          rescue I18n::MissingTranslationData
+          end
+        end
+      end
+      @error
+    end
+
+    def i18n?
+      return @@i18n if defined?(@@i18n)
+      @@i18n = defined?(I18n) && I18n.exists?(I18N_SCOPE)
+    end
+
+    def i18n!
+      base_uri_str = source.schema.base_uri.to_s
+      meta_schema_base_uri_str = source.schema.meta_schema.base_uri.to_s
+      resolved_keyword_location = Location.resolve(keyword_location)
+      error_key = source.error_key
+      I18n.translate!(
+        source.absolute_keyword_location,
+        :default => [
+          "#{base_uri_str}#{I18N_SEPARATOR}##{resolved_keyword_location}",
+          "##{resolved_keyword_location}",
+          "#{base_uri_str}#{I18N_SEPARATOR}#{error_key}",
+          "#{base_uri_str}#{I18N_SEPARATOR}#{CATCHALL}",
+          "#{meta_schema_base_uri_str}#{I18N_SEPARATOR}#{error_key}",
+          "#{meta_schema_base_uri_str}#{I18N_SEPARATOR}#{CATCHALL}",
+          error_key,
+          CATCHALL
+        ].map!(&:to_sym),
+        :separator => I18N_SEPARATOR,
+        :scope => I18N_ERRORS_SCOPE,
+        :instance => instance,
+        :instanceLocation => Location.resolve(instance_location),
+        :keywordLocation => resolved_keyword_location,
+        :absoluteKeywordLocation => source.absolute_keyword_location
       )
     end
 
@@ -38,8 +92,13 @@ module JSONSchemer
         'absoluteKeywordLocation' => source.absolute_keyword_location,
         'instanceLocation' => Location.resolve(instance_location)
       }
-      out['error'] = error unless valid
-      out['annotation'] = annotation if valid && annotation
+      if valid
+        out['annotation'] = annotation if annotation
+      else
+        out['error'] = error
+        out['x-error'] = true if @x_error
+        out['i18n'] = true if @i18n
+      end
       out
     end
 
@@ -54,6 +113,8 @@ module JSONSchemer
         'type' => type || CLASSIC_ERROR_TYPES[source.class]
       }
       out['error'] = error
+      out['x-error'] = true if @x_error
+      out['i18n'] = true if @i18n
       out['details'] = details if details
       out
     end