json-schema 1.1.1 → 1.2.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NDQzOTViYTAzYzllZGY1OWQxMTE5NjczYzM0MTc1YTM5OTI4NDU3OA==
+  data.tar.gz: !binary |-
+    ZDNhMDY5MjQ4MDFmZDMzY2I2MGY4YjY4YTNkZGZiM2Q1YzM3OWVhMg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZDRhZjZlOTA3MWUxYjkwZjE1MDFjN2JlZjM1ZGE0ZDU5ZDE1NDVjMzE5NjQ2
+    YjhkZTc4ZGU3MjNlYzA3ZmRlYzRjM2FiYWI4NzMxNzU5NTNkODYwODllZmY3
+    ZmYxMDcyMTA0MTA3MjNiYzQ5YWE5ODVlNzk4ZjdmYmNmY2JiNzE=
+  data.tar.gz: !binary |-
+    YzY0MzlhNDM5MjUwYjczMjcwNTBjMmNjY2ExN2IwNDEzNDk2NzQ5YjUyMjY4
+    NzRlODJhMmI5YTBjNmViNTZlOTYzZDI4YzE3YjA5YjE5N2Y1NDRhN2Q3ZTBh
+    MDE0MzM2NGYwYjJlYzYxZTk3OWFmMWZkNWI2Y2UzMjM0M2Y5NjY=

data/README.textile

@@ -18,7 +18,7 @@ From the git repo:
 
 <pre>
 $ gem build json-schema.gemspec
-$ gem install json-schema-1.1.1.gem
+$ gem install json-schema-1.2.0.gem
 </pre>
 
 
@@ -55,7 +55,7 @@ h3. Validate a JSON string against a JSON schema file
 <pre>
 require 'rubygems'
 require 'json-schema'
-  
+
 JSON::Validator.validate('schema.json', '{"a" : 5}')
 </pre>
 
@@ -69,19 +69,31 @@ data = ['user','user','user']
 JSON::Validator.validate('user.json', data, :list => true)
 </pre>
 
+h3. Strictly validate an object's properties
+
+With the <code>:strict</code>code> option, validation fails when an object contains properties that are not defined in the schema's property list or doesn't match the <code>additionalProperties</code> property. Furthermore, all properties are treated as <code>required</code> by default.
+
+<pre>
+require 'rubygems'
+require 'json-schema'
+
+data = ['user','user','user']
+JSON::Validator.validate('user.json', data, :list => true)
+</pre>
+
 h3. Catch a validation error and print it out
 
 <pre>
 require 'rubygems'
 require 'json-schema'
-  
+
 schema = {
   "type" => "object",
   "properties" => {
     "a" => {"type" => "integer", "required" => true}
   }
 }
-  
+
 data = {
   "a" => "taco"
 }
@@ -99,7 +111,7 @@ h3. Fully validate against a schema and catch all errors
 <pre>
 require 'rubygems'
 require 'json-schema'
