json-schema 2.0.2 → 2.0.3

data/README.textile

@@ -22,7 +22,7 @@ From the git repo:
 
 <pre>
 $ gem build json-schema.gemspec
-$ gem install json-schema-2.0.2.gem
+$ gem install json-schema-2.0.3.gem
 </pre>
 
 

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

@@ -9,7 +9,7 @@ module JSON
           if data.is_a?(String)
             error_message = "The property '#{build_fragment(fragments)}' must be a date/time in the ISO-8601 format of YYYY-MM-DDThh:mm:ssZ or YYYY-MM-DDThh:mm:ss.ssZ"
             validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if !data.is_a?(String)
-            r = Regexp.new('^\d\d\d\d-\d\d-\d\dT(\d\d):(\d\d):(\d\d)([\.,]\d+)?Z$')
+            r = Regexp.new('^\d\d\d\d-\d\d-\d\dT(\d\d):(\d\d):(\d\d)([\.,]\d+)?(Z|[+-](\d\d)(:\d\d)?)?$')
             if (m = r.match(data))
               parts = data.split("T")
               begin

data/test/test_jsonschema_draft1.rb

@@ -12,7 +12,7 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
     data = {
       "a" => nil
     }
-    
+
     # Test integers
     schema["properties"]["a"]["type"] = "integer"
     data["a"] = 5
@@ -20,14 +20,14 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
 
     data["a"] = 5.2
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data['a'] = 'string'
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data['a'] = true
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
-    
+
+
     # Test numbers
     schema["properties"]["a"]["type"] = "number"
     data["a"] = 5
@@ -35,14 +35,14 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
 
     data["a"] = 5.2
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data['a'] = 'string'
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data['a'] = true
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
-    
+
+
     # Test strings
     schema["properties"]["a"]["type"] = "string"
     data["a"] = 5
@@ -50,14 +50,14 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
 
     data["a"] = 5.2
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data['a'] = 'string'
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data['a'] = true
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
-    
+
+
     # Test booleans
     schema["properties"]["a"]["type"] = "boolean"
     data["a"] = 5
@@ -65,17 +65,17 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
 
     data["a"] = 5.2
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data['a'] = 'string'
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data['a'] = true
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data['a'] = false
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
-    
+
+
     # Test object
     schema["properties"]["a"]["type"] = "object"
     data["a"] = {}
@@ -83,14 +83,14 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
 
     data["a"] = 5.2
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data['a'] = 'string'
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data['a'] = true
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
-    
+
+
     # Test array
     schema["properties"]["a"]["type"] = "array"
     data["a"] = []
@@ -98,14 +98,14 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
 
     data["a"] = 5.2
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data['a'] = 'string'
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data['a'] = true
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
-    
+
+
     # Test null
     schema["properties"]["a"]["type"] = "null"
     data["a"] = nil
@@ -113,14 +113,14 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
 
     data["a"] = 5.2
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data['a'] = 'string'
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data['a'] = true
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
-    
+
+
     # Test any
     schema["properties"]["a"]["type"] = "any"
     data["a"] = 5
@@ -128,43 +128,43 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
 
     data["a"] = 5.2
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data['a'] = 'string'
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data['a'] = true
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
-    
+
+
     # Test a union type
     schema["properties"]["a"]["type"] = ["integer","string"]
     data["a"] = 5
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = 'boo'
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = false
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     # 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,:version => :draft1))
-    
+
     data["a"] = 5
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = {"b" => 5}
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = {"b" => "taco"}
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
    end
-  
-  
-  
+
+
+
   def test_optional
     # Set up the default datatype
     schema = {
@@ -173,24 +173,24 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
       }
     }
     data = {}
-    
+
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
     data['a'] = "Hello"
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     schema = {
       "properties" => {
         "a" => {"type" => "integer", "optional" => "true"}
       }
     }
-    
+
     data = {}
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
   end
-  
-  
-  
+
+
+
   def test_minimum
     # Set up the default datatype
     schema = {
@@ -198,49 +198,49 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
         "a" => {"minimum" => 5}
       }
     }
