json-schema 2.4.1 → 2.5.0

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

@@ -4,19 +4,20 @@ module JSON
   class Schema
     class PropertiesOptionalAttribute < Attribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
-        if data.is_a?(Hash)
-          current_schema.schema['properties'].each do |property,property_schema|
-            if (property_schema['optional'].nil? || property_schema['optional'] == false) && !data.has_key?(property.to_s)
-              message = "The property '#{build_fragment(fragments)}' did not contain a required property of '#{property}'"
-              validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
-            end
+        return unless data.is_a?(Hash)
 
-            if data.has_key?(property.to_s)
-              schema = JSON::Schema.new(property_schema,current_schema.uri,validator)
-              fragments << property
-              schema.validate(data[property],fragments,processor,options)
-              fragments.pop
-            end
+        schema = current_schema.schema
+        schema['properties'].each do |property, property_schema|
+          property = property.to_s
+
+          if !property_schema['optional'] && !data.key?(property)
+            message = "The property '#{build_fragment(fragments)}' did not contain a required property of '#{property}'"
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+          end
+
+          if data.has_key?(property)
+            expected_schema = JSON::Schema.new(property_schema, current_schema.uri, validator)
+            expected_schema.validate(data[property], fragments + [property], processor, options)
           end
         end
       end

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

@@ -21,7 +21,7 @@ module JSON
       def self.get_referenced_uri_and_schema(s, current_schema, validator)
         uri,schema = nil,nil
 
-        temp_uri = URI.parse(s['$ref'])
+        temp_uri = Addressable::URI.parse(s['$ref'])
         if temp_uri.relative?
           temp_uri = current_schema.uri.clone
           # Check for absolute path
@@ -31,7 +31,7 @@ module JSON
           elsif path[0,1] == "/"
             temp_uri.path = Pathname.new(path).cleanpath.to_s
           else
-            temp_uri = current_schema.uri.merge(path)
+            temp_uri = current_schema.uri.join(path)
           end
           temp_uri.fragment = s['$ref'].split("#")[1]
         end
@@ -40,7 +40,7 @@ module JSON
         # Grab the parent schema from the schema list
         schema_key = temp_uri.to_s.split("#")[0] + "#"
 
-        ref_schema = JSON::Validator.schemas[schema_key]
+        ref_schema = JSON::Validator.schema_for_uri(schema_key)
 
         if ref_schema
           # Perform fragment resolution to retrieve the appropriate level for the schema
@@ -49,7 +49,7 @@ module JSON
           fragment_path = ''
           fragments.each do |fragment|
             if fragment && fragment != ''
-              fragment = URI.unescape(fragment.gsub('~0', '~').gsub('~1', '/'))
+              fragment = Addressable::URI.unescape(fragment.gsub('~0', '~').gsub('~1', '/'))
               if target_schema.is_a?(Array)
                 target_schema = target_schema[fragment.to_i]
               else

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

@@ -4,19 +4,22 @@ module JSON
   class Schema
     class RequiredAttribute < Attribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
-        if data.is_a?(Hash)
-          current_schema.schema['required'].each do |property,property_schema|
-            if !data.has_key?(property.to_s)
-              prop_defaults = options[:insert_defaults] &&
-                              current_schema.schema['properties'] &&
-                              current_schema.schema['properties'][property] &&
-                              !current_schema.schema['properties'][property]["default"].nil? &&
-                              !current_schema.schema['properties'][property]["readonly"]
-              if !prop_defaults
-                message = "The property '#{build_fragment(fragments)}' did not contain a required property of '#{property}'"
-                validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
-              end
-            end
+        return unless data.is_a?(Hash)
+
+        schema = current_schema.schema
+        defined_properties = schema['properties']
+
+        schema['required'].each do |property, property_schema|
+          next if data.has_key?(property.to_s)
+          prop_defaults = options[:insert_defaults] &&
+                          defined_properties &&
+                          defined_properties[property] &&
+                          !defined_properties[property]["default"].nil? &&
+                          !defined_properties[property]["readonly"]
+
+          if !prop_defaults
+            message = "The property '#{build_fragment(fragments)}' did not contain a required property of '#{property}'"
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

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