-  
+
 schema = {
   "type" => "object",
   "properties" => {
@@ -107,14 +119,14 @@ schema = {
     "b" => {"type" => "string", "required" => "true"}
   }
 }
-  
+
 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#"] 
+# ["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#"]
 </pre>
 
 h3. Fully validate against a schema and catch all errors as objects
@@ -122,7 +134,7 @@ h3. Fully validate against a schema and catch all errors as objects
 <pre>
 require 'rubygems'
 require 'json-schema'
-  
+
 schema = {
   "type" => "object",
   "properties" => {
@@ -130,7 +142,7 @@ schema = {
     "b" => {"type" => "string", "required" => "true"}
   }
 }
-  
+
 data = {
   "a" => "taco"
 }
@@ -163,7 +175,7 @@ JSON::Validator.validate(schema, data, :validate_schema => true)
 
 h3. 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 
+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.
 
 <pre>
@@ -172,13 +184,13 @@ require 'json-schema'
 
 schema = {
   "type" => "object",
-  "properties" => { 
+  "properties" => {
     "a" => {"type" => "integer", "default" => 42, "required" => "true"},
     "b" => {"type" => "integer"}
   }
 }
 
-# Would not normally validate because "a" is missing and required by schema, 
+# Would not normally validate because "a" is missing and required by schema,
 # but "default" option allows insertion of valid default.
 data = {
   "b" => 5
@@ -189,9 +201,9 @@ JSON::Validator.validate(schema, data)
 
 JSON::Validator.validate(schema, data, :insert_defaults => true)
 # true
-# data = { 
-#   "a" => 42, 
-#   "b" => 5 
+# data = {
+#   "a" => 42,
+#   "b" => 5
 # }
 
 </pre>
@@ -223,7 +235,7 @@ For this example, we are going to extend the "JSON Schema Draft 3":http://tools.
 <pre>
 require 'rubygems'
 require 'json-schema'
-  
+
 class BitwiseAndAttribute < JSON::Schema::Attribute
   def self.validate(current_schema, data, fragments, processor, validator, options = {})
     if data.is_a?(Integer) && data & current_schema.schema['bitwise-and'].to_i == 0
@@ -240,7 +252,7 @@ class ExtendedSchema < JSON::Schema::Validator
     @attributes["bitwise-and"] = BitwiseAndAttribute
     @uri = URI.parse("http://test.com/test.json")
   end
-  
+
   JSON::Validator.register_validator(self.new)
 end
 
@@ -277,7 +289,7 @@ If more than one of the supported JSON backends are installed, the <code>yajl-ru
 <pre>
 JSON::Validator.json_backend = :json
 </pre>
-  
+
 Optionally, the JSON Schema library supports using the MultiJSON library for selecting JSON backends. If the MultiJSON library is installed, it will be autoloaded.
 
 h2. Notes

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

@@ -9,11 +9,11 @@ module JSON
               data[property] = (default.is_a?(Hash) ? default.clone : default)
             end
 
-            if property_schema['required'] and !data.has_key?(property)
+            if (property_schema['required'] || options[:strict] == true) and !data.has_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)
               schema = JSON::Schema.new(property_schema,current_schema.uri,validator)
               fragments << property
@@ -21,6 +21,18 @@ module JSON
               fragments.pop
             end
           end
+
+          # When strict is true, ensure no undefined properties exist in the data
+          if (options[:strict] == true && !current_schema.schema.has_key?('additionalProperties'))
+            diff = data.select do |k,v|
+              !current_schema.schema['properties'].has_key?(k.to_s) && !current_schema.schema['properties'].has_key?(k.to_sym)
+            end
+
+            if diff.size > 0
+              message = "The property '#{build_fragment(fragments)}' contained undefined properties: '#{diff.keys.join(", ")}'"
+              validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+            end
+          end
         end
       end
     end

data/lib/json-schema/validator.rb

@@ -20,7 +20,7 @@ module JSON
         message = "#{message} in schema #{schema.uri}"
         super(message)
       end
-      
+
       def to_string
         if @sub_errors.empty?
           message
@@ -30,7 +30,7 @@ module JSON
           full_message
         end
       end
-      
+
       def to_hash
         base = {:schema => @schema.uri, :fragment => ::JSON::Schema::Attribute.build_fragment(fragments), :message => message, :failed_attribute => @failed_attribute.to_s.split(":").last.split("Attribute").first}
         if !@sub_errors.empty?
@@ -62,7 +62,7 @@ module JSON
           raise error
         end
       end
-      
+
       def self.validation_errors(validator)
         validator.validation_errors
       end
@@ -111,7 +111,8 @@ module JSON
       :validate_schema => false,
       :record_errors => false,
       :errors_as_objects => false,
-      :insert_defaults => false
+      :insert_defaults => false,
+      :strict => false
     }
     @@validators = {}
     @@default_validator = nil
@@ -119,7 +120,7 @@ module JSON
     @@json_backend = nil
     @@serializer = nil
     @@mutex = Mutex.new
-    
+
     def self.version_string_for(version)
       # I'm not a fan of this, but it's quick and dirty to get it working for now
       return "draft-03" unless version
@@ -154,7 +155,8 @@ 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
+
       # validate the schema, if requested
       if @options[:validate_schema]
         begin
@@ -164,7 +166,7 @@ module JSON
           raise $!
         end
       end
-      
+
       @@mutex.synchronize { @base_schema = initialize_schema(schema_data) }
       @data = initialize_data(data)
       @@mutex.synchronize { build_schemas(@base_schema) }
@@ -295,7 +297,7 @@ module JSON
     def validation_error(error)
       @errors.push(error)
     end
-    
+
     def validation_errors
       @errors
     end
@@ -394,7 +396,7 @@ module JSON
           @@json_backend
         end
       end
-      
+
       def json_backend=(backend)
         if defined?(MultiJson)
           backend = backend == 'json' ? 'json_gem' : backend
@@ -425,7 +427,7 @@ module JSON
           end
         end
       end
-      
+
       if !defined?(MultiJson)
         if begin
             Gem::Specification::find_by_name('json')
@@ -438,7 +440,7 @@ module JSON
           @@available_json_backends << 'json'
           @@json_backend = 'json'
         end
-        
+
         # Try force-loading json for rubies > 1.9.2
         begin
           require 'json'
@@ -458,11 +460,11 @@ module JSON
           @@available_json_backends << 'yajl'
           @@json_backend = 'yajl'
         end
-        
+
         if @@json_backend == 'yajl'
           @@serializer = lambda{|o| Yajl::Encoder.encode(o) }
         else
-          @@serializer = lambda{|o| Marshal.dump(o) }  	  
+          @@serializer = lambda{|o| Marshal.dump(o) }
         end
       end
     end

data/test/test_jsonschema_draft3.rb

@@ -13,7 +13,7 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     data = {
       "a" => nil
     }
-    
+
     # Test integers
     schema["properties"]["a"]["type"] = "integer"
     data["a"] = 5
@@ -21,16 +21,16 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
 
     data["a"] = 5.2
     assert(!JSON::Validator.validate(schema,data))
-    
+
     data['a'] = 'string'
     assert(!JSON::Validator.validate(schema,data))
-    
+
     data['a'] = true
     assert(!JSON::Validator.validate(schema,data))
-    
+
     assert(JSON::Validator.validate({'type' => 'integer'}, 3))
     assert(!JSON::Validator.validate({'type' => 'integer'}, "hello"))
-    
+
     # Test numbers
     schema["properties"]["a"]["type"] = "number"
     data["a"] = 5
@@ -38,18 +38,18 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
 
     data["a"] = 5.2
     assert(JSON::Validator.validate(schema,data))
-    
+
     data['a'] = 'string'
     assert(!JSON::Validator.validate(schema,data))
-    
+
     data['a'] = true
     assert(!JSON::Validator.validate(schema,data))
-    
+
     assert(JSON::Validator.validate({'type' => 'number'}, 3))
     assert(JSON::Validator.validate({'type' => 'number'}, 3.14159265358979))
     assert(!JSON::Validator.validate({'type' => 'number'}, "hello"))
-    
-    
+
+
     # Test strings
     schema["properties"]["a"]["type"] = "string"
     data["a"] = 5
@@ -57,18 +57,18 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
 
     data["a"] = 5.2
     assert(!JSON::Validator.validate(schema,data))
-    
+
     data['a'] = 'string'
     assert(JSON::Validator.validate(schema,data))
-    
+
     data['a'] = true
     assert(!JSON::Validator.validate(schema,data))
-    
+
     assert(JSON::Validator.validate({'type' => 'string'}, 'hello'))
     assert(!JSON::Validator.validate({'type' => 'string'}, 3.14159265358979))
     assert(!JSON::Validator.validate({'type' => 'string'}, []))
-    
-    
+
+
     # Test booleans
     schema["properties"]["a"]["type"] = "boolean"
     data["a"] = 5
@@ -76,23 +76,23 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
 
     data["a"] = 5.2
     assert(!JSON::Validator.validate(schema,data))
-    
+
     data['a'] = 'string'
     assert(!JSON::Validator.validate(schema,data))
-    
+
     data['a'] = true
     assert(JSON::Validator.validate(schema,data))
-    
+
     data['a'] = false
     assert(JSON::Validator.validate(schema,data))
-    
+
     assert(JSON::Validator.validate({'type' => 'boolean'}, true))
     assert(JSON::Validator.validate({'type' => 'boolean'}, false))
     assert(!JSON::Validator.validate({'type' => 'boolean'}, nil))
     assert(!JSON::Validator.validate({'type' => 'boolean'}, 3))
     assert(!JSON::Validator.validate({'type' => 'boolean'}, "hello"))
-    
-    
+
+
     # Test object
     schema["properties"]["a"]["type"] = "object"
     data["a"] = {}
@@ -100,20 +100,20 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
 
     data["a"] = 5.2
     assert(!JSON::Validator.validate(schema,data))
-    
+
     data['a'] = 'string'
     assert(!JSON::Validator.validate(schema,data))
-    
+
     data['a'] = true
     assert(!JSON::Validator.validate(schema,data))
-    
+
     assert(JSON::Validator.validate({'type' => 'object'}, {'a' => true}))
     assert(JSON::Validator.validate({'type' => 'object'}, {}))
     assert(!JSON::Validator.validate({'type' => 'object'}, []))
     assert(!JSON::Validator.validate({'type' => 'object'}, 3))
     assert(!JSON::Validator.validate({'type' => 'object'}, "hello"))
-    
-    
+
+
     # Test array
     schema["properties"]["a"]["type"] = "array"
     data["a"] = []
@@ -121,20 +121,20 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
 
     data["a"] = 5.2
     assert(!JSON::Validator.validate(schema,data))
-    
+
     data['a'] = 'string'
     assert(!JSON::Validator.validate(schema,data))
-    
+
     data['a'] = true
     assert(!JSON::Validator.validate(schema,data))
-    
+
     assert(JSON::Validator.validate({'type' => 'array'}, ['a']))
     assert(JSON::Validator.validate({'type' => 'array'}, []))
     assert(!JSON::Validator.validate({'type' => 'array'}, {}))
     assert(!JSON::Validator.validate({'type' => 'array'}, 3))
     assert(!JSON::Validator.validate({'type' => 'array'}, "hello"))
-    
-    
+
+
     # Test null
     schema["properties"]["a"]["type"] = "null"
     data["a"] = nil
@@ -142,19 +142,19 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
 
     data["a"] = 5.2
     assert(!JSON::Validator.validate(schema,data))
-    
+
     data['a'] = 'string'
     assert(!JSON::Validator.validate(schema,data))
-    
+
     data['a'] = true
     assert(!JSON::Validator.validate(schema,data))
-    
+
     assert(JSON::Validator.validate({'type' => 'null'}, nil))
     assert(!JSON::Validator.validate({'type' => 'null'}, false))
     assert(!JSON::Validator.validate({'type' => 'null'}, []))
     assert(!JSON::Validator.validate({'type' => 'null'}, "hello"))
-    
-    
+
+
     # Test any
     schema["properties"]["a"]["type"] = "any"
     data["a"] = 5
@@ -162,52 +162,52 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
 
     data["a"] = 5.2
     assert(JSON::Validator.validate(schema,data))
-    
+
     data['a'] = 'string'
     assert(JSON::Validator.validate(schema,data))
-    
+
     data['a'] = true
     assert(JSON::Validator.validate(schema,data))
-    
+
     assert(JSON::Validator.validate({'type' => 'any'}, true))
     assert(JSON::Validator.validate({'type' => 'any'}, nil))
     assert(JSON::Validator.validate({'type' => 'any'}, {}))
     assert(JSON::Validator.validate({'type' => 'any'}, 3))
     assert(JSON::Validator.validate({'type' => 'any'}, "hello"))
-    
-    
+
+
     # Test a union type
     schema["properties"]["a"]["type"] = ["integer","string"]
     data["a"] = 5
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = 'boo'
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = false
     assert(!JSON::Validator.validate(schema,data))
-    
+
     assert(JSON::Validator.validate({'type' => ['string', 'null']}, "hello"))
     assert(!JSON::Validator.validate({'type' => ['integer', 'object']}, "hello"))
-    
+
     # Test a union type with schemas
     schema["properties"]["a"]["type"] = [{ "type" => "string" }, {"type" => "object", "properties" => {"b" => {"type" => "integer"}}}]
-  
+
     data["a"] = "test"
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = 5
     assert(!JSON::Validator.validate(schema,data))
-    
+
     data["a"] = {"b" => 5}
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = {"b" => "taco"}
     assert(!JSON::Validator.validate(schema,data))
    end
-  
-  
-  
+
+
+
   def test_required
     # Set up the default datatype
     schema = {
@@ -217,25 +217,25 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
       }
     }
     data = {}
-    
+
     assert(!JSON::Validator.validate(schema,data))
     data['a'] = "Hello"
     assert(JSON::Validator.validate(schema,data))
-    
+
     schema = {
       "$schema" => "http://json-schema.org/draft-03/schema#",
       "properties" => {
         "a" => {"type" => "integer"}
       }
     }
-    
+
     data = {}
     assert(JSON::Validator.validate(schema,data))
-    
+
   end
-  
-  
-  
+
+
+
   def test_minimum
     # Set up the default datatype
     schema = {
@@ -244,49 +244,49 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
         "a" => {"minimum" => 5}
       }
     }