-    
+
     data = {
       "a" => nil
     }
-    
-    
+
+
     # Test an integer
     data["a"] = 5
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = 4
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     # Test a float
     data["a"] = 5.0
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = 4.9
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     # Test a non-number
     data["a"] = "a string"
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     # Test exclusiveMinimum
     schema["properties"]["a"]["minimumCanEqual"] = false
-    
+
     data["a"] = 6
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = 5
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     # Test with float
     data["a"] = 5.00000001
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = 5.0
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
   end
-  
-  
-  
+
+
+
   def test_maximum
     # Set up the default datatype
     schema = {
@@ -248,48 +248,48 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
         "a" => {"maximum" => 5}
       }
     }
-    
+
     data = {
       "a" => nil
     }
-    
-    
+
+
     # Test an integer
     data["a"] = 5
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = 6
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     # Test a float
     data["a"] = 5.0
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = 5.1
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     # Test a non-number
     data["a"] = "a string"
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     # Test exclusiveMinimum
     schema["properties"]["a"]["maximumCanEqual"] = false
-    
+
     data["a"] = 4
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = 5
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     # Test with float
     data["a"] = 4.9999999
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = 5.0
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
   end
-  
-  
+
+
   def test_min_items
     # Set up the default datatype
     schema = {
@@ -297,25 +297,25 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
         "a" => {"minItems" => 1}
       }
     }
-    
+
     data = {
       "a" => nil
     }
-    
+
     # Test with an array
     data["a"] = ["boo"]
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = []
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     # Test with a non-array
     data["a"] = "boo"
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
   end
-  
-  
-  
+
+
+
   def test_max_items
     # Set up the default datatype
     schema = {
@@ -323,24 +323,24 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
         "a" => {"maxItems" => 1}
       }
     }
-    
+
     data = {
       "a" => nil
     }
-    
+
     # Test with an array
     data["a"] = ["boo"]
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = ["boo","taco"]
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     # Test with a non-array
     data["a"] = "boo"
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
   end
-  
-  
+
+
   def test_pattern
     # Set up the default datatype
     schema = {
@@ -348,24 +348,24 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
         "a" => {"pattern" => "\\d+ taco"}
       }
     }
-    
+
     data = {
       "a" => nil
     }
-    
+
     # Test strings
     data["a"] = "156 taco bell"
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     # Test a non-string
     data["a"] = 5
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = "taco"
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
   end
-  
-  
+
+
   def test_min_length
     # Set up the default datatype
     schema = {
@@ -373,24 +373,24 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
         "a" => {"minLength" => 1}
       }
     }
-    
+
     data = {
       "a" => nil
     }
-    
+
     # Try out strings
     data["a"] = "t"
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = ""
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     # Try out non-string
     data["a"] = 5
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
   end
-  
-  
+
+
   def test_max_length
     # Set up the default datatype
     schema = {
@@ -398,24 +398,24 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
         "a" => {"maxLength" => 1}
       }
     }
-    
+
     data = {
       "a" => nil
     }
-    
+
     # Try out strings
     data["a"] = "t"
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = "tt"
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     # Try out non-string
     data["a"] = 5
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
   end
-  
-  
+
+
   def test_enum
     # Set up the default datatype
     schema = {
@@ -423,34 +423,34 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
         "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(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = 'boo'
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = [1,2,3]
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = {"a" => "b"}
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     # Test something that doesn't exist
     data["a"] = 'taco'
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     # Try it without the key
     data = {}
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
   end
-  
-  
+
+
   def test_max_decimal
     # Set up the default datatype
     schema = {
@@ -458,32 +458,32 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
         "a" => {"maxDecimal" => 2}
       }
     }
-    
+
     data = {
       "a" => nil
     }
-    
+
     data["a"] = 3.35
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = 3.455
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
-    
+
+
     schema["properties"]["a"]["maxDecimal"] = 0