@@ -32,7 +32,7 @@ module JSON
             pre_validation_error_count = validation_errors(processor).count
 
             begin
-              schema.validate(data,fragments,processor,options)
+              schema.validate(data,fragments,processor,options.merge(:disallow => false))
               valid = true
             rescue ValidationError
               # We don't care that these schemas don't validate - we only care that one validated
@@ -49,36 +49,31 @@ module JSON
           break if valid
         end
 
-        if (options[:disallow])
-          if valid
-            message = "The property '#{build_fragment(fragments)}' matched one or more of the following types:"
-            types.each {|type| message += type.is_a?(String) ? " #{type}," : " (schema)," }
-            message.chop!
-            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
-          end
+        if options[:disallow]
+          return if !valid
+          message = "The property '#{build_fragment(fragments)}' matched one or more of the following types: #{list_types(types)}"
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
         elsif !valid
           if union
-            message = "The property '#{build_fragment(fragments)}' of type #{type_of_data(data)} did not match one or more of the following types:"
-            types.each {|type| message += type.is_a?(String) ? " #{type}," : " (schema)," }
-            message.chop!
+            message = "The property '#{build_fragment(fragments)}' of type #{type_of_data(data)} did not match one or more of the following types: #{list_types(types)}"
             validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
             validation_errors(processor).last.sub_errors = union_errors
           else
-            message = "The property '#{build_fragment(fragments)}' of type #{type_of_data(data)} did not match the following type:"
-            types.each {|type| message += type.is_a?(String) ? " #{type}," : " (schema)," }
-            message.chop!
+            message = "The property '#{build_fragment(fragments)}' of type #{type_of_data(data)} did not match the following type: #{list_types(types)}"
             validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end
 
+      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, klass = TYPE_CLASS_MAPPINGS.map { |k,v| [k,v] }.sort_by { |i|
-          k,v = i
+        type, _ = TYPE_CLASS_MAPPINGS.map { |k,v| [k,v] }.sort_by { |(_, v)|
           -Array(v).map { |klass| klass.ancestors.size }.max
-        }.find { |i|
-          k,v = i
+        }.find { |(_, v)|
           Array(v).any? { |klass| data.kind_of?(klass) }
         }
         type

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

@@ -10,26 +10,19 @@ module JSON
           types = [types]
           union = false
         end
-        valid = false
 
-        types.each do |type|
-          valid = data_valid_for_type?(data, type)
-          break if valid
-        end
+        return if types.any? { |type| data_valid_for_type?(data, type) }
 
-        if !valid
-          if union
-            message = "The property '#{build_fragment(fragments)}' of type #{data.class} did not match one or more of the following types:"
-            types.each {|type| message += type.is_a?(String) ? " #{type}," : " (schema)," }
-            message.chop!
-            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
-          else
-            message = "The property '#{build_fragment(fragments)}' of type #{data.class} did not match the following type:"
-            types.each {|type| message += type.is_a?(String) ? " #{type}," : " (schema)," }
-            message.chop!
-            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
-          end
-        end
+        types = types.map { |type| type.is_a?(String) ? type : '(schema)' }.join(', ')
+        message = format(
+          "The property '%s' of type %s did not match %s: %s",
+          build_fragment(fragments),
+          data.class,
+          union ? 'one or more of the following types' : 'the following type',
+          types
+        )
+
+        validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
       end
     end
   end

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

@@ -4,13 +4,11 @@ module JSON
   class Schema
     class UniqueItemsAttribute < Attribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
-        if data.is_a?(Array)
-          d = data.clone
-          dupes = d.uniq!
-          if dupes
-            message = "The property '#{build_fragment(fragments)}' contained duplicated array values"
-            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
-          end
+        return unless data.is_a?(Array)
+
+        if data.clone.uniq!
+          message = "The property '#{build_fragment(fragments)}' contained duplicated array values"
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
         end
       end
     end

data/lib/json-schema/schema.rb

@@ -6,15 +6,14 @@ module JSON
     attr_accessor :schema, :uri, :validator
 
     def initialize(schema,uri,parent_validator=nil)
-      @schema = self.class.stringify(schema)
+      @schema = schema
       @uri = uri
 
       # If there is an ID on this schema, use it to generate the URI
       if @schema['id'] && @schema['id'].kind_of?(String)
-        temp_uri = URI.parse(@schema['id'])
+        temp_uri = Addressable::URI.parse(@schema['id'])
         if temp_uri.relative?
-          uri = uri.merge(@schema['id'])
-          temp_uri = uri
+          temp_uri = uri.join(temp_uri)
         end
         @uri = temp_uri
       end
@@ -49,10 +48,11 @@ module JSON
       end
     end
 
-    def base_uri
-      parts = @uri.to_s.split('/')
-      parts.pop
-      parts.join('/') + '/'
+    # @return [JSON::Schema] a new schema matching an array whose items all match this schema.
+    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)
     end
 
     def to_s

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