-    
+
     data = {
       "a" => nil
     }
-    
-    
+
+
     # Test an integer
     data["a"] = 5
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = 4
     assert(!JSON::Validator.validate(schema,data))
-    
+
     # Test a float
     data["a"] = 5.0
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = 4.9
     assert(!JSON::Validator.validate(schema,data))
-    
+
     # Test a non-number
     data["a"] = "a string"
     assert(JSON::Validator.validate(schema,data))
-    
+
     # Test exclusiveMinimum
     schema["properties"]["a"]["exclusiveMinimum"] = true
-    
+
     data["a"] = 6
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = 5
     assert(!JSON::Validator.validate(schema,data))
-    
+
     # Test with float
     data["a"] = 5.00000001
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = 5.0
     assert(!JSON::Validator.validate(schema,data))
   end
-  
-  
-  
+
+
+
   def test_maximum
     # Set up the default datatype
     schema = {
@@ -295,48 +295,48 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
         "a" => {"maximum" => 5}
       }
     }
-    
+
     data = {
       "a" => nil
     }
-    
-    
+
+
     # Test an integer
     data["a"] = 5
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = 6
     assert(!JSON::Validator.validate(schema,data))
-    
+
     # Test a float
     data["a"] = 5.0
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = 5.1
     assert(!JSON::Validator.validate(schema,data))
-    
+
     # Test a non-number
     data["a"] = "a string"
     assert(JSON::Validator.validate(schema,data))
-    
+
     # Test exclusiveMinimum
     schema["properties"]["a"]["exclusiveMaximum"] = true
-    
+
     data["a"] = 4
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = 5
     assert(!JSON::Validator.validate(schema,data))
-    
+
     # Test with float
     data["a"] = 4.9999999
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = 5.0
     assert(!JSON::Validator.validate(schema,data))
   end
-  
-  
+
+
   def test_min_items
     # Set up the default datatype
     schema = {
@@ -345,25 +345,25 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
         "a" => {"minItems" => 1}
       }
     }
-    
+
     data = {
       "a" => nil
     }
-    
+
     # Test with an array
     data["a"] = ["boo"]
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = []
     assert(!JSON::Validator.validate(schema,data))
-    
+
     # Test with a non-array
     data["a"] = "boo"
     assert(JSON::Validator.validate(schema,data))
   end
-  
-  
-  
+
+
+
   def test_max_items
     # Set up the default datatype
     schema = {
@@ -372,25 +372,25 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
         "a" => {"maxItems" => 1}
       }
     }
-    
+
     data = {
       "a" => nil
     }
-    
+
     # Test with an array
     data["a"] = ["boo"]
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = ["boo","taco"]
     assert(!JSON::Validator.validate(schema,data))
-    
+
     # Test with a non-array
     data["a"] = "boo"
     assert(JSON::Validator.validate(schema,data))
   end
-  
-  
-  
+
+
+
   def test_unique_items
     # Set up the default datatype
     schema = {
@@ -399,70 +399,117 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
         "a" => {"uniqueItems" => true}
       }
     }
-    
+
     data = {
       "a" => nil
     }
-    
+
     # Test with nulls
     data["a"] = [nil,5]
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = [nil,nil]
     assert(!JSON::Validator.validate(schema,data))
-    
+
     # Test with booleans
     data["a"] = [true,4]
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = [true,false]
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = [true,true]
     assert(!JSON::Validator.validate(schema,data))
-    
+
     # Test with numbers
     data["a"] = [4,true]
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = [4,4.1]
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = [4,4]
     assert(!JSON::Validator.validate(schema,data))
-    
+
     # Test with strings
     data["a"] = ['a',true]
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = ['a','ab']
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = ['a','a']
     assert(!JSON::Validator.validate(schema,data))
-    
+
     # Test with arrays
     data["a"] = [[1],true]
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = [[1,2],[1,3]]
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = [[1,2,3],[1,2,3]]
     assert(!JSON::Validator.validate(schema,data))
-    
+
     # Test with objects
     data["a"] = [{"a" => 1},true]
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = [{"a" => 1},{"a" => 2}]
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = [{"a" => 1, "b" => 2}, {"a" => 1, "b" => 2}]
     assert(!JSON::Validator.validate(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_additional_props
+    schema = {
+      "$schema" => "http://json-schema.org/draft-03/schema#",
+      "properties" => {
+        "a" => {"type" => "string"},
+        "b" => {"type" => "string"}
+      },
+      "additionalProperties" => {"type" => "integer"}
+    }
+
+    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))
+
+    data = {"a" => "a", "b" => "b", "c" => 3}
+    assert(JSON::Validator.validate(schema,data,:strict => true))
+  end
+
   def test_pattern
     # Set up the default datatype
     schema = {
@@ -471,24 +518,24 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
         "a" => {"pattern" => "\\d+ taco"}
       }
     }
-    
+
     data = {
       "a" => nil
     }
-    
+
     # Test strings
     data["a"] = "156 taco bell"
     assert(JSON::Validator.validate(schema,data))
-    
+
     # Test a non-string
     data["a"] = 5
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = "taco"
     assert(!JSON::Validator.validate(schema,data))
   end
-  
-  
+
+
   def test_min_length
     # Set up the default datatype
     schema = {
@@ -497,24 +544,24 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
         "a" => {"minLength" => 1}
       }
     }
-    
+
     data = {
       "a" => nil
     }
-    
+
     # Try out strings
     data["a"] = "t"
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = ""
     assert(!JSON::Validator.validate(schema,data))
-    
+
     # Try out non-string
     data["a"] = 5
     assert(JSON::Validator.validate(schema,data))
   end
-  
-  
+
+
   def test_max_length
     # Set up the default datatype
     schema = {
@@ -523,24 +570,24 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
         "a" => {"maxLength" => 1}
       }
     }
-    
+
     data = {
       "a" => nil
     }
-    
+
     # Try out strings
     data["a"] = "t"
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = "tt"
     assert(!JSON::Validator.validate(schema,data))
-    
+
     # Try out non-string
     data["a"] = 5
     assert(JSON::Validator.validate(schema,data))
   end
-  
-  
+
+
   def test_enum
     # Set up the default datatype
     schema = {
@@ -549,34 +596,34 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
         "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))
-    
+
     data["a"] = 'boo'
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = [1,2,3]
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = {"a" => "b"}
     assert(JSON::Validator.validate(schema,data))
-    
+
     # Test something that doesn't exist
     data["a"] = 'taco'
     assert(!JSON::Validator.validate(schema,data))
-    
+
     # Try it without the key
     data = {}
     assert(JSON::Validator.validate(schema,data))
   end
-  
-  
+
+
   def test_divisible_by
     # Set up the default datatype
     schema = {
@@ -585,32 +632,32 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
         "a" => {"divisibleBy" => 1.1}
       }
     }
-    
+
     data = {
       "a" => nil
     }
-    
+
     data["a"] = 3.3
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = 3.4
     assert(!JSON::Validator.validate(schema,data))
-    
+
     schema["properties"]["a"]["divisibleBy"] = 2.0
-    
+
     data["a"] = 4.0
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = 'boo'
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = 5
     schema["properties"]["a"]["divisibleBy"] = 0
     assert(!JSON::Validator.validate(schema,data))
   end
-  
-  
-  
+
+
+
   def test_disallow
     # Set up the default datatype
     schema = {
@@ -619,60 +666,60 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
         "a" => {"disallow" => "integer"}
       }
     }
-    
+
     data = {
       "a" => nil
     }
-    
-    
+
+
     data["a"] = 'string'
     assert(JSON::Validator.validate(schema,data))
-    
+
     data["a"] = 5
     assert(!JSON::Validator.validate(schema,data))
-    
-    
+
+
     schema["properties"]["a"]["disallow"] = ["integer","string"]
     data["a"] = 'string'
     assert(!JSON::Validator.validate(schema,data))
-    
+
     data["a"] = 5
     assert(!JSON::Validator.validate(schema,data))
-    
+
     data["a"] = false
     assert(JSON::Validator.validate(schema,data))
 
   end
-  
-  
-  
+
+
+
   def test_extends
     schema = {
       "$schema" => "http://json-schema.org/draft-03/schema#",
       "properties" => {
         "a" => { "type" => "integer"}
-      } 
+      }
     }
-    
+
     schema2 = {
       "$schema" => "http://json-schema.org/draft-03/schema#",
       "properties" => {
         "a" => { "maximum" => 5 }
       }
     }
-    
+
     data = {
       "a" => 10
     }
-    
+
     assert(JSON::Validator.validate(schema,data))
     assert(!JSON::Validator.validate(schema2,data))
-    
+
     schema["extends"] = schema2
-    
+
     assert(!JSON::Validator.validate(schema,data))
   end
-  
+
   def test_pattern_properties
     # Set up the default datatype
     schema = {
@@ -681,19 +728,19 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
         "\\d+ taco" => {"type" => "integer"}
       }
     }
-    
+
     data = {
       "a" => true,
       "1 taco" => 1,
       "20 tacos" => 20
     }
-    
+
     assert(JSON::Validator.validate(schema,data))
     data["20 tacos"] = "string!"
     assert(!JSON::Validator.validate(schema,data))
   end
-  
-  
+
+
   def test_additional_properties
     # Test no additional properties allowed
     schema = {
@@ -703,22 +750,22 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
       },
       "additionalProperties" => false
     }
-    
+
     data = {
       "a" => 10
     }
-    
+
     assert(JSON::Validator.validate(schema,data))
     data["b"] = 5
     assert(!JSON::Validator.validate(schema,data))
-    
+
     # Test additional properties match a schema
     schema["additionalProperties"] = { "type" => "string" }
     data["b"] = "taco"
     assert(JSON::Validator.validate(schema,data))
     data["b"] = 5
     assert(!JSON::Validator.validate(schema,data))
-    
+
     # Make sure this works with pattern properties set, too
     schema = {
       "$schema" => "http://json-schema.org/draft-03/schema#",
@@ -727,29 +774,29 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
       },
       "additionalProperties" => false
     }