-    
+
     data["a"] = 4.0
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = 'boo'
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = 5
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
   end
-  
-  
-  
+
+
+
   def test_disallow
     # Set up the default datatype
     schema = {
@@ -491,33 +491,33 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
         "a" => {"disallow" => "integer"}
       }
     }
-    
+
     data = {
       "a" => nil
     }
-    
-    
+
+
     data["a"] = 'string'
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = 5
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
-    
+
+
     schema["properties"]["a"]["disallow"] = ["integer","string"]
     data["a"] = 'string'
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = 5
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     data["a"] = false
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
 
   end
-  
-  
-  
+
+
+
   def test_additional_properties
     # Test no additional properties allowed
     schema = {
@@ -526,15 +526,15 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
       },
       "additionalProperties" => false
     }
-    
+
     data = {
       "a" => 10
     }
-    
+
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
     data["b"] = 5
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     # Test additional properties match a schema
     schema["additionalProperties"] = { "type" => "string" }
     data["b"] = "taco"
@@ -542,41 +542,41 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
     data["b"] = 5
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
   end
-  
-  
+
+
   def test_items
     schema = {
       "items" => { "type" => "integer" }
     }
-    
+
     data = [1,2,4]
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
     data = [1,2,"string"]
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
     schema = {
       "items" => [
         {"type" => "integer"},
         {"type" => "string"}
       ]
     }
-    
+
     data = [1,"string"]
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
     data = [1,"string",3]
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
     data = ["string",1]
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    
+
   end
-  
-  
+
+
   def test_format_ipv4
     schema = {
       "type" => "object",
       "properties" => { "a" => {"type" => "string", "format" => "ip-address"}}
     }
-    
+
     data = {"a" => "1.1.1.1"}
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
     data = {"a" => "1.1.1"}
@@ -591,14 +591,14 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
     data = {"a" => "b1.1.1.1"}
   end
-  
-  
+
+
   def test_format_ipv6
     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,:version => :draft1))
     data = {"a" => "1111:0:8888:0:0:0:eeee:ffff"}
@@ -614,13 +614,13 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
     data = {"a" => "1111:2222:8888:9999:aaaa:cccc:eeee:ffff:bbbb"}
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
   end
-  
+
   def test_format_time
     schema = {
       "type" => "object",
       "properties" => { "a" => {"type" => "string", "format" => "time"}}
     }
-    
+
     data = {"a" => "12:00:00"}
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
     data = {"a" => "12:00"}
@@ -638,14 +638,14 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
     data = {"a" => "12:00:00b"}
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
   end
-  
-  
+
+
   def test_format_date
     schema = {
       "type" => "object",
       "properties" => { "a" => {"type" => "string", "format" => "date"}}
     }
-    
+
     data = {"a" => "2010-01-01"}
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
     data = {"a" => "2010-01-32"}
@@ -659,13 +659,13 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
     data = {"a" => "2010-01-01n"}
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
   end
-  
+
   def test_format_datetime
     schema = {
       "type" => "object",
       "properties" => { "a" => {"type" => "string", "format" => "date-time"}}
     }
-    
+
     data = {"a" => "2010-01-01T12:00:00Z"}
     assert(JSON::Validator.validate(schema,data,:version => :draft1))
     data = {"a" => "2010-01-32T12:00:00Z"}
@@ -678,19 +678,17 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
     data = {"a" => "2010-01-01T12:00:60Z"}
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "2010-01-01T12:00:00"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
     data = {"a" => "2010-01-01T12:00:00z"}
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
     data = {"a" => "2010-01-0112:00:00Z"}
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
   end
-  
-  
+
+
   def test_format_union
     data1 = {"a" => "boo"}
     data2 = {"a" => nil}
-    
+
     schema = {
       "type" => "object",
       "properties" => { "a" => {"type" => ["string","null"], "format" => "ip-address"}}
@@ -698,6 +696,6 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data1,:version => :draft1))
     assert(JSON::Validator.validate(schema,data2,:version => :draft1))
   end
-  
+
 end