@@ -0,0 +1,37 @@
+
+module JSON
+  class Schema
+    class Validator
+      attr_accessor :attributes, :formats, :uri, :names
+      attr_reader :default_formats
+
+      def initialize()
+        @attributes = {}
+        @formats = {}
+        @default_formats = {}
+        @uri = nil
+        @names = []
+        @metaschema_name = ''
+      end
+
+      def extend_schema_definition(schema_uri)
+        validator = JSON::Validator.validator_for(schema_uri)
+        @attributes.merge!(validator.attributes)
+      end
+
+      def validate(current_schema, data, fragments, processor, options = {})
+        current_schema.schema.each do |attr_name,attribute|
+          if @attributes.has_key?(attr_name.to_s)
+            @attributes[attr_name.to_s].validate(current_schema, data, fragments, processor, self, options)
+          end
+        end
+        data
+      end
+
+      def metaschema
+        resources = File.expand_path('../../../../resources', __FILE__)
+        File.join(resources, @metaschema_name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+require 'open-uri'
+require 'addressable/uri'
+require 'pathname'
+
+module JSON
+  class Schema
+    # Raised by {JSON::Schema::Reader} when one of its settings indicate
+    # a schema should not be readed.
+    class ReadRefused < StandardError
+      # @return [String] the requested schema location which was refused
+      attr_reader :location
+
+      # @return [Symbol] either +:uri+ or +:file+
+      attr_reader :type
+
+      def initialize(location, type)
+        @location = location
+        @type = type
+        super("Read of #{type == :uri ? 'URI' : type} at #{location} refused!")
+      end
+    end
+
+    # When an unregistered schema is encountered, the {JSON::Schema::Reader} is
+    # used to fetch its contents and register it with the {JSON::Validator}.
+    #
+    # This default reader will read schemas from the filesystem or from a URI.
+    class Reader
+      # The behavior of the schema reader can be controlled by providing
+      # callbacks to determine whether to permit reading referenced schemas.
+      # The options +accept_uri+ and +accept_file+ should be procs which
+      # accept a +URI+ or +Pathname+ object, and return a boolean value
+      # indicating whether to read the referenced schema.
+      #
+      # URIs using the +file+ scheme will be normalized into +Pathname+ objects
+      # and passed to the +accept_file+ callback.
+      #
+      # @param options [Hash]
+      # @option options [Boolean, #call] accept_uri (true)
+      # @option options [Boolean, #call] accept_file (true)
+      #
+      # @example Reject all unregistered schemas
+      #   JSON::Validator.schema_reader = JSON::Schema::Reader.new(
+      #     :accept_uri => false,
+      #     :accept_file => false
+      #   )
+      #
+      # @example Only permit URIs from certain hosts
+      #   JSON::Validator.schema_reader = JSON::Schema::Reader.new(
+      #     :accept_file => false,
+      #     :accept_uri => proc { |uri| ['mycompany.com', 'json-schema.org'].include?(uri.host) }
+      #   )
+      def initialize(options = {})
+        @accept_uri = options.fetch(:accept_uri, true)
+        @accept_file = options.fetch(:accept_file, true)
+      end
+
+      # @param location [#to_s] The location from which to read the schema
+      # @return [JSON::Schema]
+      # @raise [JSON::Schema::ReadRefused] if +accept_uri+ or +accept_file+
+      #   indicated the schema should not be readed
+      # @raise [JSON::ParserError] if the schema was not a valid JSON object
+      def read(location)
+        uri  = Addressable::URI.parse(location.to_s)
+        body = if uri.scheme.nil? || uri.scheme == 'file'
+                 uri = Addressable::URI.convert_path(uri.path)
+                 read_file(Pathname.new(uri.path).expand_path)
+               else
+                 read_uri(uri)
+               end
+
+        JSON::Schema.new(JSON::Validator.parse(body), uri)
+      end
+
+      # @param uri [Addressable::URI]
+      # @return [Boolean]
+      def accept_uri?(uri)
+        if @accept_uri.respond_to?(:call)
+          @accept_uri.call(uri)
+        else
+          @accept_uri
+        end
+      end
+
+      # @param pathname [Pathname]
+      # @return [Boolean]
+      def accept_file?(pathname)
+        if @accept_file.respond_to?(:call)
+          @accept_file.call(pathname)
+        else
+          @accept_file
+        end
+      end
+
+      private
+
+      def read_uri(uri)
+        if accept_uri?(uri)
+          open(uri.to_s).read
+        else
+          raise JSON::Schema::ReadRefused.new(uri.to_s, :uri)
+        end
+      end
+
+      def read_file(pathname)
+        if accept_file?(pathname)
+          File.read(Addressable::URI.unescape(pathname.to_s))
+        else
+          raise JSON::Schema::ReadRefused.new(pathname.to_s, :file)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module JSON
+  module Util
+    module URI
+      def self.normalized_uri(uri)
+        uri = Addressable::URI.parse(uri) unless uri.is_a?(Addressable::URI)
+        # Check for absolute path
+        if uri.relative?
+          data = uri.to_s
+          data = "#{Dir.pwd}/#{data}" if data[0,1] != '/'
+          uri = Addressable::URI.convert_path(data)
+        end
+        uri
+      end
+    end
+  end
+end

data/lib/json-schema/validator.rb

@@ -1,4 +1,4 @@
-require 'uri'
+require 'addressable/uri'
 require 'open-uri'
 require 'pathname'
 require 'bigdecimal'
@@ -7,6 +7,7 @@ require 'date'
 require 'thread'
 require 'yaml'
 
+require 'json-schema/schema/reader'
 require 'json-schema/errors/schema_error'
 require 'json-schema/errors/json_parse_error'
 
@@ -24,7 +25,8 @@ module JSON
       :errors_as_objects => false,
       :insert_defaults => false,
       :clear_cache => true,
-      :strict => false
+      :strict => false,
+      :parse_data => true
     }
     @@validators = {}
     @@default_validator = nil
