json-schema 2.5.0 → 2.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b4d20081a44ab34c2a1d12268a7e4160b4070221
-  data.tar.gz: a9b98f1d541ad64563095ee77d03738e3d6fbfaa
+  metadata.gz: 001e9abbf83e74538a97e0cdb3088cf2b3d415c4
+  data.tar.gz: a7dbb4c977abd6b70c8b019cf85670d4113c3e29
 SHA512:
-  metadata.gz: 433b1267a8f4902cf007e6407fbd9bc253cd5884ae9c1311825cdf1e019c784239c2e7189e11e8d752449c27a5f74f22c00dbb6205ae3ae3d5342874628584a4
-  data.tar.gz: 57f5da1f4a399df4c9025d6955a6d554fc41c23ac009651501f7badb5c622db272a53bbd3d3a2cac849b34055cbbb89d5c99775968e1b69ff8ddc3933dfc8966
+  metadata.gz: 1414dd9bee261301c502b41b30f5ba4c3dd617676acc06e5ace1a35bec1a115aebe4e996a886f981f4ced69679ae0ffed6f1d1aad4f17c16548df61e094c9bfb
+  data.tar.gz: e661d1bbf6d34d40e963580fc950d7201a2e4670ba90749dee5f76bc33045f6b55a973d17897fdcb7c101fcaafabf2ec38116a93d9fa22d9dd10869e8eabd907

data/README.textile

@@ -26,7 +26,7 @@ From the git repo:
 
 <pre>
 $ gem build json-schema.gemspec
-$ gem install json-schema-2.4.1.gem
+$ gem install json-schema-2.5.0.gem
 </pre>
 
 
@@ -40,6 +40,8 @@ By default, the validator uses the "JSON Schema Draft 4":http://tools.ietf.org/h
 
 h3. 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>.
+
 <pre>
 require 'rubygems'
 require 'json-schema'

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

@@ -7,10 +7,7 @@ module JSON
         return unless data.is_a?(String)
         error_message = "The property '#{build_fragment(fragments)}' must be a valid URI"
         begin
-          # TODO
-          # Addressable only throws an exception on to_s for invalid URI strings, although it
-          # probably should throughout parse already - https://github.com/sporkmonger/addressable/issues/177
-          Addressable::URI.parse(data).to_s
+          Addressable::URI.parse(data)
         rescue Addressable::URI::InvalidURIError
           validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
         end

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

@@ -4,39 +4,52 @@ module JSON
   class Schema
     class OneOfAttribute < Attribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
-        validation_errors = 0
+        errors = Hash.new { |hsh, k| hsh[k] = [] }
+
+        validation_error_count = 0
         one_of = current_schema.schema['oneOf']
 
         original_data = data.is_a?(Hash) ? data.clone : data
         success_data = nil
 
-        one_of.each do |element|
-          schema = JSON::Schema.new(element,current_schema.uri,validator)
+        valid = false
 
+        one_of.each_with_index do |element, schema_index|
+          schema = JSON::Schema.new(element,current_schema.uri,validator)
+          pre_validation_error_count = validation_errors(processor).count
           begin
-            # need to raise exceptions on error because
-            # schema.validate doesn't reliably return true/false
-            schema.validate(data,fragments,processor,options.merge(:record_errors => false))
+            schema.validate(data,fragments,processor,options)
             success_data = data.is_a?(Hash) ? data.clone : data
+            valid = true
           rescue ValidationError
-            validation_errors += 1
+            valid = false
           end
 
+          diff = validation_errors(processor).count - pre_validation_error_count
+          valid = false if diff > 0
+          validation_error_count += 1 if !valid
+          while diff > 0
+            diff = diff - 1
+            errors["oneOf ##{schema_index}"].push(validation_errors(processor).pop)
+          end
           data = original_data
         end
 
-        if validation_errors == one_of.length - 1
+
+
+        if validation_error_count == one_of.length - 1
           data = success_data
           return
         end
 
