json-schema 2.4.1 → 2.5.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZTc1NDAxODkxMmNiYTQ4YzdiMzNkMWEyYjlhYTQ5MTU5MWExMTFhZQ==
-  data.tar.gz: !binary |-
-    ZmQxNjIyOTU5ZGQyZGQ5ZDIxYmYxMGQwMGIzYjliMDMyYjQ5Y2EwMA==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    YjVlZjkzNWE5YTA3MjhlNTY0ZmMyMGRiNGE0YzYwODE1N2I3ZTFhMTAzYjQ1
-    NTJjZGU2ZTE1OTg3NDJjNThhYzAwMGRiYzZiMzIzZWJiODRmNzA5NjVjMzAw
-    ZTE4MjdjYzE3NGQ0ZjlhYmQ3NWViZjVmOWNhYzc2YjY2NWNlYTU=
-  data.tar.gz: !binary |-
-    ODA4M2U2YTkyMmM1NjhlMTUyN2M3NjJiODI3ZmUzMzNhYTFkNTE1YmRkYWM4
-    MWNiODZlYmQ3YjdkY2M4ZDk3ZDVkNTZlYmJkNmNjNWVjODhjOWQxNzA5MmU2
-    YjQwMDBmMjZmODdkOTI5YjBjMzUxMGJiOWNjY2JmNzZlZWZhYjY=
+SHA1:
+  metadata.gz: b4d20081a44ab34c2a1d12268a7e4160b4070221
+  data.tar.gz: a9b98f1d541ad64563095ee77d03738e3d6fbfaa
+SHA512:
+  metadata.gz: 433b1267a8f4902cf007e6407fbd9bc253cd5884ae9c1311825cdf1e019c784239c2e7189e11e8d752449c27a5f74f22c00dbb6205ae3ae3d5342874628584a4
+  data.tar.gz: 57f5da1f4a399df4c9025d6955a6d554fc41c23ac009651501f7badb5c622db272a53bbd3d3a2cac849b34055cbbb89d5c99775968e1b69ff8ddc3933dfc8966

data/README.textile

@@ -1,17 +1,18 @@
-!https://travis-ci.org/hoxworth/json-schema.svg?branch=master!:https://travis-ci.org/hoxworth/json-schema
-!https://codeclimate.com/github/hoxworth/json-schema/badges/gpa.svg!:https://codeclimate.com/github/hoxworth/json-schema
+!https://travis-ci.org/ruby-json-schema/json-schema.svg?branch=master!:https://travis-ci.org/ruby-json-schema/json-schema
+!https://codeclimate.com/github/ruby-json-schema/json-schema/badges/gpa.svg!:https://codeclimate.com/github/ruby-json-schema/json-schema
 
 h1. Ruby JSON Schema Validator
 
 This library is intended to provide Ruby with an interface for validating JSON objects against a JSON schema conforming to "JSON Schema Draft 4":http://tools.ietf.org/html/draft-zyp-json-schema-04. Legacy support for "JSON Schema Draft 3":http://tools.ietf.org/html/draft-zyp-json-schema-03, "JSON Schema Draft 2":http://tools.ietf.org/html/draft-zyp-json-schema-02, and "JSON Schema Draft 1":http://tools.ietf.org/html/draft-zyp-json-schema-01 is also included.
 
-h2. Version 2.0.0 Upgrade Notes
+h2. Additional Resources
 
-Please be aware that the upgrade to version 2.0.0 will use Draft-04 *by default*, so schemas that do not declare a validator using the <code>$schema</code> keyword will use Draft-04 now instead of Draft-03. This is the reason for the major version upgrade.
+* "Google Groups":https://groups.google.com/forum/#!forum/ruby-json-schema
+* #ruby-json-schema on chat.freenode.net
 
-h2. Dependencies
+h2. Version 2.0.0 Upgrade Notes
 