@@ -39,6 +41,7 @@ module JSON
 
       validator = JSON::Validator.validator_for_name(@options[:version])
       @options[:version] = validator
+      @options[:schema_reader] ||= JSON::Validator.schema_reader
 
       @validation_options = @options[:record_errors] ? {:record_errors => true} : {}
       @validation_options[:insert_defaults] = true if @options[:insert_defaults]
@@ -99,10 +102,12 @@ module JSON
           raise JSON::Schema::SchemaError.new("Invalid schema encountered when resolving :fragment option")
         end
       end
-      if @options[:list] #check if the schema is validating a list
-        base_schema.schema = schema_to_list(base_schema.schema)
+
+      if @options[:list]
+        base_schema.to_array_schema
+      else
+        base_schema
       end
-      base_schema
     end
 
     # Run a simple true/false validation of data against a schema
@@ -122,65 +127,50 @@ module JSON
       end
     end
 
+    def load_ref_schema(parent_schema, ref)
+      schema_uri = absolutize_ref_uri(ref, parent_schema.uri)
 
-    def load_ref_schema(parent_schema,ref)
-      uri = URI.parse(ref)
-      if uri.relative?
-        uri = parent_schema.uri.clone
+      return true if self.class.schema_loaded?(schema_uri)
 
-        # Check for absolute path
-        path = ref.split("#")[0]
+      schema = @options[:schema_reader].read(schema_uri)
+      self.class.add_schema(schema)
+      build_schemas(schema)
+    end
 
-        # This is a self reference and thus the schema does not need to be re-loaded
-        if path.nil? || path == ''
-          return
-        end
+    def absolutize_ref_uri(ref, parent_schema_uri)
+      ref_uri = Addressable::URI.parse(ref)
 
-        if path && path[0,1] == '/'
-          uri.path = Pathname.new(path).cleanpath.to_s
-        else
-          uri = parent_schema.uri.merge(path)
-        end
-        uri.fragment = ''
-      end
+      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?
 
-      if Validator.schemas[uri.to_s].nil?
-        schema = JSON::Schema.new(JSON::Validator.parse(open(uri.to_s).read), uri, @options[:version])
-        Validator.add_schema(schema)
-        build_schemas(schema)
-      end
+      uri = parent_schema_uri.clone
+      uri.fragment = ''
+      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
+
       # Build ref schemas if they exist
-      if parent_schema.schema["$ref"]
-        load_ref_schema(parent_schema, parent_schema.schema["$ref"])
-      end
-      if parent_schema.schema["extends"]
-        if parent_schema.schema["extends"].is_a?(String)
-          load_ref_schema(parent_schema, parent_schema.schema["extends"])
-        elsif parent_schema.schema["extends"].is_a?(Array)
-          parent_schema.schema["extends"].each do |type|
-            handle_schema(parent_schema, type)
-          end
-        end
+      if schema["$ref"]
+        load_ref_schema(parent_schema, schema["$ref"])
       end
 
-      # handle validations that always contain schemas
-      ["allOf", "anyOf", "oneOf", "not"].each do |key|
-        if parent_schema.schema.has_key?(key)
-          validations = parent_schema.schema[key]
-          validations = [validations] unless validations.is_a?(Array)
-          validations.each {|v| handle_schema(parent_schema, v) }
+      case schema["extends"]
+      when String
+        load_ref_schema(parent_schema, schema["extends"])
+      when Array
+        schema['extends'].each do |type|
+          handle_schema(parent_schema, type)
         end
       end
 
       # Check for schemas in union types
       ["type", "disallow"].each do |key|
-        if parent_schema.schema[key] && parent_schema.schema[key].is_a?(Array)
-          parent_schema.schema[key].each_with_index do |type,i|
+        if schema[key].is_a?(Array)
+          schema[key].each do |type|
             if type.is_a?(Hash)
               handle_schema(parent_schema, type)
             end
@@ -188,48 +178,42 @@ module JSON
         end
       end
 
-      # "definitions" are schemas in V4
-      if parent_schema.schema["definitions"]
-        parent_schema.schema["definitions"].each do |k,v|
-          handle_schema(parent_schema, v)
+      # Schema properties whose values are objects, the values of which
+      # are themselves schemas.
+      %w[definitions properties patternProperties].each do |key|
+        next unless value = schema[key]
+        value.each do |k, inner_schema|
+          handle_schema(parent_schema, inner_schema)
         end
       end
 
-      # All properties are schemas
-      if parent_schema.schema["properties"]
-        parent_schema.schema["properties"].each do |k,v|
-          handle_schema(parent_schema, v)
-        end
+      # Schema properties whose values are themselves schemas.
+      %w[additionalProperties additionalItems dependencies extends].each do |key|
+        next unless schema[key].is_a?(Hash)
+        handle_schema(parent_schema, schema[key])
       end
-      if parent_schema.schema["patternProperties"]
-        parent_schema.schema["patternProperties"].each do |k,v|
-          handle_schema(parent_schema, v)
+
+      # Schema properties whose values may be an array of schemas.
+      %w[allOf anyOf oneOf not].each do |key|
+        next unless value = schema[key]
+        Array(value).each do |inner_schema|
+          handle_schema(parent_schema, inner_schema)
         end
       end
 
       # Items are always schemas
-      if parent_schema.schema["items"]
-        items = parent_schema.schema["items"].clone
-        single = false
-        if !items.is_a?(Array)
-          items = [items]
-          single = true
-        end
-        items.each_with_index do |item,i|
+      if schema["items"]
+        items = schema["items"].clone
+        items = [items] unless items.is_a?(Array)
+
+        items.each do |item|
           handle_schema(parent_schema, item)
         end
       end
 
       # Convert enum to a ArraySet
-      if parent_schema.schema["enum"] && parent_schema.schema["enum"].is_a?(Array)
-        parent_schema.schema["enum"] = ArraySet.new(parent_schema.schema["enum"])
-      end
-
-      # Each of these might be schemas
-      ["additionalProperties", "additionalItems", "dependencies", "extends"].each do |key|
-        if parent_schema.schema[key].is_a?(Hash)
-          handle_schema(parent_schema, parent_schema.schema[key])
-        end
+      if schema["enum"].is_a?(Array)
+        schema["enum"] = ArraySet.new(schema["enum"])
       end
 
     end
@@ -238,7 +222,7 @@ module JSON
     def handle_schema(parent_schema, obj)
       if obj.is_a?(Hash)
         schema_uri = parent_schema.uri.clone
-        schema = JSON::Schema.new(obj,schema_uri,parent_schema.validator)
+        schema = JSON::Schema.new(obj, schema_uri, parent_schema.validator)
         if obj['id']
           Validator.add_schema(schema)
         end
@@ -309,6 +293,14 @@ module JSON
         fully_validate(schema, data, opts.merge(:uri => true))
       end
 
+      def schema_reader
+        @@schema_reader ||= JSON::Schema::Reader.new
+      end
+
+      def schema_reader=(reader)
+        @@schema_reader = reader
+      end
+
       def clear_cache
         @@schemas = {} if @@cache_schemas == false
       end
@@ -318,7 +310,22 @@ module JSON
       end
 
       def add_schema(schema)
-        @@schemas[schema.uri.to_s] = schema if @@schemas[schema.uri.to_s].nil?
+        @@schemas[schema_key_for(schema.uri)] ||= schema
+      end
+
+      def schema_for_uri(uri)
+        # We only store normalized uris terminated with fragment #, so we can try whether
+        # normalization can be skipped
+        @@schemas[uri] || @@schemas[schema_key_for(uri)]
+      end
+
+      def schema_loaded?(schema_uri)
+        !schema_for_uri(schema_uri).nil?
+      end
+
+      def schema_key_for(uri)
+        key = Util::URI.normalized_uri(uri).to_s
+        key.end_with?('#') ? key : "#{key}#"
       end
 
       def cache_schemas=(val)
@@ -336,7 +343,7 @@ module JSON
 
       def validator_for_uri(schema_uri)
         return default_validator unless schema_uri
-        u = URI.parse(schema_uri)
+        u = Addressable::URI.parse(schema_uri)
         validator = validators["#{u.scheme}://#{u.host}#{u.path}"]
         if validator.nil?
           raise JSON::Schema::SchemaError.new("Schema not found: #{schema_uri}")
@@ -412,7 +419,7 @@ module JSON
         else
           case @@json_backend.to_s
           when 'json'
-            JSON.parse(s)
+            JSON.parse(s, :quirks_mode => true)
           when 'yajl'
             json = StringIO.new(s)
             parser = Yajl::Parser.new
@@ -503,53 +510,45 @@ module JSON
       @@fake_uuid_generator.call(schema)
     end
 
-    def schema_to_list(schema)
-      new_schema = {"type" => "array", "items" => schema}
-      if !schema["$schema"].nil?
-        new_schema["$schema"] = schema["$schema"]
-      end
-
-      new_schema
-    end
-
     def initialize_schema(schema)
       if schema.is_a?(String)
         begin
           # Build a fake URI for this
-          schema_uri = URI.parse(fake_uuid(schema))
-          schema = JSON::Validator.parse(schema)
+          schema_uri = Addressable::URI.parse(fake_uuid(schema))
+          schema = JSON::Schema.new(JSON::Validator.parse(schema), schema_uri, @options[:version])
           if @options[:list] && @options[:fragment].nil?
