json-schema 2.7.0 → 3.0.0

data/lib/json-schema/attributes/oneof.rb

@@ -43,9 +43,9 @@ module JSON
         end
 
         if validation_error_count == one_of.length
-          message = "The property '#{build_fragment(fragments)}' of type #{data.class} did not match any of the required schemas"
+          message = "The property '#{build_fragment(fragments)}' of type #{type_of_data(data)} did not match any of the required schemas"
         else
-          message = "The property '#{build_fragment(fragments)}' of type #{data.class} matched more than one of the required schemas"
+          message = "The property '#{build_fragment(fragments)}' of type #{type_of_data(data)} matched more than one of the required schemas"
         end
 
         validation_error(processor, message, fragments, current_schema, self, options[:record_errors]) if message

data/lib/json-schema/attributes/properties.rb

@@ -62,13 +62,5 @@ module JSON
         end
       end
     end
-
-    class PropertiesV4Attribute < PropertiesAttribute
-      # draft4 relies on its own RequiredAttribute validation at a higher level, rather than
-      # as an attribute of individual properties.
-      def self.required?(schema, options)
-        options[:strict] == true
-      end
-    end
   end
 end

data/lib/json-schema/attributes/properties_v4.rb

@@ -0,0 +1,13 @@
+require 'json-schema/attributes/properties'
+
+module JSON
+  class Schema
+    class PropertiesV4Attribute < PropertiesAttribute
+      # draft4 relies on its own RequiredAttribute validation at a higher level, rather than
+      # as an attribute of individual properties.
+      def self.required?(schema, options)
+        options[:strict] == true
+      end
+    end
+  end
+end

data/lib/json-schema/attributes/ref.rb

@@ -22,23 +22,7 @@ module JSON
       def self.get_referenced_uri_and_schema(s, current_schema, validator)
         uri,schema = nil,nil
 
-        temp_uri = JSON::Util::URI.parse(s['$ref'])
-        temp_uri.defer_validation do
-          if temp_uri.relative?
-            temp_uri.merge!(current_schema.uri)
-            # Check for absolute path
-            path, fragment = s['$ref'].split("#")
-            if path.nil? || path == ''
-              temp_uri.path = current_schema.uri.path
-            elsif path[0,1] == "/"
-              temp_uri.path = Pathname.new(path).cleanpath.to_s
-            else
-              temp_uri.join!(path)
-            end
-            temp_uri.fragment = fragment
-          end
-          temp_uri.fragment = "" if temp_uri.fragment.nil? || temp_uri.fragment.empty?
-        end
+        temp_uri = JSON::Util::URI.normalize_ref(s['$ref'], current_schema.uri)
 
         # Grab the parent schema from the schema list
         schema_key = temp_uri.to_s.split("#")[0] + "#"

data/lib/json-schema/attributes/type.rb

@@ -68,16 +68,6 @@ module JSON
       def self.list_types(types)
         types.map { |type| type.is_a?(String) ? type : '(schema)' }.join(', ')
       end
-
-      # Lookup Schema type of given class instance
-      def self.type_of_data(data)
-        type, _ = TYPE_CLASS_MAPPINGS.map { |k,v| [k,v] }.sort_by { |(_, v)|
-          -Array(v).map { |klass| klass.ancestors.size }.max
-        }.find { |(_, v)|
-          Array(v).any? { |klass| data.kind_of?(klass) }
-        }
-        type
-      end
     end
   end
 end

data/lib/json-schema/attributes/type_v4.rb

@@ -17,7 +17,7 @@ module JSON
         message = format(
           "The property '%s' of type %s did not match %s: %s",
           build_fragment(fragments),
-          data.class,
+          type_of_data(data),
           union ? 'one or more of the following types' : 'the following type',
           types
         )

data/lib/json-schema/schema/reader.rb

@@ -118,7 +118,7 @@ module JSON
 
       def read_uri(uri)
         if accept_uri?(uri)
-          open(uri.to_s).read
+          URI.open(uri.to_s).read
         else
           raise JSON::Schema::ReadRefused.new(uri.to_s, :uri)
         end

data/lib/json-schema/schema/validator.rb

@@ -14,7 +14,8 @@ module JSON
       end
 
       def extend_schema_definition(schema_uri)
-        validator = JSON::Validator.validator_for(schema_uri)
+        warn "[DEPRECATION NOTICE] The preferred way to extend a Validator is by subclassing, rather than #extend_schema_definition. This method will be removed in version >= 3."
+        validator = JSON::Validator.validator_for_uri(schema_uri)
         @attributes.merge!(validator.attributes)
       end
 

