json-schema 2.6.1 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 12af76aabf22ca3fd21620ba445eec49e02bb148
-  data.tar.gz: e337dd929041aa42efbda91fd360caf0cb854035
+  metadata.gz: f440a3f87c238f6b4a3ba8fb93818ae17affd9fc
+  data.tar.gz: 910c2401bf9e11a0d57dfe8e47086c876e7e48b4
 SHA512:
-  metadata.gz: aa0037193fa2bb35abc47c05d51ad54f2d7c6f185e04ecd16332ca3b1749e67439429a69a1dbf73c15de1aa31fa21c603ea5d626c4fd6d788d3a64d4e14fc75d
-  data.tar.gz: a73e2d48d350b12c6a2b2108027845c9063de99a61ace81b7a0120cb22f55a39b769cf90b11c91fa58fed780215f6b6e66eb8c0a9b8311806fa86f2dd51b7b2a
+  metadata.gz: dbf3e34a23275021b9cf6f9d9ccb5aa86956182411f55e93fa3cd29b30d24b01d18c30e191cb31dd5a1c71b780188b08cb261d7248e203bcfa74d9b1f104f273
+  data.tar.gz: a5311ed16954806392eabe157ccd92d9b54b3e20e228697c31bc0042f1455c0b7e4bff6a2b33db473a93116020fdcf9a6296e621cb55638287103142e54c3839

data/README.md