-            schema = schema_to_list(schema)
+            schema = schema.to_array_schema
           end
-          schema = JSON::Schema.new(schema,schema_uri,@options[:version])
           Validator.add_schema(schema)
         rescue
           # Build a uri for it
-          schema_uri = normalized_uri(schema)
-          if Validator.schemas[schema_uri.to_s].nil?
-            schema = JSON::Validator.parse(open(schema_uri.to_s).read)
+          schema_uri = Util::URI.normalized_uri(schema)
+          if !self.class.schema_loaded?(schema_uri)
+            schema = @options[:schema_reader].read(schema_uri)
+            schema = JSON::Schema.stringify(schema)
+
             if @options[:list] && @options[:fragment].nil?
-              schema = schema_to_list(schema)
+              schema = schema.to_array_schema
             end
-            schema = JSON::Schema.new(schema,schema_uri,@options[:version])
+
             Validator.add_schema(schema)
           else
-            schema = Validator.schemas[schema_uri.to_s]
+            schema = self.class.schema_for_uri(schema_uri)
             if @options[:list] && @options[:fragment].nil?
-              schema = schema_to_list(schema.schema)
-              schema_uri = URI.parse(fake_uuid(serialize(schema)))
-              schema = JSON::Schema.new(schema, schema_uri, @options[:version])
+              schema = schema.to_array_schema
+              schema.uri = Addressable::URI.parse(fake_uuid(serialize(schema.schema)))
               Validator.add_schema(schema)
             end
             schema
           end
         end
       elsif schema.is_a?(Hash)
+        schema_uri = Addressable::URI.parse(fake_uuid(serialize(schema)))
+        schema = JSON::Schema.stringify(schema)
+        schema = JSON::Schema.new(schema, schema_uri, @options[:version])
         if @options[:list] && @options[:fragment].nil?
-          schema = schema_to_list(schema)
+          schema = schema.to_array_schema
         end
-        schema_uri = URI.parse(fake_uuid(serialize(schema)))
-        schema = JSON::Schema.new(schema,schema_uri,@options[:version])
         Validator.add_schema(schema)
       else
         raise "Invalid schema - must be either a string or a hash"
@@ -558,40 +557,36 @@ module JSON
       schema
     end
 
-
     def initialize_data(data)
-      if @options[:json]
-        data = JSON::Validator.parse(data)
-      elsif @options[:uri]
-        json_uri = normalized_uri(data)
-        data = JSON::Validator.parse(open(json_uri.to_s).read)
-      elsif data.is_a?(String)
-        begin
+      if @options[:parse_data]
+        if @options[:json]
           data = JSON::Validator.parse(data)
-        rescue
+        elsif @options[:uri]
+          json_uri = Util::URI.normalized_uri(data)
+          data = JSON::Validator.parse(custom_open(json_uri))
+        elsif data.is_a?(String)
           begin
-            json_uri = normalized_uri(data)
-            data = JSON::Validator.parse(open(json_uri.to_s).read)
+            data = JSON::Validator.parse(data)
           rescue
-            # Silently discard the error - the data will not change
+            begin
+              json_uri = Util::URI.normalized_uri(data)
+              data = JSON::Validator.parse(custom_open(json_uri))
+            rescue
+              # Silently discard the error - the data will not change
+            end
           end
         end
       end
       JSON::Schema.stringify(data)
     end
 
-    def normalized_uri(data)
-      uri = URI.parse(data)
-      if uri.relative?
-        # Check for absolute path
-        if data[0,1] == '/'
-          uri = URI.parse("file://#{data}")
-        else
-          uri = URI.parse("file://#{Dir.pwd}/#{data}")
-        end
+    def custom_open(uri)
+      uri = Util::URI.normalized_uri(uri) if uri.is_a?(String)
+      if uri.absolute? && uri.scheme != 'file'
+        open(uri.to_s).read
+      else
+        File.read(Addressable::URI.unescape(uri.path))
       end
-      uri
     end
-
   end
 end