-The JSON::Schema library has no dependencies if the validation methods are called using Ruby objects. However, either the <code>json</code> or the <code>yajl-ruby</code> gem needs to be installed to validate JSON strings or files containing JSON data.
+Please be aware that the upgrade to version 2.0.0 will use Draft-04 *by default*, so schemas that do not declare a validator using the <code>$schema</code> keyword will use Draft-04 now instead of Draft-03. This is the reason for the major version upgrade.
 
 h2. Installation
 
@@ -277,6 +278,32 @@ data = {
 JSON::Validator.validate(schema, data, :version => :draft2)
 </pre>
 
+h3. Explicitly specifying the type of the data
+
+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.
+
+If you want to be explict about what kind of data is being parsed, JSON schema supports a number of options:
+
+<pre>
+require 'rubygems'
+require 'json-schema'
+
+schema = {
+  "type" => "string"
+}
+
+# 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
+
+# data is already parsed json - just accept it as-is
+JSON::Validator.validate(schema, 'https://api.github.com', :parse_data => false) # returns true
+
+# data is parsed to a json string
+JSON::Validator.validate(schema, '"https://api.github.com"', :json => true) # returns true
+
+# loads data from the uri
+JSON::Validator.validate(schema, 'https://api.github.com', :uri => true) # returns false
+</pre>
 
 h3. Extend an existing schema and validate against it
 
@@ -332,7 +359,7 @@ JSON::Validator.validate(schema,data) # => false
 
 h3. 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 registering procs as custom format validators which receive the value to be checked as parameter and must raise a <code>JSON::Schema::CustomFormatError</code> to indicate a format violation. The error message will be prepended by the property namne, e.g. "The property '#a'":
+The JSON schema standard allows custom formats in schema definitions which should be ignored by validators that do not support them. JSON::Schema allows registering procs as custom format validators which receive the value to be checked as parameter and must raise a <code>JSON::Schema::CustomFormatError</code> to indicate a format violation. The error message will be prepended by the property name, e.g. "The property '#a'":
 
 <pre>
 require 'rubygems'
@@ -370,6 +397,30 @@ errors = JSON::Validator.fully_validate(schema, {"a" => "23"})
 
 </pre>
 
+h2. Controlling Remote Schema Reading
+
+In some cases, you may wish to prevent the JSON Schema library from making HTTP calls or reading local files in order to resolve <code>$ref</code> schemas. If you fully control all schemas which should be used by validation, this could be accomplished by registering all referenced schemas with the validator in advance:
+
+<pre>
+schema = JSON::Schema.new(some_schema_definition, Addressable::URI.parse('http://example.com/my-schema'))
+JSON::Validator.add_schema(schema)
+</pre>
+
+If more extensive control is necessary, the <code>JSON::Schema::Reader</code> instance used can be configured in a few ways:
+
+<pre>
+# Change the default schema reader used
+JSON::Validator.schema_reader = JSON::Schema::Reader.new(:accept_uri => true, :accept_file => false)
+
+# For this validation call, use a reader which only accepts URIs from my-website.com
+schema_reader = JSON::Schema::Reader.new(
+  :accept_uri => proc { |uri| uri.host == 'my-website.com' }
+)
+JSON::Validator.validate(some_schema, some_object, :schema_reader => schema_reader)
+</pre>
+
+The <code>JSON::Schema::Reader</code> interface requires only an object which responds to <code>read(string)</code> and returns a <code>JSON::Schema</code> instance. See the "API documentation":http://www.rubydoc.info/github/ruby-json-schema/json-schema/master/JSON/Schema/Reader for more information.
+
 h2. JSON Backends
 
 The JSON Schema library currently supports the <code>json</code> and <code>yajl-ruby</code> backend JSON parsers. If either of these libraries are installed, they will be automatically loaded and used to parse any JSON strings supplied by the user.

data/lib/json-schema.rb

@@ -9,9 +9,11 @@ if Gem::Specification::find_all_by_name('multi_json').any?
 end
 
 require 'json-schema/util/array_set'
+require 'json-schema/util/uri'
 require 'json-schema/schema'
+require 'json-schema/schema/reader'
 require 'json-schema/validator'
+
 Dir[File.join(File.dirname(__FILE__), "json-schema/attributes/*.rb")].each {|file| require file }
 Dir[File.join(File.dirname(__FILE__), "json-schema/attributes/formats/*.rb")].each {|file| require file }
 Dir[File.join(File.dirname(__FILE__), "json-schema/validators/*.rb")].sort!.each {|file| require file }
-require 'json-schema/uri/file'

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

@@ -4,19 +4,22 @@ module JSON
   class Schema
     class AdditionalItemsAttribute < Attribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
-        if data.is_a?(Array) && current_schema.schema['items'].is_a?(Array)
-          if current_schema.schema['additionalItems'] == false && current_schema.schema['items'].length != data.length
+        return unless data.is_a?(Array)
+
+        schema = current_schema.schema
+        return unless schema['items'].is_a?(Array)
+
+        case schema['additionalItems']
+        when false
+          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])
-          elsif current_schema.schema['additionalItems'].is_a?(Hash)
-            schema = JSON::Schema.new(current_schema.schema['additionalItems'],current_schema.uri,validator)
-            data.each_with_index do |item,i|
-              if i >= current_schema.schema['items'].length
-                fragments << i.to_s
-                schema.validate(item, fragments, processor, options)
-                fragments.pop
-              end
-            end
+          end
+        when Hash
+          additional_items_schema = JSON::Schema.new(schema['additionalItems'], current_schema.uri, validator)
+          data.each_with_index do |item, i|
+            next if i < schema['items'].length
+            additional_items_schema.validate(item, fragments + [i.to_s], processor, options)
           end
         end
       end

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

