RubyGems - json-schema - Versions diffs - 2.4.1 → 2.5.0 - Mend

json-schema 2.4.1 → 2.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (88) hide show

checksums.yaml +6 -14
data/README.textile +58 -7
data/lib/json-schema.rb +3 -1
data/lib/json-schema/attributes/additionalitems.rb +14 -11
data/lib/json-schema/attributes/additionalproperties.rb +33 -43
data/lib/json-schema/attributes/anyof.rb +4 -0
data/lib/json-schema/attributes/dependencies.rb +31 -19
data/lib/json-schema/attributes/disallow.rb +2 -3
data/lib/json-schema/attributes/divisibleby.rb +11 -7
data/lib/json-schema/attributes/enum.rb +14 -16
data/lib/json-schema/attributes/format.rb +4 -7
data/lib/json-schema/attributes/formats/date_time_v4.rb +5 -8
data/lib/json-schema/attributes/formats/ip.rb +41 -0
data/lib/json-schema/attributes/formats/uri.rb +10 -8
data/lib/json-schema/attributes/items.rb +15 -16
data/lib/json-schema/attributes/limit.rb +179 -0
data/lib/json-schema/attributes/maxdecimal.rb +7 -6
data/lib/json-schema/attributes/multipleof.rb +4 -11
data/lib/json-schema/attributes/not.rb +1 -1
data/lib/json-schema/attributes/oneof.rb +15 -6
data/lib/json-schema/attributes/pattern.rb +7 -6
data/lib/json-schema/attributes/patternproperties.rb +9 -12
data/lib/json-schema/attributes/properties.rb +55 -39
data/lib/json-schema/attributes/properties_optional.rb +13 -12
data/lib/json-schema/attributes/ref.rb +4 -4
data/lib/json-schema/attributes/required.rb +16 -13
data/lib/json-schema/attributes/type.rb +13 -18
data/lib/json-schema/attributes/type_v4.rb +11 -18
data/lib/json-schema/attributes/uniqueitems.rb +5 -7
data/lib/json-schema/schema.rb +8 -8
data/lib/json-schema/schema/#validator.rb# +37 -0
data/lib/json-schema/schema/reader.rb +113 -0
data/lib/json-schema/util/uri.rb +16 -0
data/lib/json-schema/validator.rb +123 -128
data/lib/json-schema/validators/draft1.rb +1 -1
data/lib/json-schema/validators/draft2.rb +1 -1
data/lib/json-schema/validators/draft3.rb +1 -1
data/lib/json-schema/validators/draft4.rb +1 -1
data/lib/json-schema/validators/hyper-draft4.rb +1 -1
data/test/schemas/address_microformat.json +18 -0
data/test/schemas/definition_schema.json +15 -0
data/test/schemas/ref john with spaces schema.json +11 -0
data/test/schemas/relative_definition_schema.json +8 -0
data/test/test_all_of_ref_schema.rb +12 -15
data/test/test_any_of_ref_schema.rb +7 -9
data/test/test_bad_schema_ref.rb +18 -12
data/test/test_common_test_suite.rb +45 -29
data/test/test_custom_format.rb +2 -3
data/test/test_definition.rb +15 -0
data/test/test_extended_schema.rb +25 -31
data/test/test_extends_and_additionalProperties.rb +23 -21
data/test/test_files_v3.rb +14 -23
data/test/test_fragment_resolution.rb +6 -7
data/test/test_fragment_validation_with_ref.rb +2 -8
data/test/test_full_validation.rb +2 -3
data/test/test_helper.rb +46 -1
data/test/test_initialize_data.rb +118 -0
data/test/test_jsonschema_draft1.rb +48 -600
data/test/test_jsonschema_draft2.rb +48 -699
data/test/test_jsonschema_draft3.rb +91 -861
data/test/test_jsonschema_draft4.rb +173 -812
data/test/test_list_option.rb +6 -7
data/test/{test_merge_misisng_values.rb → test_merge_missing_values.rb} +2 -3
data/test/test_minitems.rb +2 -4
data/test/test_one_of.rb +9 -19
data/test/test_ruby_schema.rb +5 -14
data/test/test_schema_loader.rb +74 -0
data/test/test_schema_type_attribute.rb +2 -3
data/test/test_schema_validation.rb +4 -5
data/test/test_stringify.rb +2 -3
data/test/test_uri_related.rb +67 -0
data/test/test_validator.rb +53 -0
metadata +129 -51
data/lib/json-schema/attributes/dependencies_v4.rb +0 -27
data/lib/json-schema/attributes/formats/ip4.rb +0 -20
data/lib/json-schema/attributes/formats/ip6.rb +0 -20
data/lib/json-schema/attributes/maximum.rb +0 -17
data/lib/json-schema/attributes/maximum_inclusive.rb +0 -17
data/lib/json-schema/attributes/maxitems.rb +0 -14
data/lib/json-schema/attributes/maxlength.rb +0 -16
data/lib/json-schema/attributes/maxproperties.rb +0 -14
data/lib/json-schema/attributes/minimum.rb +0 -17
data/lib/json-schema/attributes/minimum_inclusive.rb +0 -17
data/lib/json-schema/attributes/minitems.rb +0 -14
data/lib/json-schema/attributes/minlength.rb +0 -16
data/lib/json-schema/attributes/minproperties.rb +0 -14
data/lib/json-schema/attributes/properties_v4.rb +0 -58
data/lib/json-schema/uri/file.rb +0 -36

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

@@ -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 CHANGED

@@ -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 CHANGED

@@ -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 CHANGED

@@ -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 CHANGED

@@ -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 CHANGED

@@ -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 CHANGED

@@ -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# ADDED

@@ -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 ADDED

@@ -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 ADDED

@@ -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 CHANGED

@@ -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