json_schemer 0.2.15 → 1.0.1

data/lib/json_schemer/format.rb

@@ -1,15 +1,19 @@
 # frozen_string_literal: true
 module JSONSchemer
   module Format
+    include Hostname
+    include URITemplate
+
     # this is no good
     EMAIL_REGEX = /\A[^@\s]+@([\p{L}\d-]+\.)+[\p{L}\d\-]{2,}\z/i.freeze
-    LABEL_REGEX_STRING = '[\p{L}\p{N}]([\p{L}\p{N}\-]*[\p{L}\p{N}])?'
-    HOSTNAME_REGEX = /\A(#{LABEL_REGEX_STRING}\.)*#{LABEL_REGEX_STRING}\z/i.freeze
     JSON_POINTER_REGEX_STRING = '(\/([^~\/]|~[01])*)*'
     JSON_POINTER_REGEX = /\A#{JSON_POINTER_REGEX_STRING}\z/.freeze
     RELATIVE_JSON_POINTER_REGEX = /\A(0|[1-9]\d*)(#|#{JSON_POINTER_REGEX_STRING})?\z/.freeze
     DATE_TIME_OFFSET_REGEX = /(Z|[\+\-]([01][0-9]|2[0-3]):[0-5][0-9])\z/i.freeze
-    INVALID_QUERY_REGEX = /[[:space:]]/.freeze
+    HOUR_24_REGEX = /T24/.freeze
+    LEAP_SECOND_REGEX = /T\d{2}:\d{2}:6/.freeze
+    IP_REGEX = /\A[\h:.]+\z/.freeze
+    INVALID_QUERY_REGEX = /\s/.freeze
 
     def valid_spec_format?(data, format)
       case format
@@ -28,9 +32,9 @@ module JSONSchemer
       when 'idn-hostname'
         valid_hostname?(data)
       when 'ipv4'
-        valid_ip?(data, :v4)
+        valid_ip?(data, Socket::AF_INET)
       when 'ipv6'
-        valid_ip?(data, :v6)
+        valid_ip?(data, Socket::AF_INET6)
       when 'uri'
         valid_uri?(data)
       when 'uri-reference'
@@ -46,7 +50,9 @@ module JSONSchemer
       when 'relative-json-pointer'
         valid_relative_json_pointer?(data)
       when 'regex'
-        EcmaReValidator.valid?(data)
+        valid_regex?(data)
+      else
+        raise UnknownFormat, format
       end
     end
 
@@ -58,25 +64,24 @@ module JSONSchemer
     end
 
     def valid_date_time?(data)
-      DateTime.rfc3339(data)
+      return false if HOUR_24_REGEX.match?(data)
+      datetime = DateTime.rfc3339(data)
+      return false if LEAP_SECOND_REGEX.match?(data) && datetime.to_time.utc.strftime('%H:%M') != '23:59'
       DATE_TIME_OFFSET_REGEX.match?(data)
-    rescue ArgumentError => e
-      raise e unless e.message == 'invalid date'
+    rescue ArgumentError
       false
     end
 
     def valid_email?(data)
-      EMAIL_REGEX.match?(data)
-    end
-
-    def valid_hostname?(data)
-      HOSTNAME_REGEX.match?(data) && data.split('.').all? { |label| label.size <= 63 }
+      return false unless EMAIL_REGEX.match?(data)
+      local, _domain = data.partition('@')
+      !local.start_with?('.') && !local.end_with?('.') && !local.include?('..')
     end
 
-    def valid_ip?(data, type)
-      ip_address = IPAddr.new(data)
-      type == :v4 ? ip_address.ipv4? : ip_address.ipv6?
-    rescue IPAddr::InvalidAddressError
+    def valid_ip?(data, family)
+      IPAddr.new(data, family)
+      IP_REGEX.match?(data)
+    rescue IPAddr::Error
       false
     end
 
@@ -101,14 +106,14 @@ module JSONSchemer
     end
 
     def iri_escape(data)
-      URI.escape(data, /[^[[:ascii:]]]/)
-    end
-
-    def valid_uri_template?(data)
-      URITemplate.new(data)
-      true
-    rescue URITemplate::Invalid
-      false
+      data.gsub(/[^[:ascii:]]/) do |match|
+        us = match
+        tmp = +''
+        us.each_byte do |uc|
+          tmp << sprintf('%%%02X', uc)
+        end
+        tmp
+      end.force_encoding(Encoding::US_ASCII)
     end
 
     def valid_json_pointer?(data)
@@ -118,5 +123,11 @@ module JSONSchemer
     def valid_relative_json_pointer?(data)
       RELATIVE_JSON_POINTER_REGEX.match?(data)
     end
+
+    def valid_regex?(data)
+      !!EcmaRegexp.ruby_equivalent(data)
+    rescue InvalidEcmaRegexp
+      false
+    end
   end
 end

data/lib/json_schemer/schema/base.rb

@@ -4,58 +4,102 @@ module JSONSchemer
     class Base
       include Format
 
-      Instance = Struct.new(:data, :data_pointer, :schema, :schema_pointer, :parent_uri, :insert_property_defaults) do
+      Instance = Struct.new(:data, :data_pointer, :schema, :schema_pointer, :base_uri, :before_property_validation, :after_property_validation) do
         def merge(
           data: self.data,
           data_pointer: self.data_pointer,
           schema: self.schema,
           schema_pointer: self.schema_pointer,
-          parent_uri: self.parent_uri,
-          insert_property_defaults: self.insert_property_defaults
+          base_uri: self.base_uri,
+          before_property_validation: self.before_property_validation,
+          after_property_validation: self.after_property_validation
         )
-          self.class.new(data, data_pointer, schema, schema_pointer, parent_uri, insert_property_defaults)
+          self.class.new(data, data_pointer, schema, schema_pointer, base_uri, before_property_validation, after_property_validation)
         end
       end
 
       ID_KEYWORD = '$id'
       DEFAULT_REF_RESOLVER = proc { |uri| raise UnknownRef, uri.to_s }
       NET_HTTP_REF_RESOLVER = proc { |uri| JSON.parse(Net::HTTP.get(uri)) }
+      RUBY_REGEXP_RESOLVER = proc { |pattern| Regexp.new(pattern) }
+      ECMA_REGEXP_RESOLVER = proc { |pattern| Regexp.new(EcmaRegexp.ruby_equivalent(pattern)) }
       BOOLEANS = Set[true, false].freeze
 
-      RUBY_REGEX_ANCHORS_TO_ECMA_262 = {
-        :bos => 'A',
-        :eos => 'z',
-        :bol => '\A',
-        :eol => '\z'
-      }.freeze
+      INSERT_DEFAULT_PROPERTY = proc do |data, property, property_schema, _parent|
+        if !data.key?(property) && property_schema.is_a?(Hash) && property_schema.key?('default')
+          data[property] = property_schema.fetch('default').clone
+        end
+      end
+
+      JSON_POINTER_TOKEN_ESCAPE_CHARS = { '~' => '~0', '/' => '~1' }
+      JSON_POINTER_TOKEN_ESCAPE_REGEX = Regexp.union(JSON_POINTER_TOKEN_ESCAPE_CHARS.keys)
+
+      class << self
+        def draft_name
+          name.split('::').last.downcase
+        end
+
+        def meta_schema
+          @meta_schema ||= JSON.parse(Pathname.new(__dir__).join("#{draft_name}.json").read).freeze
+        end
+
+        def meta_schemer
+          @meta_schemer ||= JSONSchemer.schema(meta_schema)
+        end
+      end
 
       def initialize(
         schema,
+        base_uri: nil,
         format: true,
         insert_property_defaults: false,
+        before_property_validation: nil,
+        after_property_validation: nil,
         formats: nil,
         keywords: nil,
-        ref_resolver: DEFAULT_REF_RESOLVER
+        ref_resolver: DEFAULT_REF_RESOLVER,
+        regexp_resolver: 'ruby'
       )
         raise InvalidSymbolKey, 'schemas must use string keys' if schema.is_a?(Hash) && !schema.empty? && !schema.first.first.is_a?(String)
         @root = schema
+        @base_uri = base_uri
         @format = format
-        @insert_property_defaults = insert_property_defaults
+        @before_property_validation = [*before_property_validation]
+        @before_property_validation.unshift(INSERT_DEFAULT_PROPERTY) if insert_property_defaults
+        @after_property_validation = [*after_property_validation]
         @formats = formats
         @keywords = keywords
-        @ref_resolver = ref_resolver == 'net/http' ? CachedRefResolver.new(&NET_HTTP_REF_RESOLVER) : ref_resolver
+        @ref_resolver = ref_resolver == 'net/http' ? CachedResolver.new(&NET_HTTP_REF_RESOLVER) : ref_resolver
+        @regexp_resolver = case regexp_resolver
+        when 'ecma'
+          CachedResolver.new(&ECMA_REGEXP_RESOLVER)
+        when 'ruby'
+          CachedResolver.new(&RUBY_REGEXP_RESOLVER)
+        else
+          regexp_resolver
+        end
       end
 
       def valid?(data)
-        valid_instance?(Instance.new(data, '', root, '', nil, !!@insert_property_defaults))
+        valid_instance?(Instance.new(data, '', root, '', @base_uri, @before_property_validation, @after_property_validation))
       end
 
       def validate(data)
-        validate_instance(Instance.new(data, '', root, '', nil, !!@insert_property_defaults))
+        validate_instance(Instance.new(data, '', root, '', @base_uri, @before_property_validation, @after_property_validation))
+      end
+
+      def valid_schema?
+        self.class.meta_schemer.valid?(root)
+      end
+
+      def validate_schema
+        self.class.meta_schemer.validate(root)
       end
 
     protected
 
+      attr_reader :root
+
       def valid_instance?(instance)
         validate_instance(instance).none?
       end
@@ -85,13 +129,13 @@ module JSONSchemer
         ref = schema['$ref']
         id = schema[id_keyword]
 
-        instance.parent_uri = join_uri(instance.parent_uri, id)
-
         if ref
           validate_ref(instance, ref, &block)
           return
         end
 
+        instance.base_uri = join_uri(instance.base_uri, id)
+
         if format? && custom_format?(format)
           validate_custom_format(instance, formats.fetch(format), &block)
         end
@@ -101,7 +145,7 @@ module JSONSchemer
         if keywords
           keywords.each do |keyword, callable|
             if schema.key?(keyword)
-              result = callable.call(data, schema, instance.pointer)
+              result = callable.call(data, schema, instance.data_pointer)
               if result.is_a?(Array)
                 result.each(&block)
               elsif !result
@@ -119,7 +163,8 @@ module JSONSchemer
             subinstance = instance.merge(
               schema: subschema,
               schema_pointer: "#{instance.schema_pointer}/allOf/#{index}",
-              insert_property_defaults: false
+              before_property_validation: false,
+              after_property_validation: false
             )
             validate_instance(subinstance, &block)
           end
@@ -130,7 +175,8 @@ module JSONSchemer
             subinstance = instance.merge(
               schema: subschema,
               schema_pointer: "#{instance.schema_pointer}/anyOf/#{index}",
-              insert_property_defaults: false
+              before_property_validation: false,
+              after_property_validation: false
             )
             validate_instance(subinstance)
           end
@@ -142,7 +188,8 @@ module JSONSchemer
             subinstance = instance.merge(
               schema: subschema,
               schema_pointer: "#{instance.schema_pointer}/oneOf/#{index}",
-              insert_property_defaults: false
+              before_property_validation: false,
+              after_property_validation: false
             )
             validate_instance(subinstance)
           end
@@ -158,14 +205,15 @@ module JSONSchemer
           subinstance = instance.merge(
             schema: not_schema,
             schema_pointer: "#{instance.schema_pointer}/not",
-            insert_property_defaults: false
+            before_property_validation: false,
+            after_property_validation: false
           )
           yield error(subinstance, 'not') if valid_instance?(subinstance)
         end
 
-        if if_schema && valid_instance?(instance.merge(schema: if_schema, insert_property_defaults: false))
+        if if_schema && valid_instance?(instance.merge(schema: if_schema, before_property_validation: false, after_property_validation: false))
           validate_instance(instance.merge(schema: then_schema, schema_pointer: "#{instance.schema_pointer}/then"), &block) unless then_schema.nil?
-        elsif if_schema
+        elsif schema.key?('if')
           validate_instance(instance.merge(schema: else_schema, schema_pointer: "#{instance.schema_pointer}/else"), &block) unless else_schema.nil?
         end
 
@@ -189,7 +237,7 @@ module JSONSchemer
 
     private
 
-      attr_reader :root, :formats, :keywords, :ref_resolver
+      attr_reader :formats, :keywords, :ref_resolver, :regexp_resolver
 
       def id_keyword
         ID_KEYWORD
@@ -207,13 +255,16 @@ module JSONSchemer
         !custom_format?(format) && supported_format?(format)
       end
 
-      def child(schema)
+      def child(schema, base_uri:)
         JSONSchemer.schema(
           schema,
+          default_schema_class: self.class,
+          base_uri: base_uri,
           format: format?,
           formats: formats,
           keywords: keywords,
-          ref_resolver: ref_resolver
+          ref_resolver: ref_resolver,
+          regexp_resolver: regexp_resolver
         )
       end
 
@@ -265,50 +316,38 @@ module JSONSchemer
       end
 
       def validate_ref(instance, ref, &block)
-        if ref.start_with?('#')
-          schema_pointer = ref.slice(1..-1)
-          if valid_json_pointer?(schema_pointer)
-            ref_pointer = Hana::Pointer.new(URI.decode_www_form_component(schema_pointer))
-            subinstance = instance.merge(
-              schema: ref_pointer.eval(root),
-              schema_pointer: schema_pointer,
-              parent_uri: (pointer_uri(root, ref_pointer) || instance.parent_uri)
-            )
-            validate_instance(subinstance, &block)
-            return
-          end
-        end
-
-        ref_uri = join_uri(instance.parent_uri, ref)
+        ref_uri = join_uri(instance.base_uri, ref)
 
+        ref_uri_pointer = ''
         if valid_json_pointer?(ref_uri.fragment)
-          ref_pointer = Hana::Pointer.new(URI.decode_www_form_component(ref_uri.fragment))
-          ref_root = resolve_ref(ref_uri)
-          ref_object = child(ref_root)
-          subinstance = instance.merge(
-            schema: ref_pointer.eval(ref_root),
-            schema_pointer: ref_uri.fragment,
-            parent_uri: (pointer_uri(ref_root, ref_pointer) || ref_uri)
-          )
-          ref_object.validate_instance(subinstance, &block)
-        elsif id = ids[ref_uri.to_s]
-          subinstance = instance.merge(
-            schema: id.fetch(:schema),
-            schema_pointer: id.fetch(:pointer),
-            parent_uri: ref_uri
-          )
-          validate_instance(subinstance, &block)
+          ref_uri_pointer = ref_uri.fragment
+          ref_uri.fragment = nil
+        end
+
+        ref_object = if ids.key?(ref_uri) || ref_uri.to_s == @base_uri.to_s
+          self
         else
-          ref_root = resolve_ref(ref_uri)
-          ref_object = child(ref_root)
-          id = ref_object.ids[ref_uri.to_s] || { schema: ref_root, pointer: '' }
-          subinstance = instance.merge(
-            schema: id.fetch(:schema),
-            schema_pointer: id.fetch(:pointer),
-            parent_uri: ref_uri
-          )
-          ref_object.validate_instance(subinstance, &block)
+          child(resolve_ref(ref_uri), base_uri: ref_uri)
+        end
+
+        ref_schema, ref_schema_pointer = ref_object.ids[ref_uri] || [ref_object.root, '']
+
+        ref_uri_pointer_parts = Hana::Pointer.parse(URI.decode_www_form_component(ref_uri_pointer))
+        schema, base_uri = ref_uri_pointer_parts.reduce([ref_schema, ref_uri]) do |(obj, uri), token|
+          if obj.is_a?(Array)
+            [obj.fetch(token.to_i), uri]
+          else
+            [obj.fetch(token), join_uri(uri, obj[id_keyword])]
+          end
         end
+
+        subinstance = instance.merge(
+          schema: schema,
+          schema_pointer: "#{ref_schema_pointer}#{ref_uri_pointer}",
+          base_uri: base_uri
+        )
+
+        ref_object.validate_instance(subinstance, &block)
       end
 
       def validate_custom_format(instance, custom_format)
@@ -340,8 +379,7 @@ module JSONSchemer
         validate_exclusive_minimum(instance, exclusive_minimum, minimum, &block) if exclusive_minimum
 
         if multiple_of
-          quotient = data / multiple_of.to_f
-          yield error(instance, 'multipleOf') unless quotient.floor == quotient
+          yield error(instance, 'multipleOf') unless BigDecimal(data.to_s).modulo(multiple_of).zero?
         end
       end
 
@@ -384,7 +422,7 @@ module JSONSchemer
 
         yield error(instance, 'maxLength') if max_length && data.size > max_length
         yield error(instance, 'minLength') if min_length && data.size < min_length
-        yield error(instance, 'pattern') if pattern && ecma_262_regex(pattern) !~ data
+        yield error(instance, 'pattern') if pattern && !resolve_regexp(pattern).match?(data)
         yield error(instance, 'format') if format? && spec_format?(format) && !valid_spec_format?(data, format)
 
         if content_encoding || content_media_type
@@ -487,10 +525,10 @@ module JSONSchemer
         dependencies = schema['dependencies']
         property_names = schema['propertyNames']
 
-        if instance.insert_property_defaults && properties
+        if instance.before_property_validation && properties
           properties.each do |property, property_schema|
-            if !data.key?(property) && property_schema.is_a?(Hash) && property_schema.key?('default')
-              data[property] = property_schema.fetch('default').clone
+            instance.before_property_validation.each do |hook|
+              hook.call(data, property, property_schema, schema)
             end
           end
         end
@@ -499,7 +537,8 @@ module JSONSchemer
           dependencies.each do |key, value|
             next unless data.key?(key)
             subschema = value.is_a?(Array) ? { 'required' => value } : value
-            subinstance = instance.merge(schema: subschema, schema_pointer: "#{instance.schema_pointer}/dependencies/#{key}")
+            escaped_key = escape_json_pointer_token(key)
+            subinstance = instance.merge(schema: subschema, schema_pointer: "#{instance.schema_pointer}/dependencies/#{escaped_key}")
             validate_instance(subinstance, &block)
           end
         end
@@ -513,6 +552,8 @@ module JSONSchemer
 
         regex_pattern_properties = nil
         data.each do |key, value|
+          escaped_key = escape_json_pointer_token(key)
+
           unless property_names.nil?
             subinstance = instance.merge(
               data: key,
@@ -527,9 +568,9 @@ module JSONSchemer
           if properties && properties.key?(key)
             subinstance = instance.merge(
               data: value,
-              data_pointer: "#{instance.data_pointer}/#{key}",
+              data_pointer: "#{instance.data_pointer}/#{escaped_key}",
               schema: properties[key],
-              schema_pointer: "#{instance.schema_pointer}/properties/#{key}"
+              schema_pointer: "#{instance.schema_pointer}/properties/#{escaped_key}"
             )
             validate_instance(subinstance, &block)
             matched_key = true
@@ -537,15 +578,16 @@ module JSONSchemer
 
           if pattern_properties
             regex_pattern_properties ||= pattern_properties.map do |pattern, property_schema|
-              [pattern, ecma_262_regex(pattern), property_schema]
+              [pattern, resolve_regexp(pattern), property_schema]
             end
             regex_pattern_properties.each do |pattern, regex, property_schema|
+              escaped_pattern = escape_json_pointer_token(pattern)
               if regex.match?(key)
                 subinstance = instance.merge(
                   data: value,
-                  data_pointer: "#{instance.data_pointer}/#{key}",
+                  data_pointer: "#{instance.data_pointer}/#{escaped_key}",
                   schema: property_schema,
-                  schema_pointer: "#{instance.schema_pointer}/patternProperties/#{pattern}"
+                  schema_pointer: "#{instance.schema_pointer}/patternProperties/#{escaped_pattern}"
                 )
                 validate_instance(subinstance, &block)
                 matched_key = true
@@ -558,34 +600,36 @@ module JSONSchemer
           unless additional_properties.nil?
             subinstance = instance.merge(
               data: value,
-              data_pointer: "#{instance.data_pointer}/#{key}",
+              data_pointer: "#{instance.data_pointer}/#{escaped_key}",
               schema: additional_properties,
               schema_pointer: "#{instance.schema_pointer}/additionalProperties"
             )
             validate_instance(subinstance, &block)
           end
         end
+
+        if instance.after_property_validation && properties
+          properties.each do |property, property_schema|
+            instance.after_property_validation.each do |hook|
+              hook.call(data, property, property_schema, schema)
+            end
+          end
+        end
       end
 
       def safe_strict_decode64(data)
         Base64.strict_decode64(data)
-      rescue ArgumentError => e
-        raise e unless e.message == 'invalid base64'
+      rescue ArgumentError
         nil
       end
 
-      def ecma_262_regex(pattern)
-        @ecma_262_regex ||= {}
-        @ecma_262_regex[pattern] ||= Regexp.new(
-          Regexp::Scanner.scan(pattern).map do |type, token, text|
-            type == :anchor ? RUBY_REGEX_ANCHORS_TO_ECMA_262.fetch(token, text) : text
-          end.join
-        )
+      def escape_json_pointer_token(token)
+        token.gsub(JSON_POINTER_TOKEN_ESCAPE_REGEX, JSON_POINTER_TOKEN_ESCAPE_CHARS)
       end
 
       def join_uri(a, b)
         b = URI.parse(b) if b
-        if a && b && a.relative? && b.relative?
+        uri = if a && b && a.relative? && b.relative?
           b
         elsif a && b
           URI.join(a, b)
@@ -594,34 +638,26 @@ module JSONSchemer
         else
           a
         end
+        uri.fragment = nil if uri.is_a?(URI) && uri.fragment == ''
+        uri
       end
 
-      def pointer_uri(schema, pointer)
-        uri_parts = nil
-        pointer.reduce(schema) do |obj, token|
-          next obj.fetch(token.to_i) if obj.is_a?(Array)
-          if obj_id = obj[id_keyword]
-            uri_parts ||= []
-            uri_parts << obj_id
-          end
-          obj.fetch(token)
-        end
-        uri_parts ? URI.join(*uri_parts) : nil
-      end
-
-      def resolve_ids(schema, ids = {}, parent_uri = nil, pointer = '')
+      def resolve_ids(schema, ids = {}, base_uri = @base_uri, pointer = '')
         if schema.is_a?(Array)
-          schema.each_with_index { |subschema, index| resolve_ids(subschema, ids, parent_uri, "#{pointer}/#{index}") }
+          schema.each_with_index { |subschema, index| resolve_ids(subschema, ids, base_uri, "#{pointer}/#{index}") }
         elsif schema.is_a?(Hash)
-          uri = join_uri(parent_uri, schema[id_keyword])
+          uri = join_uri(base_uri, schema[id_keyword])
           schema.each do |key, value|
-            if key == id_keyword && uri != parent_uri
-              ids[uri.to_s] = {
-                schema: schema,
-                pointer: pointer
-              }
+            case key
+            when id_keyword
+              ids[uri] ||= [schema, pointer]
+            when 'items', 'allOf', 'anyOf', 'oneOf', 'additionalItems', 'contains', 'additionalProperties', 'propertyNames', 'if', 'then', 'else', 'not'
+              resolve_ids(value, ids, uri, "#{pointer}/#{key}")
+            when 'properties', 'patternProperties', 'definitions', 'dependencies'
+              value.each do |subkey, subvalue|
+                resolve_ids(subvalue, ids, uri, "#{pointer}/#{key}/#{subkey}")
+              end
             end
-            resolve_ids(value, ids, uri, "#{pointer}/#{key}")
           end
         end
         ids
@@ -630,6 +666,10 @@ module JSONSchemer
       def resolve_ref(uri)
         ref_resolver.call(uri) || raise(InvalidRefResolution, uri.to_s)
       end
+
+      def resolve_regexp(pattern)
+        regexp_resolver.call(pattern) || raise(InvalidRegexpResolution, pattern)
+      end
     end
   end
 end