-    
+
     data = {
       "5 tacos" => 5,
       "20 tacos" => 20
     }
-    
+
     assert(JSON::Validator.validate(schema,data))
     data["b"] = 5
     assert(!JSON::Validator.validate(schema,data))
   end
-  
-  
+
+
   def test_items
     schema = {
       "$schema" => "http://json-schema.org/draft-03/schema#",
       "items" => { "type" => "integer" }
     }
-    
+
     data = [1,2,4]
     assert(JSON::Validator.validate(schema,data))
     data = [1,2,"string"]
     assert(!JSON::Validator.validate(schema,data))
-    
+
     schema = {
       "$schema" => "http://json-schema.org/draft-03/schema#",
       "items" => [
@@ -757,14 +804,14 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
         {"type" => "string"}
       ]
     }
-    
+
     data = [1,"string"]
     assert(JSON::Validator.validate(schema,data))
     data = [1,"string",3]
     assert(JSON::Validator.validate(schema,data))
     data = ["string",1]
     assert(!JSON::Validator.validate(schema,data))
-    
+
     schema = {
       "$schema" => "http://json-schema.org/draft-03/schema#",
       "items" => [
@@ -773,14 +820,14 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
       ],
       "additionalItems" => false
     }
-    
+
     data = [1,"string"]
     assert(JSON::Validator.validate(schema,data))
     data = [1,"string",3]
     assert(!JSON::Validator.validate(schema,data))
-    
+
     schema = {"$schema" => "http://json-schema.org/draft-03/schema#","items" => [{"type" => "integer"},{"type" => "string"}],"additionalItems" => {"type" => "integer"}}
-    
+
     data = [1,"string"]
     assert(JSON::Validator.validate(schema,data))
     data = [1,"string",3]
@@ -788,48 +835,48 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     data = [1,"string","string"]
     assert(!JSON::Validator.validate(schema,data))
   end
-  
-  
+
+
   def test_list_option
     schema = {
       "$schema" => "http://json-schema.org/draft-03/schema#",
       "type" => "object",
       "properties" => { "a" => {"type" => "integer", "required" => true} }
     }
-    
+
     data = [{"a" => 1},{"a" => 2},{"a" => 3}]
     assert(JSON::Validator.validate(schema,data,:list => true))
-    assert(!JSON::Validator.validate(schema,data))    
-    
+    assert(!JSON::Validator.validate(schema,data))
+
     data = {"a" => 1}
     assert(!JSON::Validator.validate(schema,data,:list => true))
-    
+
     data = [{"a" => 1},{"b" => 2},{"a" => 3}]
     assert(!JSON::Validator.validate(schema,data,:list => true))
   end
-  
-  
+
+
   def test_self_reference
     schema = {
       "$schema" => "http://json-schema.org/draft-03/schema#",
       "type" => "object",
       "properties" => { "a" => {"type" => "integer"}, "b" => {"$ref" => "#"}}
     }
-    
+
     data = {"a" => 5, "b" => {"b" => {"a" => 1}}}
     assert(JSON::Validator.validate(schema,data))
     data = {"a" => 5, "b" => {"b" => {"a" => 'taco'}}}
     assert(!JSON::Validator.validate(schema,data))
   end
-  
-  
+
+
   def test_format_ipv4
     schema = {
       "$schema" => "http://json-schema.org/draft-03/schema#",
       "type" => "object",
       "properties" => { "a" => {"type" => "string", "format" => "ip-address"}}
     }
-    
+
     data = {"a" => "1.1.1.1"}
     assert(JSON::Validator.validate(schema,data))
     data = {"a" => "1.1.1"}
@@ -844,15 +891,15 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data))
     data = {"a" => "b1.1.1.1"}
   end
-  
-  
+
+
   def test_format_ipv6
     schema = {
       "$schema" => "http://json-schema.org/draft-03/schema#",
       "type" => "object",
       "properties" => { "a" => {"type" => "string", "format" => "ipv6"}}
     }
-    
+
     data = {"a" => "1111:2222:8888:9999:aaaa:cccc:eeee:ffff"}
     assert(JSON::Validator.validate(schema,data))
     data = {"a" => "1111:0:8888:0:0:0:eeee:ffff"}
@@ -868,14 +915,14 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     data = {"a" => "1111:2222:8888:9999:aaaa:cccc:eeee:ffff:bbbb"}
     assert(!JSON::Validator.validate(schema,data))
   end
-  
+
   def test_format_time
     schema = {
       "$schema" => "http://json-schema.org/draft-03/schema#",
       "type" => "object",
       "properties" => { "a" => {"type" => "string", "format" => "time"}}
     }