@@ -1,5 +1,5 @@
-![https://travis-ci.org/ruby-json-schema/json-schema](https://travis-ci.org/ruby-json-schema/json-schema.svg?branch=master)
-![https://codeclimate.com/github/ruby-json-schema/json-schema](https://codeclimate.com/github/ruby-json-schema/json-schema/badges/gpa.svg)
+[![Travis](https://travis-ci.org/ruby-json-schema/json-schema.svg?branch=master)](https://travis-ci.org/ruby-json-schema/json-schema)
+[![Code Climate](https://codeclimate.com/github/ruby-json-schema/json-schema/badges/gpa.svg)](https://codeclimate.com/github/ruby-json-schema/json-schema)
 
 Ruby JSON Schema Validator
 ==========================
@@ -42,10 +42,10 @@ $ gem build json-schema.gemspec
 $ gem install json-schema-2.5.2.gem
 ```
 
-Usage
+Validation
 -----
 
-Three base validation methods exist: 
+Three base validation methods exist:
 
 1. `validate`: returns a boolean on whether a validation attempt passes
 2. `validate!`: throws a `JSON::Schema::ValidationError` with an appropriate message/trace on where the validation failed
@@ -67,15 +67,15 @@ attribute in the schema and referencing the appropriate specification URI. Note
 that the `$schema` attribute takes precedence over the `:version` option during
 parsing and validation.
 
-### Validate Ruby objects against a Ruby schema
-
 For further information on json schema itself refer to <a
 href="http://spacetelescope.github.io/understanding-json-schema/">Understanding
 JSON Schema</a>.
 
-```rb
-require 'rubygems'
-require 'json-schema'
+Basic Usage
+--------------
+
+```ruby
+require "json-schema"
 
 schema = {
   "type" => "object",
@@ -85,279 +85,206 @@ schema = {
   }
 }
 
-data = {
-  "a" => 5
-}
-
-JSON::Validator.validate(schema, data)
-```
-
-### Validate a JSON string against a JSON schema file
-
-```rb
-require 'rubygems'
-require 'json-schema'
-
-JSON::Validator.validate('schema.json', '{"a" : 5}')
-```
-
-### Validate a list of objects against a schema that represents the individual objects
-
-```rb
-require 'rubygems'
-require 'json-schema'
-
-data = ['user','user','user']
-JSON::Validator.validate('user.json', data, :list => true)
-```
-
-### Strictly validate an object's properties
-
-With the `:strict` option, validation fails when an object contains properties
-that are not defined in the schema's property list or doesn't match the
-`additionalProperties` property. Furthermore, all properties are treated as
-`required` regardless of `required` properties set in the schema.
+#
+# validate ruby objects against a ruby schema
+#
 
-```rb
-require 'rubygems'
-require 'json-schema'
+# => true
+JSON::Validator.validate(schema, { "a" => 5 })
+# => false
+JSON::Validator.validate(schema, {})
 
-schema = {
-  "type" => "object",
-  "properties" => {
-    "a" => {"type" => "integer"},
-    "b" => {"type" => "integer"}
-  }
-}
+#
+# validate a json string against a json schema file
+#
 
-JSON::Validator.validate(schema, {"a" => 1, "b" => 2}, :strict => true)            # ==> true
-JSON::Validator.validate(schema, {"a" => 1, "b" => 2, "c" => 3}, :strict => true)  # ==> false
-JSON::Validator.validate(schema, {"a" => 1}, :strict => true)                      # ==> false
-```
+require "json"
+File.write("schema.json", JSON.dump(schema))
 
-### Catch a validation error and print it out
+# => true
+JSON::Validator.validate('schema.json', '{ "a": 5 }')
 
-```rb
-require 'rubygems'
-require 'json-schema'
-
-schema = {
-  "type" => "object",
-  "required" => ["a"],
-  "properties" => {
-    "a" => {"type" => "integer"}
-  }
-}
-
-data = {
-  "a" => "taco"
-}
+#
+# raise an error when validation fails
+#
 
+# => "The property '#/a' of type String did not match the following type: integer"
 begin
-  JSON::Validator.validate!(schema, data)
-rescue JSON::Schema::ValidationError
-  puts $!.message
+  JSON::Validator.validate!(schema, { "a" => "taco" })
+rescue JSON::Schema::ValidationError => e
+  e.message
 end
-```
-
-### Fully validate against a schema and catch all errors
-
-```rb
-require 'rubygems'
-require 'json-schema'
-
-schema = {
-  "type" => "object",
-  "required" => ["a","b"],
-  "properties" => {
-    "a" => {"type" => "integer"},
-    "b" => {"type" => "string"}
-  }
-}
-
-data = {
-  "a" => "taco"
-}
-
-errors = JSON::Validator.fully_validate(schema, data)
-
-# ["The property '#/a' of type String did not match the following type: integer in schema 03179a21-197e-5414-9611-e9f63e8324cd#", "The property '#/' did not contain a required property of 'b' in schema 03179a21-197e-5414-9611-e9f63e8324cd#"]
-```
-
-### Fully validate against a schema and catch all errors as objects
-
-```rb
-require 'rubygems'
-require 'json-schema'
-
-schema = {
-  "type" => "object",
-  "required" => ["a","b"],
-  "properties" => {
-    "a" => {"type" => "integer"},
-    "b" => {"type" => "string"}
-  }
-}
-
-data = {
-  "a" => "taco"
-}
 
-errors = JSON::Validator.fully_validate(schema, data, :errors_as_objects => true)
+#
+# return an array of error messages when validation fails
+#
 
-# [{:message=>"The property '#/a' of type String did not match the following type: integer in schema 03179a21-197e-5414-9611-e9f63e8324cd#", :schema=>#, :failed_attribute=>"Type", :fragment=>"#/a"}, {:message=>"The property '#/' did not contain a required property of 'b' in schema 03179a21-197e-5414-9611-e9f63e8324cd#", :schema=>#, :failed_attribute=>"Properties", :fragment=>"#/"}]
+# => ["The property '#/a' of type String did not match the following type: integer in schema 18a1ffbb-4681-5b00-bd15-2c76aee4b28f"]
+JSON::Validator.fully_validate(schema, { "a" => "taco" })
 ```
 
-### Validate against a fragment of a supplied schema
+Advanced Options
+-----------------
 
-```rb
-require 'rubygems'
-require 'json-schema'
+```ruby
+require "json-schema"
 
 schema = {
-  "type" => "object",
-  "required" => ["a","b"],
+  "type"=>"object",
+  "required" => ["a"],
   "properties" => {
-    "a" => {"type" => "integer"},
-    "b" => {"type" => "string"},
-    "c" => {
+    "a" => {
+      "type" => "integer",
+      "default" => 42
+    },
+    "b" => {
       "type" => "object",
       "properties" => {
-        "z" => {"type" => "integer"}
+        "x" => {
+          "type" => "integer"
+        }
       }
     }
   }
 }
 
-data = {
-  "z" => 1
-}
-
-JSON::Validator.validate(schema, data, :fragment => "#/properties/c")
-```
-
-### Validate a JSON object against a JSON schema object, while also validating the schema itself
-
-```rb
-require 'rubygems'
-require 'json-schema'
-
-schema = {
+#
+# with the `:list` option, a list can be validated against a schema that represents the individual objects
+#
+
+# => true
+JSON::Validator.validate(schema, [{"a" => 1}, {"a" => 2}, {"a" => 3}], :list => true)
+# => false
+JSON::Validator.validate(schema, [{"a" => 1}, {"a" => 2}, {"a" => 3}])
+
+#
+# with the `:errors_as_objects` option, `#fully_validate` returns errors as hashes instead of strings
+#
+
+# => [{:schema=>#<Addressable::URI:0x3ffa69cbeed8 URI:18a1ffbb-4681-5b00-bd15-2c76aee4b28f>, :fragment=>"#/a", :message=>"The property '#/a' of type String did not match the following type: integer in schema 18a1ffbb-4681-5b00-bd15-2c76aee4b28f", :failed_attribute=>"TypeV4"}]
+JSON::Validator.fully_validate(schema, { "a" => "taco" }, :errors_as_objects => true)
+
+#
+# with the `:strict` option, all properties are condisidered to have `"required": true` and all objects `"additionalProperties": false`
+#
+
+# => true
+JSON::Validator.validate(schema, { "a" => 1, "b" => { "x" => 2 } }, :strict => true)
+# => false
+JSON::Validator.validate(schema, { "a" => 1, "b" => { "x" => 2 }, "c" => 3 }, :strict => true)
+# => false
+JSON::Validator.validate(schema, { "a" => 1 }, :strict => true)
+
+#
+# with the `:fragment` option, only a fragment of the schema is used for validation
+#
+
+# => true
+JSON::Validator.validate(schema, { "x" => 1 }, :fragment => "#/properties/b")
+# => false
+JSON::Validator.validate(schema, { "x" => 1 })
+
+#
+# with the `:validate_schema` option, the schema is validated (against the json schema spec) before the json is validated (against the specified schema)
+#
+
+# => true
+JSON::Validator.validate(schema, { "a" => 1 }, :validate_schema => true)
+# => false
+JSON::Validator.validate({ "required" => true }, { "a" => 1 }, :validate_schema => true)
+
+#
+# with the `:insert_defaults` option, any undefined values in the json that have a default in the schema are replaced with the default before validation
+#
+
+# => true
+JSON::Validator.validate(schema, {}, :insert_defaults => true)
+# => false
+JSON::Validator.validate(schema, {})
+
+#
+# with the `:version` option, schemas conforming to older drafts of the json schema spec can be used
+#
+
+v2_schema = {
   "type" => "object",
-  "required" => ["a"],
   "properties" => {
-    "a" => {"type" => "integer", "required" => "true"}  # This will fail schema validation!
-  }
-}
-
-data = {
-  "a" => 5
-}
-
-JSON::Validator.validate(schema, data, :validate_schema => true)
-```
-
-### Validate a JSON object against a JSON schema object, while inserting default values from the schema
-
-With the `:insert_defaults` option set to true any missing property that has a
-default value specified in the schema will be inserted into the validated data.
-The inserted default value is validated hence catching a schema that specifies
-an invalid default value.
-
-```rb
-require 'rubygems'
-require 'json-schema'
-
-schema = {
-  "type" => "object",
-  "required" => ["a"],
-  "properties" => {
-    "a" => {"type" => "integer", "default" => 42},
-    "b" => {"type" => "integer"}
+    "a" => {
+      "type" => "integer"
+    }
   }
 }
 
-# Would not normally validate because "a" is missing and required by schema,
-# but "default" option allows insertion of valid default.
-data = {
-  "b" => 5
-}
+# => false
+JSON::Validator.validate(v2_schema, {}, :version => :draft2)
+# => true
+JSON::Validator.validate(v2_schema, {})
 
-JSON::Validator.validate(schema, data)
-# false
-
-JSON::Validator.validate(schema, data, :insert_defaults => true)
-# true
-# data = {
-#   "a" => 42,
-#   "b" => 5
-# }
-```
+#
+# with the `:parse_data` option set to false, the json must be a parsed ruby object (not a json text, a uri or a file path)
+#
 
-### Validate an object against a JSON Schema Draft 2 schema
+# => true
+JSON::Validator.validate(schema, { "a" => 1 }, :parse_data => false)
+# => false
+JSON::Validator.validate(schema, '{ "a": 1 }', :parse_data => false)
 
-```rb
-require 'rubygems'
-require 'json-schema'
+#
+# with the `:json` option, the json must be an unparsed json text (not a hash, a uri or a file path)
+#
 
-schema = {
-  "type" => "object",
-  "properties" => {
-    "a" => {"type" => "integer", "optional" => true}
-  }
-}
-
-data = {
-  "a" => 5
-}
-
-JSON::Validator.validate(schema, data, :version => :draft2)
-```
+# => true
+JSON::Validator.validate(schema, '{ "a": 1 }', :json => true)
+# => "no implicit conversion of Hash into String"
+begin
+  JSON::Validator.validate(schema, { "a" => 1 }, :json => true)
+rescue TypeError => e
+  e.message
+end
 
-### Explicitly specifying the type of the data
+#
+# with the `:uri` option, the json must be a uri or file path (not a hash or a json text)
+#
 
-By default, json-schema accepts a variety of different types for the data
-parameter, and it will try to work out what to do with it dynamically. You can
-pass it a string uri (in which case it will download the json from that location
-before validating), a string of JSON text, or simply a ruby object (such as an
-array or hash representing parsed json). However, sometimes the nature of the
-data is ambiguous (for example, is "http://github.com" just a string, or is it a
-uri?). In other situations, you have already parsed your JSON, and you don't
-need to re-parse it.
+File.write("data.json", '{ "a": 1 }')
 
-If you want to be explict about what kind of data is being parsed, JSON schema
-supports a number of options:
+# => true
+JSON::Validator.validate(schema, "data.json", :uri => true)
+# => "Can't convert Hash into String."
+begin
+  JSON::Validator.validate(schema, { "a"  => 1 }, :uri => true)
+rescue TypeError => e
+  e.message
+end
 
-```rb
-require 'rubygems'
-require 'json-schema'
+#
+# with the `:clear_cache` option set to true, the internal cache of schemas is
+# cleared after validation (otherwise schemas are cached for efficiency)
+#
 
-schema = {
-  "type" => "string"
-}
+File.write("schema.json", v2_schema.to_json)
 
-# examines the data, determines it's a uri, then tries to load data from it
-JSON::Validator.validate(schema, 'https://api.github.com') # returns false
+# => true
+JSON::Validator.validate("schema.json", {})
 
-# data is already parsed json - just accept it as-is
-JSON::Validator.validate(schema, 'https://api.github.com', :parse_data => false) # returns true
+File.write("schema.json", schema.to_json)
 
-# data is parsed to a json string
-JSON::Validator.validate(schema, '"https://api.github.com"', :json => true) # returns true
+# => true
+JSON::Validator.validate("schema.json", {}, :clear_cache => true)
 
-# loads data from the uri
-JSON::Validator.validate(schema, 'https://api.github.com', :uri => true) # returns false
+# => false
+JSON::Validator.validate("schema.json", {})
 ```
 
-### Extend an existing schema and validate against it
+Extending Schemas
+-----------------
 
 For this example, we are going to extend the [JSON Schema Draft
 3](http://tools.ietf.org/html/draft-zyp-json-schema-03) specification by adding
 a 'bitwise-and' property for validation.
 
-```rb
-require 'rubygems'
-require 'json-schema'
+```ruby
+require "json-schema"
 
 class BitwiseAndAttribute < JSON::Schema::Attribute
   def self.validate(current_schema, data, fragments, processor, validator, options = {})
@@ -403,7 +330,8 @@ data = {"a" => 0, "b" => "taco"}
 JSON::Validator.validate(schema,data) # => false
 ```
 
-### Custom format validation
+Custom format validation
+------------------------
 
 The JSON schema standard allows custom formats in schema definitions which
 should be ignored by validators that do not support them. JSON::Schema allows
@@ -412,9 +340,8 @@ checked as parameter and must raise a `JSON::Schema::CustomFormatError` to
 indicate a format violation. The error message will be prepended by the property
 name, e.g. [The property '#a']()
 
-```rb
-require 'rubygems'
-require 'json-schema'
+```ruby
+require "json-schema"
 
 format_proc = -> value {
   raise JSON::Schema::CustomFormatError.new("must be 42") unless value == "42"
@@ -456,7 +383,7 @@ control all schemas which should be used by validation, this could be
 accomplished by registering all referenced schemas with the validator in
 advance:
 
-```rb
+```ruby
 schema = JSON::Schema.new(some_schema_definition, Addressable::URI.parse('http://example.com/my-schema'))
 JSON::Validator.add_schema(schema)
 ```
@@ -464,7 +391,7 @@ JSON::Validator.add_schema(schema)
 If more extensive control is necessary, the `JSON::Schema::Reader` instance used
 can be configured in a few ways:
 
-```rb
+```ruby
 # Change the default schema reader used
 JSON::Validator.schema_reader = JSON::Schema::Reader.new(:accept_uri => true, :accept_file => false)
 
@@ -491,7 +418,7 @@ If more than one of the supported JSON backends are installed, the `yajl-ruby`
 parser is used by default. This can be changed by issuing the following before
 validation:
 
-```rb
+```ruby
 JSON::Validator.json_backend = :json
 ```
 

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

@@ -11,7 +11,7 @@ module JSON
 
         case schema['additionalItems']
         when false
-          if schema['items'].length != data.length
+          if schema['items'].length < data.length
             message = "The property '#{build_fragment(fragments)}' contains additional array elements outside of the schema when none are allowed"
             validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
           end

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

@@ -14,7 +14,7 @@ module JSON
         if addprop.is_a?(Hash)
           matching_properties = extra_properties # & addprop.keys
           matching_properties.each do |key|
-            additional_property_schema = JSON::Schema.new(addprop[key] || addprop, current_schema.uri, validator)
+            additional_property_schema = JSON::Schema.new(addprop, current_schema.uri, validator)
             additional_property_schema.validate(data[key], fragments + [key], processor, options)
           end
           extra_properties -= matching_properties

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

@@ -24,8 +24,6 @@ module JSON
       def self.get_extended_uri_and_schema(s, current_schema, validator)
         uri,schema = nil,nil
 
-        s = {'$ref' => s} if s.is_a?(String)
-
         if s.is_a?(Hash)
           uri = current_schema.uri
           if s['$ref']

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

@@ -16,6 +16,7 @@ module JSON
 
         when Array
           items.each_with_index do |item_schema, i|
+            break if i >= data.length
             schema = JSON::Schema.new(item_schema, current_schema.uri, validator)
             schema.validate(data[i], fragments + [i.to_s], processor, options)
           end

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

@@ -48,11 +48,11 @@ module JSON
         if ref_schema
           # Perform fragment resolution to retrieve the appropriate level for the schema
           target_schema = ref_schema.schema
-          fragments = temp_uri.fragment.split("/")
+          fragments = JSON::Util::URI.parse(JSON::Util::URI.unescape_uri(temp_uri)).fragment.split("/")
           fragment_path = ''
           fragments.each do |fragment|
             if fragment && fragment != ''
-              fragment = JSON::Util::URI.unescaped_uri(fragment.gsub('~0', '~').gsub('~1', '/'))
+              fragment = fragment.gsub('~0', '~').gsub('~1', '/')
               if target_schema.is_a?(Array)
                 target_schema = target_schema[fragment.to_i]
               else

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

@@ -3,9 +3,8 @@ 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
+    # Base for any reading exceptions encountered by {JSON::Schema::Reader}
+    class ReadError < StandardError
       # @return [String] the requested schema location which was refused
       attr_reader :location
 
@@ -15,7 +14,30 @@ module JSON
       def initialize(location, type)
         @location = location
         @type = type
-        super("Read of #{type == :uri ? 'URI' : type} at #{location} refused!")
+        super(error_message)
+      end
+
+      private
+
+      def type_string
+        type == :uri ? 'URI' : type.to_s
+      end
+    end
+
+    # Raised by {JSON::Schema::Reader} when one of its settings indicate
+    # a schema should not be read.
+    class ReadRefused < ReadError
+      private
+      def error_message
+        "Read of #{type_string} at #{location} refused"
+      end
+    end
+
+    # Raised by {JSON::Schema::Reader} when an attempt to read a schema fails
+    class ReadFailed < ReadError
+      private
+      def error_message
+        "Read of #{type_string} at #{location} failed"
       end
     end
 
@@ -58,6 +80,8 @@ module JSON
       # @raise [JSON::Schema::ReadRefused] if +accept_uri+ or +accept_file+
       #   indicated the schema could not be read
       # @raise [JSON::Schema::ParseError] if the schema was not a valid JSON object
+      # @raise [JSON::Schema::ReadFailed] if reading the location was acceptable but the
+      #   attempt to retrieve it failed
       def read(location)
         uri  = JSON::Util::URI.parse(location.to_s)
         body = if uri.scheme.nil? || uri.scheme == 'file'
@@ -98,14 +122,18 @@ module JSON
         else
           raise JSON::Schema::ReadRefused.new(uri.to_s, :uri)
         end
+      rescue OpenURI::HTTPError, SocketError
+        raise JSON::Schema::ReadFailed.new(uri.to_s, :uri)
       end
 
       def read_file(pathname)
         if accept_file?(pathname)
-          File.read(JSON::Util::URI.unescaped_uri(pathname.to_s))
+          File.read(JSON::Util::URI.unescaped_path(pathname.to_s))
         else
           raise JSON::Schema::ReadRefused.new(pathname.to_s, :file)
         end
+      rescue Errno::ENOENT
+        raise JSON::Schema::ReadFailed.new(pathname.to_s, :file)
       end
     end
   end

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

@@ -54,7 +54,11 @@ module JSON
         Addressable::URI.convert_path(parsed_uri.path)
       end
 
-      def self.unescaped_uri(uri)
+      def self.unescape_uri(uri)
+        Addressable::URI.unescape(uri)
+      end
+
+      def self.unescaped_path(uri)
         parsed_uri = parse(uri)
 
         Addressable::URI.unescape(parsed_uri.path)

data/lib/json-schema/validator.rb

@@ -18,7 +18,7 @@ module JSON
   class Validator
 
     @@schemas = {}
-    @@cache_schemas = false
+    @@cache_schemas = true
     @@default_opts = {
       :list => false,
       :version => nil,
@@ -26,7 +26,7 @@ module JSON
       :record_errors => false,
       :errors_as_objects => false,
       :insert_defaults => false,
-      :clear_cache => true,
+      :clear_cache => false,
       :strict => false,
       :parse_data => true
     }
@@ -48,7 +48,7 @@ module JSON
       @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] = false if @options[:clear_cache] == false
+      @validation_options[:clear_cache] = true if !@@cache_schemas || @options[:clear_cache]
 
       @@mutex.synchronize { @base_schema = initialize_schema(schema_data) }
       @original_data = data
@@ -62,8 +62,7 @@ module JSON
         end
         metaschema = base_validator ? base_validator.metaschema : validator.metaschema
         # Don't clear the cache during metaschema validation!
-        meta_validator = JSON::Validator.new(metaschema, @base_schema.schema, {:clear_cache => false})
-        meta_validator.validate
+        self.class.validate!(metaschema, @base_schema.schema, {:clear_cache => false})
       end
 
       # If the :fragment option is set, try and validate against the fragment
@@ -110,12 +109,17 @@ module JSON
     end
 
     # Run a simple true/false validation of data against a schema
-    def validate()
+    def validate
       @base_schema.validate(@data,[],self,@validation_options)
-      if @options[:errors_as_objects]
-        return @errors.map{|e| e.to_hash}
+
+      if @options[:record_errors]
+        if @options[:errors_as_objects]
+          @errors.map{|e| e.to_hash}
+        else
+          @errors.map{|e| e.to_string}
+        end
       else
-        return @errors.map{|e| e.to_string}
+        true
       end
     ensure
       if @validation_options[:clear_cache] == true
@@ -239,9 +243,7 @@ module JSON
     class << self
       def validate(schema, data,opts={})
         begin
-          validator = JSON::Validator.new(schema, data, opts)
-          validator.validate
-          return true
+          validate!(schema, data, opts)
         rescue JSON::Schema::ValidationError, JSON::Schema::SchemaError
           return false
         end
@@ -258,7 +260,6 @@ module JSON
       def validate!(schema, data,opts={})
         validator = JSON::Validator.new(schema, data, opts)
         validator.validate
-        return true
       end
       alias_method 'validate2', 'validate!'
 
@@ -271,9 +272,7 @@ module JSON
       end
 
       def fully_validate(schema, data, opts={})
-        opts[:record_errors] = true
-        validator = JSON::Validator.new(schema, data, opts)
-        validator.validate
+        validate!(schema, data, opts.merge(:record_errors => true))
       end
 
       def fully_validate_schema(schema, opts={})
@@ -299,7 +298,7 @@ module JSON
       end
 
       def clear_cache
-        @@schemas = {} if @@cache_schemas == false
+        @@schemas = {}
       end
 
       def schemas
@@ -608,7 +607,7 @@ module JSON
         end
       else
         begin
-          File.read(JSON::Util::URI.unescaped_uri(uri))
+          File.read(JSON::Util::URI.unescaped_path(uri))
         rescue SystemCallError => e
           raise JSON::Schema::JsonLoadError, e.message
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json-schema
 version: !ruby/object:Gem::Version
-  version: 2.6.1
+  version: 2.7.0
 platform: ruby
 authors:
 - Kenny Hoxworth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-26 00:00:00.000000000 Z
+date: 2016-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -70,16 +70,16 @@ dependencies:
   name: addressable
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.3.8
+        version: '2.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.3.8
+        version: '2.4'
 description: 
 email: hoxworth@gmail.com
 executables: []
@@ -161,7 +161,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.8.7
+      version: '1.9'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -174,4 +174,3 @@ signing_key:
 specification_version: 4
 summary: Ruby JSON Schema Validator
 test_files: []
-has_rdoc: