json-schema 0.1.12 → 0.1.13

data/README.textile

@@ -1,6 +1,6 @@
 h1. Ruby JSON Schema Validator
 
-This library is intended to provide Ruby with an interface for validating JSON objects against a JSON schema conforming to "JSON Schema Draft 3":http://tools.ietf.org/html/draft-zyp-json-schema-03. The project originally started as a fork of "Constellation's ruby-jsonschema":https://github.com/Constellation/ruby-jsonchema project, but differences in the JSON schema draft versions implemented as well as assumptions made by the ruby-jsonschema library forced this to become a new project.
+This library is intended to provide Ruby with an interface for validating JSON objects against a JSON schema conforming to "JSON Schema Draft 3":http://tools.ietf.org/html/draft-zyp-json-schema-03. 
 
 h2. Usage
 
@@ -13,8 +13,8 @@ gem install json-schema
 If downloading the git repo, build the gem and install it:
 
 <pre>
-$ rake package
-$ gem install pkg/json-schema-0.1.6.gem
+$ gem build json-schema.gemspec
+$ gem install json-schema-0.1.13.gem
 </pre>
 
 <pre>
@@ -51,56 +51,21 @@ end
 </pre>
   
 
-h2. Currently implemented
-
-The following core schema definitions are currently implemented:
-
-* type
-* properties
-* patternProperties
-* additionalProperties
-* items
-* additionalItems
-* required
-* dependencies
-* minimum
-* maximum
-* exclusiveMinimum
-* exclusiveMaximum
-* minItems
-* maxItems
-* uniqueItems
-* pattern
-* minLength
-* maxLength
-* enum
-* title
-* description
-* divisibleBy
-* disallow
-* extends
-* id
-* $ref (this implementation only follows slash-delimited fragment resolution)
-
-
-h2. Not implemented
-
-The following core schema definitions are not implemented:
-
-* format - Some of the formats listed will be supported, others are fairly vague in their definition and may be left out
+h2. Notes
+
+The following core schema attributes are not implemented:
+
 * default - This library aims to solely be a validator and does not modify an object it is validating.
 * $schema - Support for this will come later, possibly with the ability to validate against other JSON Schema draft versions
 
-In addition, the following hyper schema attributes are not implemented at this time:
-
-* links
-* fragmentResolution (only handles default slash-delimited)
-* contentEncoding
-* pathStart
+The 'format' attribute is only validated for the following values:
 
+* date-time
+* date
+* time
+* ip-address
+* ipv6
 
-h2. To Do
+All other 'format' attribute values are simply checked to ensure the instance value is of the correct datatype (e.g., an instance value is validated to be an integer or a float in the case of 'utc-millisec').
 
-* (Much) More testing
-* Documentation
-* Breaking the current validator out into a subclass, acting as the foundation for supporting multiple versions of validators
+Additionally, JSON::Validator does not handle any json hyperschema attributes.

data/lib/json-schema/validator.rb

@@ -3,6 +3,7 @@ require 'open-uri'
 require 'pathname'
 require 'bigdecimal'
 require 'digest/sha1'
+require 'date'
 
 module JSON
   
@@ -48,6 +49,7 @@ module JSON
       "additionalItems",
       "dependencies",
       "extends",
+      "format",
       "$ref"
     ]
     
@@ -175,6 +177,108 @@ module JSON
     end
     
     