-        if validation_errors == one_of.length
+        if validation_error_count == one_of.length
           message = "The property '#{build_fragment(fragments)}' of type #{data.class} did not match any of the required schemas"
         else
           message = "The property '#{build_fragment(fragments)}' of type #{data.class} matched more than one of the required schemas"
         end
 
         validation_error(processor, message, fragments, current_schema, self, options[:record_errors]) if message
+        validation_errors(processor).last.sub_errors = errors if message
       end
     end
   end

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

@@ -56,8 +56,8 @@ module JSON
         end
 
         if diff.size > 0
-          properties = data.to_a.map { |(key, _)| key }.join(', ')
-          message = "The property '#{build_fragment(fragments)}' contained undefined properties: '#{properties}"
+          properties = diff.keys.join(', ')
+          message = "The property '#{build_fragment(fragments)}' contained undefined properties: '#{properties}'"
           validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
         end
       end

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

@@ -1,14 +1,20 @@
+require 'set'
+
 # This is a hack that I don't want to ever use anywhere else or repeat EVER, but we need enums to be
-# an Array to pass schema validation. But we also want fast lookup! And we can't use sets because of
-# backport support... so...
+# an Array to pass schema validation. But we also want fast lookup!
 
 class ArraySet < Array
-	def include?(obj)
-		# On first invocation create a HASH (yeah, yeah) to act as our set given the array values
-		if !defined? @array_values
-			@array_values = {}
-			self.each {|x| @array_values[x] = 1}
-		end
-		@array_values.has_key? obj
-	end
-end
+  def include?(obj)
+    if !defined? @values
+      @values = Set.new
+      self.each { |x| @values << convert_to_float_if_fixnum(x) }
+    end
+    @values.include?(convert_to_float_if_fixnum(obj))
+  end
+
+  private
+
+  def convert_to_float_if_fixnum(value)
+    value.is_a?(Fixnum) ? value.to_f : value
+  end
+end

data/lib/json-schema/validator.rb

@@ -129,7 +129,6 @@ module JSON
 
     def load_ref_schema(parent_schema, ref)
       schema_uri = absolutize_ref_uri(ref, parent_schema.uri)
-
       return true if self.class.schema_loaded?(schema_uri)
 
       schema = @options[:schema_reader].read(schema_uri)
@@ -139,6 +138,7 @@ module JSON
 
     def absolutize_ref_uri(ref, parent_schema_uri)
       ref_uri = Addressable::URI.parse(ref)
+      ref_uri.fragment = ''
 
       return ref_uri if ref_uri.absolute?
       # This is a self reference and thus the schema does not need to be re-loaded

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

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

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

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

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

@@ -8,7 +8,6 @@ module JSON
       end
 
       JSON::Validator.register_validator(self.new)
-      JSON::Validator.register_default_validator(self.new)
     end
   end
 end

data/test/test_jsonschema_draft1.rb

@@ -15,10 +15,15 @@ class JSONSchemaDraft1Test < Minitest::Test
 
   include ArrayValidation::ItemsTests
 
+  include EnumValidation::General
+  include EnumValidation::V1_V2
+
   include NumberValidation::MinMaxTests
 
   include ObjectValidation::AdditionalPropertiesTests
 
+  include StrictValidation
+
   include StringValidation::ValueTests
   include StringValidation::FormatTests
   include StringValidation::DateAndTimeFormatTests
@@ -50,41 +55,6 @@ class JSONSchemaDraft1Test < Minitest::Test
     assert_valid schema, data
   end
 