-    
+
     data = {"a" => "12:00:00"}
     assert(JSON::Validator.validate(schema,data))
     data = {"a" => "12:00"}
@@ -893,15 +940,15 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     data = {"a" => "12:00:00b"}
     assert(!JSON::Validator.validate(schema,data))
   end
-  
-  
+
+
   def test_format_date
     schema = {
       "$schema" => "http://json-schema.org/draft-03/schema#",
       "type" => "object",
       "properties" => { "a" => {"type" => "string", "format" => "date"}}
     }
-    
+
     data = {"a" => "2010-01-01"}
     assert(JSON::Validator.validate(schema,data))
     data = {"a" => "2010-01-32"}
@@ -915,20 +962,20 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     data = {"a" => "2010-01-01n"}
     assert(!JSON::Validator.validate(schema,data))
   end
-  
+
   def test_format_datetime
     schema = {
       "$schema" => "http://json-schema.org/draft-03/schema#",
       "type" => "object",
       "properties" => { "a" => {"type" => "string", "format" => "date-time"}}
     }
-    
+
     data = {"a" => "2010-01-01T12:00:00Z"}
     assert(JSON::Validator.validate(schema,data))
   data = {"a" => "2010-01-01T12:00:00.1Z"}
     assert(JSON::Validator.validate(schema,data))
 	data = {"a" => "2010-01-01T12:00:00,1Z"}
-    assert(JSON::Validator.validate(schema,data))	
+    assert(JSON::Validator.validate(schema,data))
     data = {"a" => "2010-01-32T12:00:00Z"}
     assert(!JSON::Validator.validate(schema,data))
     data = {"a" => "2010-13-01T12:00:00Z"}
@@ -946,12 +993,12 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     data = {"a" => "2010-01-0112:00:00Z"}
     assert(!JSON::Validator.validate(schema,data))
   end
-  
-  
+
+
   def test_format_union
     data1 = {"a" => "boo"}
     data2 = {"a" => nil}
-    
+
     schema = {
       "type" => "object",
       "properties" => { "a" => {"type" => ["string","null"], "format" => "ip-address"}}
@@ -959,25 +1006,25 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data1,:version => :draft3))
     assert(JSON::Validator.validate(schema,data2,:version => :draft3))
   end
-  
-  
-  
+
+
+
   def test_schema
     schema = {
       "$schema" => "http://json-schema.org/THIS-IS-NOT-A-SCHEMA",
       "type" => "object"
     }
-    
+
     data = {"a" => "taco"}
     assert(!JSON::Validator.validate(schema,data))
-    
+
     schema = {
       "$schema" => "http://json-schema.org/draft-03/schema#",
       "type" => "object"
     }
     assert(JSON::Validator.validate(schema,data))
   end
-  
+
   def test_dependency
     schema = {
       "type" => "object",
@@ -989,12 +1036,12 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
         "a" => "b"
       }
     }
-    
+
     data = {"a" => 1, "b" => 2}
     assert(JSON::Validator.validate(schema,data))
     data = {"a" => 1}
     assert(!JSON::Validator.validate(schema,data))
-    
+
     schema = {
       "type" => "object",
       "properties" => {
@@ -1006,7 +1053,7 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
         "a" => ["b","c"]
       }
     }
-    
+
     data = {"a" => 1, "c" => 2}
     assert(!JSON::Validator.validate(schema,data))
     data = {"a" => 1, "b" => 2, "c" => 3}
@@ -1021,7 +1068,7 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
         "b" => {"type" => "integer"}
       }
     }
-    
+
     data = {"b" => 2}
     assert(JSON::Validator.validate(schema,data))
     assert_nil(data["a"])
@@ -1035,7 +1082,7 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
         "b" => {"type" => "integer"}
       }
     }
-    
+
     data = {"b" => 2}
     assert(!JSON::Validator.validate(schema,data))
     assert_nil(data["a"])
@@ -1049,7 +1096,7 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
         "b" => {"type" => "integer"}
       }
     }
-    
+
 
     schema = {
       "type" => "object",
@@ -1058,7 +1105,7 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
         "b" => {"type" => "integer"}
       }
     }
-    
+
     data = {"b" => 2}
     assert(!JSON::Validator.validate(schema,data))
     assert_nil(data["a"])
@@ -1072,7 +1119,7 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
         "b" => {"type" => "integer"}
       }
     }
-    
+
     data = {"b" => 2}
     assert(JSON::Validator.validate(schema,data))
     assert_nil(data["a"])
@@ -1080,7 +1127,7 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     assert_equal("42",data["a"])
 
   end
-  
-  
+
+
 end