+    # Validate the format of an item
+    def validate_format(current_schema, data, fragments)
+      case current_schema.schema['format']
+      
+      # Timestamp in restricted ISO-8601 YYYY-MM-DDThh:mm:ssZ
+      when 'date-time'
+        error_message = "The property '#{build_fragment(fragments)}' must be a string and be a date/time in the ISO-8601 format of YYYY-MM-DDThh:mm:ssZ"
+        raise ValidationError.new(error_message, fragments, current_schema) if !data.is_a?(String)
+        r = Regexp.new('^\d\d\d\d-\d\d-\d\dT(\d\d):(\d\d):(\d\d)Z$')
+        if (m = r.match(data))
+          parts = data.split("T")
+          begin
+            Date.parse(parts[0])
+          rescue Exception
+            raise ValidationError.new(error_message, fragments, current_schema)
+          end
+          begin
+            raise ValidationError.new(error_message, fragments, current_schema) if m[1].to_i > 23
+            raise ValidationError.new(error_message, fragments, current_schema) if m[2].to_i > 59
+            raise ValidationError.new(error_message, fragments, current_schema) if m[3].to_i > 59
+          rescue Exception
+            raise ValidationError.new(error_message, fragments, current_schema)
+          end
+        else
+          raise ValidationError.new(error_message, fragments, current_schema)
+        end
+        
+      # Date in the format of YYYY-MM-DD
+      when 'date'
+        error_message = "The property '#{build_fragment(fragments)}' must be a string and be a date in the format of YYYY-MM-DD"
+        raise ValidationError.new(error_message, fragments, current_schema) if !data.is_a?(String)
+        r = Regexp.new('^\d\d\d\d-\d\d-\d\d$')
+        if (m = r.match(data))
+          begin
+            Date.parse(data)
+          rescue Exception
+            raise ValidationError.new(error_message, fragments, current_schema)
+          end
+        else
+          raise ValidationError.new(error_message, fragments, current_schema)
+        end
+        
+      # Time in the format of HH:MM:SS
+      when 'time'
+        error_message = "The property '#{build_fragment(fragments)}' must be a string and be a time in the format of hh:mm:ss"
+        raise ValidationError.new(error_message, fragments, current_schema) if !data.is_a?(String)
+        r = Regexp.new('^(\d\d):(\d\d):(\d\d)$')
+        if (m = r.match(data))
+          raise ValidationError.new(error_message, fragments, current_schema) if m[1].to_i > 23
+          raise ValidationError.new(error_message, fragments, current_schema) if m[2].to_i > 59
+          raise ValidationError.new(error_message, fragments, current_schema) if m[3].to_i > 59
+        else
+          raise ValidationError.new(error_message, fragments, current_schema)
+        end
+        
+      # IPv4 in dotted-quad format
+      when 'ip-address', 'ipv4'
+        error_message = "The property '#{build_fragment(fragments)}' must be a string and be a valid IPv4 address"
+        raise ValidationError.new(error_message, fragments, current_schema) if !data.is_a?(String)
+        r = Regexp.new('^(\d+){1,3}\.(\d+){1,3}\.(\d+){1,3}\.(\d+){1,3}$')
+        if (m = r.match(data))
+          1.upto(4) do |x|
+            raise ValidationError.new(error_message, fragments, current_schema) if m[x].to_i > 255
+          end
+        else
+          raise ValidationError.new(error_message, fragments, current_schema)
+        end
+        
+      # IPv6 in standard format (including abbreviations)
+      when 'ipv6'
+        error_message = "The property '#{build_fragment(fragments)}' must be a string and be a valid IPv6 address"
+        raise ValidationError.new(error_message, fragments, current_schema) if !data.is_a?(String)
+        r = Regexp.new('^[a-f0-9:]+$')
+        if (m = r.match(data))
+          # All characters are valid, now validate structure
+          parts = data.split(":")
+          raise ValidationError.new(error_message, fragments, current_schema) if parts.length > 8
+          condensed_zeros = false
+          parts.each do |part|
+            if part.length == 0
+              raise ValidationError.new(error_message, fragments, current_schema) if condensed_zeros
+              condensed_zeros = true
+            end
+            raise ValidationError.new(error_message, fragments, current_schema) if part.length > 4
+          end
+        else
+          raise ValidationError.new(error_message, fragments, current_schema)
+        end
+        
+      # Milliseconds since the epoch. Must be an integer or a float
+      when 'utc-millisec'
+        error_message = "The property '#{build_fragment(fragments)}' must be an integer or a float"
+        raise ValidationError.new(error_message, fragments, current_schema) if (!data.is_a?(Numeric))
+
+      # Must be a string
+      when 'regex','color','style','phone','uri','email','host-name'
+        error_message = "The property '#{build_fragment(fragments)}' must be a string"
+        raise ValidationError.new(error_message, fragments, current_schema) if (!data.is_a?(String))
+      end
+    end
+    
+    
     # Validate the minimum value of a number
     def validate_minimum(current_schema, data, fragments)
       if data.is_a?(Numeric)

data/test/test_jsonschema.rb

@@ -744,5 +744,206 @@ class JSONSchemaTest < Test::Unit::TestCase
     
   end
   
+  
+  def test_self_reference
+    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 = {
+      "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"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "1.1.1.300"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => 5}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "1.1.1"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "1.1.1.1b"}
+    assert(!JSON::Validator.validate(schema,data))
+    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))
+    data = {"a" => "1111:0:8888:0:0:0:eeee:ffff"}
+    assert(JSON::Validator.validate(schema,data))
+    data = {"a" => "1111:2222:8888::eeee:ffff"}
+    assert(JSON::Validator.validate(schema,data))
+    data = {"a" => "1111:2222:8888:99999:aaaa:cccc:eeee:ffff"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "1111:2222:8888:9999:aaaa:cccc:eeee:gggg"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "1111:2222::9999::cccc:eeee:ffff"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "1111:2222:8888:9999:aaaa:cccc:eeee:ffff:bbbb"}
+    assert(!JSON::Validator.validate(schema,data))
+  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))
+    data = {"a" => "12:00"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "12:00:60"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "12:60:00"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "24:00:00"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "0:00:00"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "-12:00:00"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "12:00:00b"}
+    assert(!JSON::Validator.validate(schema,data))
+  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))
+    data = {"a" => "2010-01-32"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "n2010-01-01"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "2010-1-01"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "2010-01-1"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "2010-01-01n"}
+    assert(!JSON::Validator.validate(schema,data))
+  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))
+    data = {"a" => "2010-01-32T12:00:00Z"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "2010-13-01T12:00:00Z"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "2010-01-01T24:00:00Z"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "2010-01-01T12:60:00Z"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "2010-01-01T12:00:60Z"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "2010-01-01T12:00:00"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "2010-01-01T12:00:00z"}
+    assert(!JSON::Validator.validate(schema,data))
+    data = {"a" => "2010-01-0112:00:00Z"}
+    assert(!JSON::Validator.validate(schema,data))
+  end
+  
+  
+  def test_format_strings
+    data1 = {"a" => "boo"}
+    data2 = {"a" => 5}
+    
+    schema = {
+      "type" => "object",
+      "properties" => { "a" => {"format" => "regex"}}
+    }
+    assert(JSON::Validator.validate(schema,data1))
+    assert(!JSON::Validator.validate(schema,data2))
+    
+    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))
+    assert(!JSON::Validator.validate(schema,data2))
+    
+    schema = {
+      "type" => "object",
+      "properties" => { "a" => {"format" => "phone"}}
+    }
+    assert(JSON::Validator.validate(schema,data1))
+    assert(!JSON::Validator.validate(schema,data2))
+    
+    schema = {
+      "type" => "object",
+      "properties" => { "a" => {"format" => "uri"}}
+    }
+    assert(JSON::Validator.validate(schema,data1))
+    assert(!JSON::Validator.validate(schema,data2))
+    
+    schema = {
+      "type" => "object",
+      "properties" => { "a" => {"format" => "email"}}
+    }
+    assert(JSON::Validator.validate(schema,data1))
+    assert(!JSON::Validator.validate(schema,data2))
+    
+    schema = {
+      "type" => "object",
+      "properties" => { "a" => {"format" => "host-name"}}
+    }
+    assert(JSON::Validator.validate(schema,data1))
+    assert(!JSON::Validator.validate(schema,data2))
+  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))
+    assert(JSON::Validator.validate(schema,data2))
+    assert(JSON::Validator.validate(schema,data3))
+  end
+  
+  
+  
 end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: json-schema
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 1
   prerelease: false
   segments: 
   - 0
   - 1
-  - 12
-  version: 0.1.12
+  - 13
+  version: 0.1.13
 platform: ruby
 authors: 
 - Kenny Hoxworth
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-15 00:00:00 -05:00
+date: 2011-02-16 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -45,9 +45,9 @@ files:
 - lib/json-schema/uri/file.rb
 - lib/json-schema/validator.rb
 - lib/json-schema.rb
+- README.textile
 - test/test_files.rb
 - test/test_jsonschema.rb
-- README.textile
 has_rdoc: true
 homepage: http://github.com/hoxworth/json-schema/tree/master
 licenses: []