data/lib/json-schema/schema.rb

@@ -21,7 +21,7 @@ module JSON
 
       # If there is a $schema on this schema, use it to determine which validator to use
       if @schema['$schema']
-        @validator = JSON::Validator.validator_for(@schema['$schema'])
+        @validator = JSON::Validator.validator_for_uri(@schema['$schema'])
       elsif parent_validator
         @validator = parent_validator
       else
@@ -52,7 +52,7 @@ module JSON
     def to_array_schema
       array_schema = { 'type' => 'array', 'items' => schema }
       array_schema['$schema'] = schema['$schema'] unless schema['$schema'].nil?
-      JSON::Schema.new(array_schema, uri, validator)
+      self.class.new(array_schema, uri, validator)
     end
 
     def to_s

data/lib/json-schema/util/array_set.rb

@@ -7,14 +7,14 @@ class ArraySet < Array
   def include?(obj)
     if !defined? @values
       @values = Set.new
-      self.each { |x| @values << convert_to_float_if_fixnum(x) }
+      self.each { |x| @values << convert_to_float_if_numeric(x) }
     end
-    @values.include?(convert_to_float_if_fixnum(obj))
+    @values.include?(convert_to_float_if_numeric(obj))
   end
 
   private
 
-  def convert_to_float_if_fixnum(value)
-    value.is_a?(Fixnum) ? value.to_f : value
+  def convert_to_float_if_numeric(value)
+    value.is_a?(Numeric) ? value.to_f : value
   end
 end

data/lib/json-schema/util/uri.rb

@@ -23,6 +23,43 @@ module JSON
         normalized_uri
       end
 
+      def self.absolutize_ref(ref, base)
+        ref_uri = strip_fragment(ref.dup)
+
+        return ref_uri if ref_uri.absolute?
+        return parse(base) if ref_uri.path.empty?
+
+        uri = strip_fragment(base.dup).join(ref_uri.path)
+        normalized_uri(uri)
+      end
+
+      def self.normalize_ref(ref, base)
+        ref_uri = parse(ref)
+        base_uri = parse(base)
+
+        ref_uri.defer_validation do
+          if ref_uri.relative?
+            ref_uri.merge!(base_uri)
+
+            # Check for absolute path
+            path, fragment = ref.to_s.split("#")
+            if path.nil? || path == ''
+              ref_uri.path = base_uri.path
+            elsif path[0,1] == "/"
+              ref_uri.path = Pathname.new(path).cleanpath.to_s
+            else
+              ref_uri.join!(path)
+            end
+
+            ref_uri.fragment = fragment
+          end
+
+          ref_uri.fragment = "" if ref_uri.fragment.nil? || ref_uri.fragment.empty?
+        end
+
+        ref_uri
+      end
+
       def self.parse(uri)
         if uri.is_a?(Addressable::URI)
           return uri.dup
@@ -63,6 +100,11 @@ module JSON
 
         Addressable::URI.unescape(parsed_uri.path)
       end
+
+      def self.clear_cache
+        @parse_cache = {}
+        @normalize_cache = {}
+      end
     end
   end
 end

data/lib/json-schema/util/uuid.rb

@@ -241,7 +241,6 @@ module JSON
     	alias urn to_uri
 
     	# Convert into 128-bit unsigned integer
-    	# Typically a Bignum instance, but can be a Fixnum.
     	def to_int
     		tmp = self.raw_bytes.unpack "C*"
     		tmp.inject do |r, i|

data/lib/json-schema/validator.rb

@@ -4,6 +4,7 @@ require 'bigdecimal'
 require 'digest/sha1'
 require 'date'
 require 'thread'
+require 'timeout'
 require 'yaml'
 
 require 'json-schema/schema/reader'
@@ -41,28 +42,24 @@ module JSON
       @options = @@default_opts.clone.merge(opts)
       @errors = []
 
-      validator = JSON::Validator.validator_for_name(@options[:version])
-      @options[:version] = validator
-      @options[:schema_reader] ||= JSON::Validator.schema_reader
+      configured_validator = self.class.validator_for_name(@options[:version])
+      @options[:schema_reader] ||= self.class.schema_reader
 
       @validation_options = @options[:record_errors] ? {:record_errors => true} : {}
       @validation_options[:insert_defaults] = true if @options[:insert_defaults]
       @validation_options[:strict] = true if @options[:strict] == true
       @validation_options[:clear_cache] = true if !@@cache_schemas || @options[:clear_cache]
 
-      @@mutex.synchronize { @base_schema = initialize_schema(schema_data) }
+      @@mutex.synchronize { @base_schema = initialize_schema(schema_data, configured_validator) }
       @original_data = data
       @data = initialize_data(data)
       @@mutex.synchronize { build_schemas(@base_schema) }
 
       # validate the schema, if requested
       if @options[:validate_schema]
-        if @base_schema.schema["$schema"]
-          base_validator = JSON::Validator.validator_for_name(@base_schema.schema["$schema"])
-        end
-        metaschema = base_validator ? base_validator.metaschema : validator.metaschema
         # Don't clear the cache during metaschema validation!
-        self.class.validate!(metaschema, @base_schema.schema, {:clear_cache => false})
+        meta_validator = self.class.new(@base_schema.validator.metaschema, @base_schema.schema, {:clear_cache => false})
+        meta_validator.validate
       end
 
       # If the :fragment option is set, try and validate against the fragment
@@ -73,38 +70,35 @@ module JSON
 
     def schema_from_fragment(base_schema, fragment)
       schema_uri = base_schema.uri
-      fragments = fragment.split("/")
+      fragments = fragment.split("/").map { |f| f.gsub('~0', '~').gsub('~1', '/') }
 
       # ensure the first element was a hash, per the fragment spec
       if fragments.shift != "#"
         raise JSON::Schema::SchemaError.new("Invalid fragment syntax in :fragment option")
       end
 
+      schema_fragment = base_schema.schema
       fragments.each do |f|
-        if base_schema.is_a?(JSON::Schema) #test if fragment is a JSON:Schema instance
-          if !base_schema.schema.has_key?(f)
-            raise JSON::Schema::SchemaError.new("Invalid fragment resolution for :fragment option")
-          end
-          base_schema = base_schema.schema[f]
-        elsif base_schema.is_a?(Hash)
-          if !base_schema.has_key?(f)
-            raise JSON::Schema::SchemaError.new("Invalid fragment resolution for :fragment option")
-          end
-          base_schema = JSON::Schema.new(base_schema[f],schema_uri,@options[:version])
-        elsif base_schema.is_a?(Array)
-          if base_schema[f.to_i].nil?
-            raise JSON::Schema::SchemaError.new("Invalid fragment resolution for :fragment option")
-          end
-          base_schema = JSON::Schema.new(base_schema[f.to_i],schema_uri,@options[:version])
-        else
-          raise JSON::Schema::SchemaError.new("Invalid schema encountered when resolving :fragment option")
+        case schema_fragment
+        when Hash
+          schema_fragment = schema_fragment[f]
+        when Array
+          schema_fragment = schema_fragment[f.to_i]
         end
       end
 
+      unless schema_fragment.is_a?(Hash)
+        raise JSON::Schema::SchemaError.new("Invalid fragment resolution for :fragment option")
+      end
+
+      schema = JSON::Schema.new(schema_fragment, schema_uri, base_schema.validator)
+
       if @options[:list]
-        base_schema.to_array_schema
+        schema.to_array_schema
+      elsif schema.is_a?(Hash)
+        JSON::Schema.new(schema, schema_uri, @options[:version])
       else
-        base_schema
+        schema
       end
     end
 
@@ -123,33 +117,25 @@ module JSON
       end
     ensure
       if @validation_options[:clear_cache] == true
-        Validator.clear_cache
+        self.class.clear_cache
       end
       if @validation_options[:insert_defaults]
-        JSON::Validator.merge_missing_values(@data, @original_data)
+        self.class.merge_missing_values(@data, @original_data)
       end
     end
 
     def load_ref_schema(parent_schema, ref)
-      schema_uri = absolutize_ref_uri(ref, parent_schema.uri)
+      schema_uri = JSON::Util::URI.absolutize_ref(ref, parent_schema.uri)
       return true if self.class.schema_loaded?(schema_uri)
 
+      validator = self.class.validator_for_uri(schema_uri, false)
+      schema_uri = JSON::Util::URI.file_uri(validator.metaschema) if validator
+
       schema = @options[:schema_reader].read(schema_uri)
       self.class.add_schema(schema)
       build_schemas(schema)
     end
 
-    def absolutize_ref_uri(ref, parent_schema_uri)
-      ref_uri = JSON::Util::URI.strip_fragment(ref)
-
-      return ref_uri if ref_uri.absolute?
-      # This is a self reference and thus the schema does not need to be re-loaded
-      return parent_schema_uri if ref_uri.path.empty?
-
-      uri = JSON::Util::URI.strip_fragment(parent_schema_uri.dup)
-      Util::URI.normalized_uri(uri.join(ref_uri.path))
-    end
-
     # Build all schemas with IDs, mapping out the namespace
     def build_schemas(parent_schema)
       schema = parent_schema.schema
@@ -225,7 +211,7 @@ module JSON
         schema_uri = parent_schema.uri.dup
         schema = JSON::Schema.new(obj, schema_uri, parent_schema.validator)
         if obj['id']
-          Validator.add_schema(schema)
+          self.class.add_schema(schema)
         end
         build_schemas(schema)
       end
@@ -258,10 +244,14 @@ module JSON
       end
 
       def validate!(schema, data,opts={})
-        validator = JSON::Validator.new(schema, data, opts)
+        validator = new(schema, data, opts)
         validator.validate
       end
-      alias_method 'validate2', 'validate!'
+
+      def validate2(schema, data, opts={})
+        warn "[DEPRECATION NOTICE] JSON::Validator#validate2 has been replaced by JSON::Validator#validate! and will be removed in version >= 3. Please use the #validate! method instead."
+        validate!(schema, data, opts)
+      end
 
       def validate_json!(schema, data, opts={})
         validate!(schema, data, opts.merge(:json => true))
@@ -277,7 +267,7 @@ module JSON
 
       def fully_validate_schema(schema, opts={})
         data = schema
-        schema = JSON::Validator.validator_for_name(opts[:version]).metaschema
+        schema = validator_for_name(opts[:version]).metaschema
         fully_validate(schema, data, opts)
       end
 
@@ -299,6 +289,7 @@ module JSON
 
       def clear_cache
         @@schemas = {}
+        JSON::Util::URI.clear_cache
       end
 
       def schemas
@@ -337,28 +328,34 @@ module JSON
         @@default_validator
       end
 
-      def validator_for_uri(schema_uri)
+      def validator_for_uri(schema_uri, raise_not_found=true)
         return default_validator unless schema_uri
         u = JSON::Util::URI.parse(schema_uri)
         validator = validators["#{u.scheme}://#{u.host}#{u.path}"]
-        if validator.nil?
+        if validator.nil? && raise_not_found
           raise JSON::Schema::SchemaError.new("Schema not found: #{schema_uri}")
         else
           validator
         end
       end
 
-      def validator_for_name(schema_name)
+      def validator_for_name(schema_name, raise_not_found=true)
         return default_validator unless schema_name
-        validator = validators_for_names([schema_name]).first
-        if validator.nil?
+        schema_name = schema_name.to_s
+        validator = validators.values.detect do |v|
+          Array(v.names).include?(schema_name)
+        end
+        if validator.nil? && raise_not_found
           raise JSON::Schema::SchemaError.new("The requested JSON schema version is not supported")
         else
           validator
         end
       end
 
-      alias_method :validator_for, :validator_for_uri
+      def validator_for(schema_uri)
+        warn "[DEPRECATION NOTICE] JSON::Validator#validator_for has been replaced by JSON::Validator#validator_for_uri and will be removed in version >= 3. Please use the #validator_for_uri method instead."
+        validator_for_uri(schema_uri)
+      end
 
       def register_validator(v)
         @@validators["#{v.uri.scheme}://#{v.uri.host}#{v.uri.path}"] = v
@@ -368,21 +365,24 @@ module JSON
         @@default_validator = v
       end
 
-      def register_format_validator(format, validation_proc, versions = ["draft1", "draft2", "draft3", "draft4", nil])
+      def register_format_validator(format, validation_proc, versions = (@@validators.flat_map{ |k, v| v.names.first } + [nil]))
         custom_format_validator = JSON::Schema::CustomFormat.new(validation_proc)
-        validators_for_names(versions).each do |validator|
+        versions.each do |version|
+          validator = validator_for_name(version)
           validator.formats[format.to_s] = custom_format_validator
         end
       end
 
-      def deregister_format_validator(format, versions = ["draft1", "draft2", "draft3", "draft4", nil])
-        validators_for_names(versions).each do |validator|
+      def deregister_format_validator(format, versions = (@@validators.flat_map{ |k, v| v.names.first } + [nil]))
+        versions.each do |version|
+          validator = validator_for_name(version)
           validator.formats[format.to_s] = validator.default_formats[format.to_s]
         end
       end
 
-      def restore_default_formats(versions = ["draft1", "draft2", "draft3", "draft4", nil])
-        validators_for_names(versions).each do |validator|
+      def restore_default_formats(versions = (@@validators.flat_map{ |k, v| v.names.first } + [nil]))
+        versions.each do |version|
+          validator = validator_for_name(version)
           validator.formats = validator.default_formats.clone
         end
       end
@@ -487,22 +487,6 @@ module JSON
           @@serializer = lambda{|o| YAML.dump(o) }
         end
       end
-
-      private
-
-      def validators_for_names(names)
-        names = names.map { |name| name.to_s }
-        [].tap do |memo|
-          validators.each do |_, validator|
-            if (validator.names & names).any?
-              memo << validator
-            end
-          end
-          if names.include?('')
-            memo << default_validator
-          end
-        end
-      end
     end
 
     private
@@ -527,16 +511,16 @@ module JSON
       @@fake_uuid_generator.call(schema)
     end
 
-    def initialize_schema(schema)
+    def initialize_schema(schema, default_validator)
       if schema.is_a?(String)
         begin
           # Build a fake URI for this
           schema_uri = JSON::Util::URI.parse(fake_uuid(schema))
-          schema = JSON::Schema.new(JSON::Validator.parse(schema), schema_uri, @options[:version])
+          schema = JSON::Schema.new(JSON::Validator.parse(schema), schema_uri, default_validator)
           if @options[:list] && @options[:fragment].nil?
             schema = schema.to_array_schema
           end
-          Validator.add_schema(schema)
+          self.class.add_schema(schema)
         rescue JSON::Schema::JsonParseError
           # Build a uri for it
           schema_uri = Util::URI.normalized_uri(schema)
@@ -548,13 +532,13 @@ module JSON
               schema = schema.to_array_schema
             end
 
-            Validator.add_schema(schema)
+            self.class.add_schema(schema)
           else
             schema = self.class.schema_for_uri(schema_uri)
             if @options[:list] && @options[:fragment].nil?
               schema = schema.to_array_schema
               schema.uri = JSON::Util::URI.parse(fake_uuid(serialize(schema.schema)))
-              Validator.add_schema(schema)
+              self.class.add_schema(schema)
             end
             schema
           end
@@ -562,11 +546,11 @@ module JSON
       elsif schema.is_a?(Hash)
         schema_uri = JSON::Util::URI.parse(fake_uuid(serialize(schema)))
         schema = JSON::Schema.stringify(schema)
-        schema = JSON::Schema.new(schema, schema_uri, @options[:version])
+        schema = JSON::Schema.new(schema, schema_uri, default_validator)
         if @options[:list] && @options[:fragment].nil?
           schema = schema.to_array_schema
         end
-        Validator.add_schema(schema)
+        self.class.add_schema(schema)
       else
         raise JSON::Schema::SchemaParseError, "Invalid schema - must be either a string or a hash"
       end
@@ -577,18 +561,18 @@ module JSON
     def initialize_data(data)
       if @options[:parse_data]
         if @options[:json]
-          data = JSON::Validator.parse(data)
+          data = self.class.parse(data)
         elsif @options[:uri]
           json_uri = Util::URI.normalized_uri(data)
-          data = JSON::Validator.parse(custom_open(json_uri))
+          data = self.class.parse(custom_open(json_uri))
         elsif data.is_a?(String)
           begin
-            data = JSON::Validator.parse(data)
+            data = self.class.parse(data)
           rescue JSON::Schema::JsonParseError
             begin
               json_uri = Util::URI.normalized_uri(data)
-              data = JSON::Validator.parse(custom_open(json_uri))
-            rescue JSON::Schema::JsonLoadError
+              data = self.class.parse(custom_open(json_uri))
+            rescue JSON::Schema::JsonLoadError, JSON::Schema::UriError
               # Silently discard the error - use the data as-is
             end
           end
@@ -601,7 +585,7 @@ module JSON
       uri = Util::URI.normalized_uri(uri) if uri.is_a?(String)
       if uri.absolute? && Util::URI::SUPPORTED_PROTOCOLS.include?(uri.scheme)
         begin
-          open(uri.to_s).read
+          URI.open(uri.to_s).read
         rescue OpenURI::HTTPError, Timeout::Error => e
           raise JSON::Schema::JsonLoadError, e.message
         end