@@ -5,62 +5,52 @@ module JSON
   class Schema
     class AdditionalPropertiesAttribute < Attribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
-        if data.is_a?(Hash) && (
-          current_schema.schema['type'].nil? || (
-            current_schema.schema['type'].is_a?(String) &&
-            current_schema.schema['type'].downcase == 'object'
-          )
-        )
-          extra_properties = data.keys
-          extra_properties = remove_valid_properties(extra_properties, current_schema, validator)
+        schema = current_schema.schema
+        return unless data.is_a?(Hash) && (schema['type'].nil? || schema['type'] == 'object')
 
-          addprop = current_schema.schema['additionalProperties']
-          if addprop.is_a?(Hash)
-            matching_properties = extra_properties # & addprop.keys
-            matching_properties.each do |key|
-              schema = JSON::Schema.new(addprop[key] || addprop, current_schema.uri, validator)
-              fragments << key
-              schema.validate(data[key],fragments,processor,options)
-              fragments.pop
-            end
-            extra_properties -= matching_properties
-          end
-          if !extra_properties.empty? and (addprop == false or (addprop.is_a?(Hash) and !addprop.empty?))
-            message = "The property '#{build_fragment(fragments)}' contains additional properties #{extra_properties.inspect} outside of the schema when none are allowed"
-            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+        extra_properties = remove_valid_properties(data.keys, current_schema, validator)
+
+        addprop = schema['additionalProperties']
+        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.validate(data[key], fragments + [key], processor, options)
           end
+          extra_properties -= matching_properties
+        end
+
+        if extra_properties.any? && (addprop == false || (addprop.is_a?(Hash) && !addprop.empty?))
+          message = "The property '#{build_fragment(fragments)}' contains additional properties #{extra_properties.inspect} outside of the schema when none are allowed"
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
         end
       end
 
       def self.remove_valid_properties(extra_properties, current_schema, validator)
+        schema = current_schema.schema
 
-          if current_schema.schema['properties']
-            extra_properties = extra_properties - current_schema.schema['properties'].keys
-          end
+        if schema['properties']
+          extra_properties = extra_properties - schema['properties'].keys
+        end
 