-  def test_enum
-    # Set up the default datatype
-    schema = {
-      "properties" => {
-        "a" => {"enum" => [1,'boo',[1,2,3],{"a" => "b"}], "optional" => true}
-      }
-    }
-
-    data = {
-      "a" => nil
-    }
-
-    # Make sure all of the above are valid...
-    data["a"] = 1
-    assert_valid schema, data
-
-    data["a"] = 'boo'
-    assert_valid schema, data
-
-    data["a"] = [1,2,3]
-    assert_valid schema, data
-
-    data["a"] = {"a" => "b"}
-    assert_valid schema, data
-
-    # Test something that doesn't exist
-    data["a"] = 'taco'
-    refute_valid schema, data
-
-    # Try it without the key
-    data = {}
-    assert_valid schema, data
-  end
-
-
   def test_max_decimal
     # Set up the default datatype
     schema = {

data/test/test_jsonschema_draft2.rb

@@ -20,11 +20,16 @@ class JSONSchemaDraft2Test < Minitest::Test
   include ArrayValidation::ItemsTests
   include ArrayValidation::UniqueItemsTests
 
+  include EnumValidation::General
+  include EnumValidation::V1_V2
+
   include NumberValidation::MinMaxTests
   include NumberValidation::MultipleOfTests
 
   include ObjectValidation::AdditionalPropertiesTests
 
+  include StrictValidation
+
   include StringValidation::ValueTests
   include StringValidation::FormatTests
   include StringValidation::DateAndTimeFormatTests
@@ -56,40 +61,6 @@ class JSONSchemaDraft2Test < Minitest::Test
     assert_valid schema, data
   end
 
-  def test_enum
-    # Set up the default datatype
-    schema = {
-      "properties" => {
-        "a" => {"enum" => [1,'boo',[1,2,3],{"a" => "b"}], "optional" => true}
-      }
-    }
-
-    data = {
-      "a" => nil
-    }
-
-    # Make sure all of the above are valid...
-    data["a"] = 1
-    assert_valid schema, data
-
-    data["a"] = 'boo'
-    assert_valid schema, data
-
-    data["a"] = [1,2,3]
-    assert_valid schema, data
-
-    data["a"] = {"a" => "b"}
-    assert_valid schema, data
-
-    # Test something that doesn't exist
-    data["a"] = 'taco'
-    refute_valid schema, data
-
-    # Try it without the key
-    data = {}
-    assert_valid schema, data
-  end
-
   def test_disallow
     # Set up the default datatype
     schema = {

data/test/test_jsonschema_draft3.rb

@@ -22,12 +22,17 @@ class JSONSchemaDraft3Test < Minitest::Test
   include ArrayValidation::AdditionalItemsTests
   include ArrayValidation::UniqueItemsTests
 
+  include EnumValidation::General
+  include EnumValidation::V3_V4
+
   include NumberValidation::MinMaxTests
   include NumberValidation::MultipleOfTests
 
   include ObjectValidation::AdditionalPropertiesTests
   include ObjectValidation::PatternPropertiesTests
 
+  include StrictValidation
+
   include StringValidation::ValueTests
   include StringValidation::FormatTests
   include StringValidation::DateAndTimeFormatTests
@@ -94,28 +99,6 @@ class JSONSchemaDraft3Test < Minitest::Test
     assert_valid schema, data
   end
 
-  def test_strict_properties
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "properties" => {
-        "a" => {"type" => "string"},
-        "b" => {"type" => "string"}
-      }
-    }
-
-    data = {"a" => "a"}
-    assert(!JSON::Validator.validate(schema,data,:strict => true))
-
-    data = {"b" => "b"}
-    assert(!JSON::Validator.validate(schema,data,:strict => true))
-
-    data = {"a" => "a", "b" => "b"}
-    assert(JSON::Validator.validate(schema,data,:strict => true))
-
-    data = {"a" => "a", "b" => "b", "c" => "c"}
-    assert(!JSON::Validator.validate(schema,data,:strict => true))
-  end
-
   def test_strict_properties_required_props
     schema = {
       "$schema" => "http://json-schema.org/draft-03/schema#",
@@ -193,41 +176,6 @@ class JSONSchemaDraft3Test < Minitest::Test
     assert(!JSON::Validator.validate(schema,data,:strict => true))
   end
 
-  def test_enum
-    # Set up the default datatype
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "properties" => {
-        "a" => {"enum" => [1,'boo',[1,2,3],{"a" => "b"}]}
-      }
-    }
-
-    data = {
-      "a" => nil
-    }
-
-    # Make sure all of the above are valid...
-    data["a"] = 1
-    assert_valid schema, data
-
-    data["a"] = 'boo'
-    assert_valid schema, data
-
-    data["a"] = [1,2,3]
-    assert_valid schema, data
-
-    data["a"] = {"a" => "b"}
-    assert_valid schema, data
-
-    # Test something that doesn't exist
-    data["a"] = 'taco'
-    refute_valid schema, data
-
-    # Try it without the key
-    data = {}
-    assert_valid schema, data
-  end
-
   def test_disallow
     # Set up the default datatype
     schema = {

data/test/test_jsonschema_draft4.rb

@@ -22,12 +22,17 @@ class JSONSchemaDraft4Test < Minitest::Test
   include ArrayValidation::AdditionalItemsTests
   include ArrayValidation::UniqueItemsTests
 
+  include EnumValidation::General
+  include EnumValidation::V3_V4
+
   include NumberValidation::MinMaxTests
   include NumberValidation::MultipleOfTests
 
   include ObjectValidation::AdditionalPropertiesTests
   include ObjectValidation::PatternPropertiesTests
 
+  include StrictValidation
+
   include StringValidation::ValueTests
   include StringValidation::FormatTests
 
@@ -159,58 +164,6 @@ class JSONSchemaDraft4Test < Minitest::Test
     assert(!JSON::Validator.validate(schema,data,:strict => true))
   end
 
-  def test_enum
-    # Set up the default datatype
-    schema = {
-      "$schema" => "http://json-schema.org/draft-04/schema#",
-      "properties" => {
-        "a" => {"enum" => [1,'boo',[1,2,3],{"a" => "b"}]}
-      }
-    }
-
-    data = {
-      "a" => nil
-    }
-
-    # Make sure all of the above are valid...
-    data["a"] = 1
-    assert_valid schema, data
-
-    data["a"] = 'boo'
-    assert_valid schema, data
-
-    data["a"] = [1,2,3]
-    assert_valid schema, data
-
-    data["a"] = {"a" => "b"}
-    assert_valid schema, data
-
-    # Test something that doesn't exist
-    data["a"] = 'taco'
-    refute_valid schema, data
-
-    # Try it without the key
-    data = {}
-    assert_valid schema, data
-  end
-
-  def test_enum_with_schema_validation
-    schema = {
-      "$schema" => "http://json-schema.org/draft-04/schema#",
-      "properties" => {
-        "a" => {"enum" => [1,'boo',[1,2,3],{"a" => "b"}]}
-      }
-    }
-
-    data = {
-      "a" => nil
-    }
-
-    # Make sure all of the above are valid...
-    data["a"] = 1
-    assert(JSON::Validator.validate(schema,data,:validate_schema => true))
-  end
-
   def test_list_option
     schema = {
       "$schema" => "http://json-schema.org/draft-04/schema#",

data/test/test_load_ref_schema.rb

@@ -0,0 +1,40 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class LoadRefSchemaTests < Minitest::Test
+  def load_other_schema
+    JSON::Validator.add_schema(JSON::Schema.new(
+      {
+        '$schema' => 'http://json-schema.org/draft-04/schema#',
+        'type' => 'object',
+        'properties' => {
+          "title" => {
+            "type" => "string"
+          }
+        }
+      },
+      Addressable::URI.parse("http://example.com/schema#")
+    ))
+  end
+
+  def test_cached_schema
+    schema_url = "http://example.com/schema#"
+    schema = {
+      "$ref" => schema_url
+    }
+    data = {}
+    load_other_schema
+    validator = JSON::Validator.new(schema, data)
+    assert JSON::Validator.schema_loaded?(schema_url)
+  end
+
+  def test_cached_schema_with_fragment
+    schema_url = "http://example.com/schema#"
+    schema = {
+      "$ref" => "#{schema_url}/properties/title"
+    }
+    data = {}
+    load_other_schema
+    validator = JSON::Validator.new(schema, data)
+    assert JSON::Validator.schema_loaded?(schema_url)
+  end
+end

data/test/test_one_of.rb

@@ -29,4 +29,57 @@ class OneOfTest < Minitest::Test
     refute_valid schema, { "a" => 5 }
   end
 
+  def test_one_of_sub_errors
+    schema = {
+      "$schema" => "http://json-schema.org/draft-04/schema#",
+      "oneOf" => [
+        {
+          "properties" => {"a" => {"type" => "string", "pattern" => "foo"}},
+        },
+        {
+          "properties" => {"a" => {"type" => "string", "pattern" => "bar"}},
+        },
+        {
+          "properties" => {"a" => {"type" => "number", "minimum" => 10}},
+        }
+      ]
+    }
+
+    errors = JSON::Validator.fully_validate(schema, { "a" => 5 }, :errors_as_objects => true)
+    nested_errors = errors[0][:errors]
+    assert_equal([:oneof_0,:oneof_1,:oneof_2], nested_errors.keys, 'should have nested errors for each allOf subschema')
+    assert_match(/the property '#\/a' of type Fixnum did not match the following type: string/i, nested_errors[:oneof_0][0][:message])
+    assert_match(/the property '#\/a' did not have a minimum value of 10, inclusively/i, nested_errors[:oneof_2][0][:message])
+  end
+
+  def test_one_of_sub_errors_message
+    schema = {
+      "$schema" => "http://json-schema.org/draft-04/schema#",
+      "oneOf" => [
+        {
+          "properties" => {"a" => {"type" => "string", "pattern" => "foo"}},
+        },
+        {
+          "properties" => {"a" => {"type" => "string", "pattern" => "bar"}},
+        },
+        {
+          "properties" => {"a" => {"type" => "number", "minimum" => 10}},
+        }
+      ]
+    }
+
+    errors = JSON::Validator.fully_validate(schema, { "a" => 5 })
+    expected_message = """The property '#/' of type Hash did not match any of the required schemas. The schema specific errors were:
+
+- oneOf #0:
+    - The property '#/a' of type Fixnum did not match the following type: string
+- oneOf #1:
+    - The property '#/a' of type Fixnum did not match the following type: string
+- oneOf #2:
+    - The property '#/a' did not have a minimum value of 10, inclusively"""
+
+    assert_equal(expected_message, errors[0])
+
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json-schema
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.5.1
 platform: ruby
 authors:
 - Kenny Hoxworth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-03 00:00:00.000000000 Z
+date: 2015-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: 2.3.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: 2.3.7
 description: 
 email: hoxworth@gmail.com
 executables: []
@@ -129,7 +129,6 @@ files:
 - lib/json-schema/errors/schema_error.rb
 - lib/json-schema/errors/validation_error.rb
 - lib/json-schema/schema.rb
-- lib/json-schema/schema/#validator.rb#
 - lib/json-schema/schema/reader.rb
 - lib/json-schema/schema/validator.rb
 - lib/json-schema/util/array_set.rb
@@ -140,6 +139,8 @@ files:
 - lib/json-schema/validators/draft2.rb
 - lib/json-schema/validators/draft3.rb
 - lib/json-schema/validators/draft4.rb
+- lib/json-schema/validators/hyper-draft1.rb
+- lib/json-schema/validators/hyper-draft2.rb
 - lib/json-schema/validators/hyper-draft4.rb
 - resources/draft-01.json
 - resources/draft-02.json
@@ -191,6 +192,7 @@ files:
 - test/test_jsonschema_draft3.rb
 - test/test_jsonschema_draft4.rb
 - test/test_list_option.rb
+- test/test_load_ref_schema.rb
 - test/test_merge_missing_values.rb
 - test/test_minitems.rb
 - test/test_one_of.rb
@@ -221,7 +223,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '1.8'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Ruby JSON Schema Validator
@@ -245,6 +247,7 @@ test_files:
 - test/test_jsonschema_draft3.rb
 - test/test_jsonschema_draft4.rb
 - test/test_list_option.rb
+- test/test_load_ref_schema.rb
 - test/test_merge_missing_values.rb
 - test/test_minitems.rb
 - test/test_one_of.rb
@@ -282,3 +285,4 @@ test_files:
 - test/schemas/relative_definition_schema.json
 - test/schemas/self_link_schema.json
 - test/schemas/up_link_schema.json
+has_rdoc: 

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

@@ -1,37 +0,0 @@
-
-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