data/lib/json-schema/validators/draft6.rb

@@ -0,0 +1,57 @@
+require 'json-schema/schema/validator'
+
+module JSON
+  class Schema
+
+    class Draft6 < Validator
+      def initialize
+        super
+        @attributes = {
+          "type" => JSON::Schema::TypeV4Attribute,
+          "allOf" => JSON::Schema::AllOfAttribute,
+          "anyOf" => JSON::Schema::AnyOfAttribute,
+          "oneOf" => JSON::Schema::OneOfAttribute,
+          "not" => JSON::Schema::NotAttribute,
+          "disallow" => JSON::Schema::DisallowAttribute,
+          "format" => JSON::Schema::FormatAttribute,
+          "maximum" => JSON::Schema::MaximumAttribute,
+          "minimum" => JSON::Schema::MinimumAttribute,
+          "minItems" => JSON::Schema::MinItemsAttribute,
+          "maxItems" => JSON::Schema::MaxItemsAttribute,
+          "minProperties" => JSON::Schema::MinPropertiesAttribute,
+          "maxProperties" => JSON::Schema::MaxPropertiesAttribute,
+          "uniqueItems" => JSON::Schema::UniqueItemsAttribute,
+          "minLength" => JSON::Schema::MinLengthAttribute,
+          "maxLength" => JSON::Schema::MaxLengthAttribute,
+          "multipleOf" => JSON::Schema::MultipleOfAttribute,
+          "enum" => JSON::Schema::EnumAttribute,
+          "properties" => JSON::Schema::PropertiesV4Attribute,
+          "required" => JSON::Schema::RequiredAttribute,
+          "pattern" => JSON::Schema::PatternAttribute,
+          "patternProperties" => JSON::Schema::PatternPropertiesAttribute,
+          "additionalProperties" => JSON::Schema::AdditionalPropertiesAttribute,
+          "items" => JSON::Schema::ItemsAttribute,
+          "additionalItems" => JSON::Schema::AdditionalItemsAttribute,
+          "dependencies" => JSON::Schema::DependenciesV4Attribute,
+          "extends" => JSON::Schema::ExtendsAttribute,
+          "const" => JSON::Schema::ConstAttribute,
+          "$ref" => JSON::Schema::RefAttribute
+        }
+        @default_formats = {
+          'date-time' => DateTimeV4Format,
+          'ipv4' => IP4Format,
+          'ipv6' => IP6Format,
+          'uri' => UriFormat
+        }
+        @formats = @default_formats.clone
+        @uri = JSON::Util::URI.parse("http://json-schema.org/draft/schema#")
+        @names = ["draft6", "http://json-schema.org/draft/schema#"]
+        @metaschema_name = "draft-06.json"
+      end
+
+      JSON::Validator.register_validator(self.new)
+      JSON::Validator.register_default_validator(self.new)
+    end
+
+  end
+end

data/lib/json-schema/validators/hyper-draft3.rb

@@ -0,0 +1,13 @@
+module JSON
+  class Schema
+
+    class HyperDraft3 < Draft3
+      def initialize
+        super
+        @uri = JSON::Util::URI.parse("http://json-schema.org/draft-03/hyper-schema#")
+      end
+
+      JSON::Validator.register_validator(self.new)
+    end
+  end
+end

data/lib/json-schema/validators/hyper-draft6.rb

@@ -0,0 +1,13 @@
+module JSON
+  class Schema
+
+    class HyperDraft6 < Draft6
+      def initialize
+        super
+        @uri = JSON::Util::URI.parse("http://json-schema.org/draft-06/hyper-schema#")
+      end
+
+      JSON::Validator.register_validator(self.new)
+    end
+  end
+end

data/lib/json-schema.rb

@@ -14,6 +14,5 @@ require 'json-schema/schema'
 require 'json-schema/schema/reader'
 require 'json-schema/validator'
 
-Dir[File.join(File.dirname(__FILE__), "json-schema/attributes/*.rb")].each {|file| require file }
-Dir[File.join(File.dirname(__FILE__), "json-schema/attributes/formats/*.rb")].each {|file| require file }
+Dir[File.join(File.dirname(__FILE__), "json-schema/attributes/**/*.rb")].each {|file| require file }
 Dir[File.join(File.dirname(__FILE__), "json-schema/validators/*.rb")].sort!.each {|file| require file }