-          if current_schema.schema['patternProperties']
-            current_schema.schema['patternProperties'].each_key do |key|
-              r = Regexp.new(key)
-              extras_clone = extra_properties.clone
-              extras_clone.each do |prop|
-                if r.match(prop)
-                  extra_properties = extra_properties - [prop]
-                end
-              end
-            end
+        if schema['patternProperties']
+          schema['patternProperties'].each_key do |key|
+            regexp = Regexp.new(key)
+            extra_properties.reject! { |prop| regexp.match(prop) }
           end
+        end
 
-          if schemas= current_schema.schema['extends']
-            schemas = [schemas] if !schemas.is_a?(Array)
-            schemas.each do |schema_value|
-              temp_uri,extended_schema= JSON::Schema::ExtendsAttribute.get_extended_uri_and_schema(schema_value, current_schema, validator)
-              if extended_schema
-                extra_properties= remove_valid_properties(extra_properties, extended_schema, validator)
-              end
+        if extended_schemas = schema['extends']
+          extended_schemas = [extended_schemas] unless extended_schemas.is_a?(Array)
+          extended_schemas.each do |schema_value|
+            _, extended_schema = JSON::Schema::ExtendsAttribute.get_extended_uri_and_schema(schema_value, current_schema, validator)
+            if extended_schema
+              extra_properties = remove_valid_properties(extra_properties, extended_schema, validator)
             end
           end
+        end
 
-          extra_properties
+        extra_properties
       end
 
     end

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

@@ -8,6 +8,8 @@ module JSON
         errors = Hash.new { |hsh, k| hsh[k] = [] }
         valid = false
 
+        original_data = data.is_a?(Hash) ? data.clone : data
+
         current_schema.schema['anyOf'].each_with_index do |element, schema_index|
           schema = JSON::Schema.new(element,current_schema.uri,validator)
 
@@ -30,6 +32,8 @@ module JSON
           end
 
           break if valid
+
+          data = original_data
         end
 
         if !valid

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

@@ -4,29 +4,41 @@ module JSON
   class Schema
     class DependenciesAttribute < Attribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
-        if data.is_a?(Hash)
-          current_schema.schema['dependencies'].each do |property,dependency_value|
-            if data.has_key?(property.to_s)
-              if dependency_value.is_a?(String)
-                if !data.has_key?(dependency_value.to_s)
-                  message = "The property '#{build_fragment(fragments)}' has a property '#{property}' that depends on a missing property '#{dependency_value}'"
-                  validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
-                end
-              elsif dependency_value.is_a?(Array)
-                dependency_value.each do |value|
-                  if !data.has_key?(value.to_s)
-                    message = "The property '#{build_fragment(fragments)}' has a property '#{property}' that depends on a missing property '#{value}'"
-                    validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
-                  end
-                end
-              else
-                schema = JSON::Schema.new(dependency_value,current_schema.uri,validator)
-                schema.validate(data, fragments, processor, options)
-              end
+        return unless data.is_a?(Hash)
+
+        current_schema.schema['dependencies'].each do |property, dependency_value|
+          next unless data.has_key?(property.to_s)
+          next unless accept_value?(dependency_value)
+
+          case dependency_value
+          when String
+            validate_dependency(current_schema, data, property, dependency_value, fragments, processor, self, options)
+          when Array
+            dependency_value.each do |value|
+              validate_dependency(current_schema, data, property, value, fragments, processor, self, options)
             end
+          else
+            schema = JSON::Schema.new(dependency_value, current_schema.uri, validator)
+            schema.validate(data, fragments, processor, options)
           end
         end
       end
+
+      def self.validate_dependency(schema, data, property, value, fragments, processor, attribute, options)
+        return if data.key?(value.to_s)
+        message = "The property '#{build_fragment(fragments)}' has a property '#{property}' that depends on a missing property '#{value}'"
+        validation_error(processor, message, fragments, schema, attribute, options[:record_errors])
+      end
+
+      def self.accept_value?(value)
+        value.is_a?(String) || value.is_a?(Array) || value.is_a?(Hash)
+      end
+    end
+
+    class DependenciesV4Attribute < DependenciesAttribute
+      def self.accept_value?(value)
+        value.is_a?(Array) || value.is_a?(Hash)
+      end
     end
   end
 end

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

