json-schema 0.2.0 → 0.9.0

data/lib/json-schema/validator.rb

@@ -57,6 +57,7 @@ module JSON
       
       def validate(current_schema, data, fragments)
         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, self)
           end
@@ -72,7 +73,8 @@ module JSON
     @@schemas = {}
     @@cache_schemas = false
     @@default_opts = {
-      :list => false
+      :list => false,
+      :version => nil
     }
     @@validators = {}
     @@default_validator = nil
@@ -81,6 +83,23 @@ module JSON
     
     def initialize(schema_data, data, opts={})
       @options = @@default_opts.clone.merge(opts)
+      
+      # I'm not a fan of this, but it's quick and dirty to get it working for now
+      if @options[:version]
+        @options[:version] = case @options[:version].to_s
+        when "draft3"
+          "draft-03"
+        when "draft2"
+          "draft-02"
+        when "draft1"
+          "draft-01"
+        else
+          raise JSON::Schema::SchemaError.new("The requested JSON schema version is not supported")
+        end
+        u = URI.parse("http://json-schema.org/#{@options[:version]}/schema#")
+        validator = JSON::Validator.validators["#{u.scheme}://#{u.host}#{u.path}"]
+        @options[:version] = validator
+      end
       @base_schema = initialize_schema(schema_data)
       @data = initialize_data(data)    
       build_schemas(@base_schema)
@@ -122,13 +141,13 @@ module JSON
       
       if Validator.schemas[uri.to_s].nil?
         begin
-          schema = JSON::Schema.new(JSON::Validator.parse(open(uri.to_s).read), uri)
+          schema = JSON::Schema.new(JSON::Validator.parse(open(uri.to_s).read), uri, @options[:version])
           Validator.add_schema(schema)
           build_schemas(schema)
         rescue JSON::ParserError
           # Don't rescue this error, we want JSON formatting issues to bubble up
           raise $!
-        rescue
+        rescue Exception
           # Failures will occur when this URI cannot be referenced yet. Don't worry about it,
           # the proper error will fall out if the ref isn't ever defined
         end
@@ -184,7 +203,7 @@ module JSON
          load_ref_schema(parent_schema, obj['$ref'])
        else
          schema_uri = parent_schema.uri.clone
-         schema = JSON::Schema.new(obj,schema_uri)
+         schema = JSON::Schema.new(obj,schema_uri,@options[:version])
          if obj['id']
            Validator.add_schema(schema)
          end
@@ -288,12 +307,12 @@ module JSON
       if schema.is_a?(String)
         begin
           # Build a fake URI for this
-          schema_uri = URI.parse("file://#{Dir.pwd}/#{Digest::SHA1.hexdigest(schema)}")
+          schema_uri = URI.parse(UUID.create_v5(schema,UUID::Nil).to_s)
           schema = JSON::Validator.parse(schema)
           if @options[:list]
             schema = {"type" => "array", "items" => schema}
           end
-          schema = JSON::Schema.new(schema,schema_uri)
+          schema = JSON::Schema.new(schema,schema_uri,@options[:version])
           Validator.add_schema(schema)
         rescue
           # Build a uri for it
@@ -311,7 +330,7 @@ module JSON
             if @options[:list]
               schema = {"type" => "array", "items" => schema}
             end
-            schema = JSON::Schema.new(schema,schema_uri)
+            schema = JSON::Schema.new(schema,schema_uri,@options[:version])
             Validator.add_schema(schema)
           else
             schema = Validator.schemas[schema_uri.to_s]
@@ -321,8 +340,8 @@ module JSON
         if @options[:list]
           schema = {"type" => "array", "items" => schema}
         end
-        schema_uri = URI.parse("file://#{Dir.pwd}/#{Digest::SHA1.hexdigest(schema.inspect)}")
-        schema = JSON::Schema.new(schema,schema_uri)
+        schema_uri = URI.parse(UUID.create_v5(schema.inspect,UUID::Nil).to_s)
+        schema = JSON::Schema.new(schema,schema_uri,@options[:version])
         Validator.add_schema(schema)
       else
         raise "Invalid schema - must be either a string or a hash"

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