@@ -4,9 +4,8 @@ module JSON
   class Schema
     class DisallowAttribute < Attribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
-        if validator.attributes['type']
-          validator.attributes['type'].validate(current_schema, data, fragments, processor, validator, {:disallow => true}.merge(options))
-        end
+        return unless type = validator.attributes['type']
+        type.validate(current_schema, data, fragments, processor, validator, options.merge(:disallow => true))
       end
     end
   end

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

@@ -3,14 +3,18 @@ require 'json-schema/attribute'
 module JSON
   class Schema
     class DivisibleByAttribute < Attribute
+      def self.keyword
+        'divisibleBy'
+      end
+
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
-        if data.is_a?(Numeric)
-          if current_schema.schema['divisibleBy'] == 0 || 
-             current_schema.schema['divisibleBy'] == 0.0 ||
-             (BigDecimal.new(data.to_s) % BigDecimal.new(current_schema.schema['divisibleBy'].to_s)).to_f != 0
-             message = "The property '#{build_fragment(fragments)}' was not divisible by #{current_schema.schema['divisibleBy']}"
-             validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
-          end
+        return unless data.is_a?(Numeric)
+
+        factor = current_schema.schema[keyword]
+
+        if factor == 0 || factor == 0.0 || (BigDecimal.new(data.to_s) % BigDecimal.new(factor.to_s)).to_f != 0
+          message = "The property '#{build_fragment(fragments)}' was not divisible by #{factor}"
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
         end
       end
     end

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

@@ -4,22 +4,20 @@ module JSON
   class Schema
     class EnumAttribute < Attribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
-        if !current_schema.schema['enum'].include?(data)
-          message = "The property '#{build_fragment(fragments)}' value #{data.inspect} did not match one of the following values:"
-          current_schema.schema['enum'].each {|val|
-            if val.is_a?(NilClass)
-              message += " null,"
-            elsif val.is_a?(Array)
-              message += " (array),"
-            elsif val.is_a?(Hash)
-              message += " (object),"
-            else
-              message += " #{val.to_s},"
-            end
-          }
-          message.chop!
-          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
-        end
+        enum = current_schema.schema['enum']
+        return if enum.include?(data)
+
+        values = enum.map { |val|
+          case val
+          when nil   then 'null'
+          when Array then 'array'
+          when Hash  then 'object'
+          else val.to_s
+          end
+        }.join(', ')
+
+        message = "The property '#{build_fragment(fragments)}' value #{data.inspect} did not match one of the following values: #{values}"
+        validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
       end
     end
   end

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

@@ -1,16 +1,13 @@
 require 'json-schema/attribute'
-require 'uri'
 
 module JSON
   class Schema
     class FormatAttribute < Attribute
-
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
-        if self.data_valid_for_type?(data, current_schema.schema['type'])
-          format = current_schema.schema['format'].to_s
-          validator = validator.formats[format]
-          validator.validate(current_schema, data, fragments, processor, validator, options) unless validator.nil?
-        end
+        return unless data_valid_for_type?(data, current_schema.schema['type'])
+        format = current_schema.schema['format'].to_s
+        validator = validator.formats[format]
+        validator.validate(current_schema, data, fragments, processor, validator, options) unless validator.nil?
       end
     end
   end

data/lib/json-schema/attributes/formats/date_time_v4.rb

@@ -4,14 +4,11 @@ module JSON
   class Schema
     class DateTimeV4Format < FormatAttribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
-        if data.is_a?(String)
-          error_message = "The property '#{build_fragment(fragments)}' must be a valid RFC3339 date/time string"
-          begin
-            DateTime.rfc3339(data)
-          rescue ArgumentError
-            validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
-          end
-        end
+        return unless data.is_a?(String)
+        DateTime.rfc3339(data)
+      rescue ArgumentError
+        error_message = "The property '#{build_fragment(fragments)}' must be a valid RFC3339 date/time string"
+        validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
       end
     end
   end