@@ -0,0 +1,32 @@
+module JSON
+  class Schema
+    
+    class Draft1 < Validator
+      def initialize
+        super
+        @attributes = {
+          "type" => JSON::Schema::TypeAttribute,
+          "disallow" => JSON::Schema::DisallowAttribute,
+          "format" => JSON::Schema::FormatAttribute,
+          "maximum" => JSON::Schema::MaximumInclusiveAttribute,
+          "minimum" => JSON::Schema::MinimumInclusiveAttribute,
+          "minItems" => JSON::Schema::MinItemsAttribute,
+          "maxItems" => JSON::Schema::MaxItemsAttribute,
+          "minLength" => JSON::Schema::MinLengthAttribute,
+          "maxLength" => JSON::Schema::MaxLengthAttribute,
+          "maxDecimal" => JSON::Schema::MaxDecimalAttribute,
+          "enum" => JSON::Schema::EnumAttribute,
+          "properties" => JSON::Schema::PropertiesOptionalAttribute,
+          "pattern" => JSON::Schema::PatternAttribute,
+          "additionalProperties" => JSON::Schema::AdditionalPropertiesAttribute,
+          "items" => JSON::Schema::ItemsAttribute,
+          "extends" => JSON::Schema::ExtendsAttribute
+        }
+        @uri = URI.parse("http://json-schema.org/draft-01/schema#")
+      end
+      
+      JSON::Validator.register_validator(self.new)
+    end
+    
+  end
+end

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

@@ -0,0 +1,33 @@
+module JSON
+  class Schema
+    
+    class Draft2 < Validator
+      def initialize
+        super
+        @attributes = {
+          "type" => JSON::Schema::TypeAttribute,
+          "disallow" => JSON::Schema::DisallowAttribute,
+          "format" => JSON::Schema::FormatAttribute,
+          "maximum" => JSON::Schema::MaximumInclusiveAttribute,
+          "minimum" => JSON::Schema::MinimumInclusiveAttribute,
+          "minItems" => JSON::Schema::MinItemsAttribute,
+          "maxItems" => JSON::Schema::MaxItemsAttribute,
+          "uniqueItems" => JSON::Schema::UniqueItemsAttribute,
+          "minLength" => JSON::Schema::MinLengthAttribute,
+          "maxLength" => JSON::Schema::MaxLengthAttribute,
+          "divisibleBy" => JSON::Schema::DivisibleByAttribute,
+          "enum" => JSON::Schema::EnumAttribute,
+          "properties" => JSON::Schema::PropertiesOptionalAttribute,
+          "pattern" => JSON::Schema::PatternAttribute,
+          "additionalProperties" => JSON::Schema::AdditionalPropertiesAttribute,
+          "items" => JSON::Schema::ItemsAttribute,
+          "extends" => JSON::Schema::ExtendsAttribute
+        }
+        @uri = URI.parse("http://json-schema.org/draft-02/schema#")
+      end
+      
+      JSON::Validator.register_validator(self.new)
+    end
+    
+  end
+end

data/test/test_jsonschema_draft1.rb

@@ -0,0 +1,760 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/json-schema'
+
+class JSONSchemaDraft1Test < Test::Unit::TestCase
+  def test_types
+    # Set up the default datatype
+    schema = {
+      "properties" => {
+        "a" => {}
+      }
+    }
+    data = {
+      "a" => nil
+    }
+    
+    # Test integers
+    schema["properties"]["a"]["type"] = "integer"
+    data["a"] = 5
+    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+
+    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
+    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+
+    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
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+
+    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
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+
+    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"] = {}
+    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+
+    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"] = []
+    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+
+    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
+    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+
+    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
+    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+
+    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 = {
+      "properties" => {
+        "a" => {"type" => "string"}
+      }
+    }
+    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 = {
+      "properties" => {
+        "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 = {
+      "properties" => {
+        "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 = {
+      "properties" => {
+        "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 = {
+      "properties" => {
+        "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 = {
+      "properties" => {
+        "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 = {
+      "properties" => {
+        "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 = {
+      "properties" => {
+        "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 = {
+      "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(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 = {
+      "properties" => {
+        "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 = {
+      "properties" => {
+        "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 = {
+      "properties" => {
+        "a" => { "type" => "integer" }
+      },
+      "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"
+    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+    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"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "1.1.1.300"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => 5}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "1.1.1"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "1.1.1.1b"}
+    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"}
+    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "1111:2222:8888::eeee:ffff"}
+    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "1111:2222:8888:99999:aaaa:cccc:eeee:ffff"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "1111:2222:8888:9999:aaaa:cccc:eeee:gggg"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "1111:2222::9999::cccc:eeee:ffff"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    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"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "12:00:60"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "12:60:00"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "24:00:00"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "0:00:00"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "-12:00:00"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    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"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "n2010-01-01"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "2010-1-01"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "2010-01-1"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    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"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "2010-13-01T12:00:00Z"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "2010-01-01T24:00:00Z"}
+    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => "2010-01-01T12:60:00Z"}
+    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_strings
+    data1 = {"a" => "boo"}
+    data2 = {"a" => 5}
+    
+    schema = {
+      "type" => "object",
+      "properties" => { "a" => {"format" => "regex"}}
+    }
+    assert(JSON::Validator.validate(schema,data1,:version => :draft1))
+    assert(!JSON::Validator.validate(schema,data2,:version => :draft1))
+    
+    schema = {
+      "type" => "object",
+      "properties" => { "a" => {"format" => "color"}}
+    }
+    assert(JSON::Validator.validate(schema,data1))
+    assert(!JSON::Validator.validate(schema,data2))
+    
+    schema = {
+      "type" => "object",
+      "properties" => { "a" => {"format" => "style"}}
+    }
+    assert(JSON::Validator.validate(schema,data1,:version => :draft1))
+    assert(!JSON::Validator.validate(schema,data2,:version => :draft1))
+    
+    schema = {
+      "type" => "object",
+      "properties" => { "a" => {"format" => "phone"}}
+    }
+    assert(JSON::Validator.validate(schema,data1,:version => :draft1))
+    assert(!JSON::Validator.validate(schema,data2,:version => :draft1))
+    
+    schema = {
+      "type" => "object",
+      "properties" => { "a" => {"format" => "uri"}}
+    }
+    assert(JSON::Validator.validate(schema,data1,:version => :draft1))
+    assert(!JSON::Validator.validate(schema,data2,:version => :draft1))
+    
+    schema = {
+      "type" => "object",
+      "properties" => { "a" => {"format" => "email"}}
+    }
+    assert(JSON::Validator.validate(schema,data1,:version => :draft1))
+    assert(!JSON::Validator.validate(schema,data2,:version => :draft1))
+    
+    schema = {
+      "type" => "object",
+      "properties" => { "a" => {"format" => "host-name"}}
+    }
+    assert(JSON::Validator.validate(schema,data1,:version => :draft1))
+    assert(!JSON::Validator.validate(schema,data2,:version => :draft1))
+  end
+  
+  
+  def test_format_numeric
+    data1 = {"a" => "boo"}
+    data2 = {"a" => 5}
+    data3 = {"a" => 5.4}
+    
+    schema = {
+      "type" => "object",
+      "properties" => { "a" => {"format" => "utc-millisec"}}
+    }
+    assert(!JSON::Validator.validate(schema,data1,:version => :draft1))
+    assert(JSON::Validator.validate(schema,data2,:version => :draft1))
+    assert(JSON::Validator.validate(schema,data3,:version => :draft1))
+  end
+  
+end
+