json-schema 0.1.13 → 0.1.14

data/README.textile

@@ -2,27 +2,40 @@ 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. 
 
-h2. Usage
+h2. Dependencies
 
-Install:
+The JSON::Schema library depends on the ruby JSON gem (json). Support for YAJL and other Ruby parsers is planned.
+
+h2. Installation
+
+From rubygems.org:
 
 <pre>
 gem install json-schema
 </pre>
 
-If downloading the git repo, build the gem and install it:
+From the git repo:
 
 <pre>
 $ gem build json-schema.gemspec
-$ gem install json-schema-0.1.13.gem
+$ gem install json-schema-0.1.14.gem
 </pre>
 
+
+h2. Basic Usage
+
+Two base validation methods exist: <code>validate</code> and <code>validate!</code>. The first returns a boolean on whether a validation attempt passes and the latter will throw a <code>JSON::Schema::ValidationError</code> with an appropriate message/trace on where the validation failed.
+
+Both methods take two arguments, which can be either a JSON string, a file containing JSON, or a Ruby object representing JSON data. The first argument to these methods is always the schema, the second is always the data to validate.
+
+By default, the validator uses (and only supports) the "JSON Schema Draft 3":http://tools.ietf.org/html/draft-zyp-json-schema-03 specification for validation; however, the user is free to specify additional specifications or extend existing ones.
+
+h3. Validate Ruby objects against a Ruby schema
+
 <pre>
 require 'rubygems'
 require 'json-schema'
 
-JSON::Validator.validate('schema.json', 'data.json')
-
 schema = {
   "type" => "object",
   "properties" => {
@@ -35,20 +48,102 @@ data = {
 }
 
 JSON::Validator.validate(schema, data)
+</pre>
+
+h3. Validate a JSON string against a JSON schema file
+
+<pre>
+require 'rubygems'
+require 'json-schema'
+  
+JSON::Validator.validate('schema.json', "{'a' : 5}")
+</pre>
+
+h3. Validate a list of objects against a schema that represents the individual objects
+
+<pre>
+require 'rubygems'
+require 'json-schema'
+
+data = ['user','user','user']
+JSON::Validator.validate('user.json', data, :list => true)
+</pre>
 
-data = [data,data,data]
-JSON::Validator.validate(schema, data, :list => true)
+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"
 }
 
 begin
-  JSON::Validator.validate2(schema, data)
-rescue ValidationError
+  JSON::Validator.validate!(schema, data)
+rescue JSON::Schema::ValidationError
   puts $!.message
 end
 </pre>
+
+h3. Extend an existing schema and validating against it
+
+For this example, we are going to extend the "JSON Schema Draft 3":http://tools.ietf.org/html/draft-zyp-json-schema-03 specification by adding a 'bitwise-and' property for validation.
+
+<pre>
+require 'rubygems'
+require 'json-schema'
+  
+class BitwiseAndAttribute < JSON::Schema::Attribute
+  def self.validate(current_schema, data, fragments, validator, options = {})
+    if data.is_a?(Integer) && data & current_schema.schema['bitwise-and'].to_i == 0
+      message = "The property '#{build_fragment(fragments)}' did not evaluate  to true when bitwise-AND'd with  #{current_schema.schema['bitwise-or']}"
+      raise JSON::Schema::ValidationError.new(message, fragments, current_schema)
+    end
+  end
+end
+
+class ExtendedSchema < JSON::Schema::Validator
+  def initialize
+    super
+    extend_schema_definition("http://json-schema.org/draft-03/schema#")
+    @attributes["bitwise-and"] = BitwiseAndAttribute
+    @uri = URI.parse("http://test.com/test.json")
+  end
+  
+  JSON::Validator.register_validator(self.new)
+end
+
+schema = {
+  "$schema" => "http://test.com/test.json",
+  "properties" => {
+    "a" => {
+      "bitwise-and" => 1
+    },
+    "b" => {
+      "type" => "string"
+    }
+  }
+}
+
+data = {
+  "a" => 0
+}
+
+data = {"a" => 1, "b" => "taco"}
+JSON::Validator.validate(schema,data) # => true
+data = {"a" => 1, "b" => 5}
+JSON::Validator.validate(schema,data) # => false
+data = {"a" => 0, "b" => "taco"}
+JSON::Validator.validate(schema,data) # => false
+</pre>
   
 
 h2. Notes
@@ -56,7 +151,6 @@ 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
 
 The 'format' attribute is only validated for the following values:
 

data/lib/json-schema.rb

@@ -2,4 +2,6 @@ $LOAD_PATH.unshift "#{File.dirname(__FILE__)}/json-schema"
 
 require 'schema'
 require 'validator'
+Dir[File.join(File.dirname(__FILE__), "json-schema/attributes/*")].each {|file| require file }
+Dir[File.join(File.dirname(__FILE__), "json-schema/validators/*")].each {|file| require file }
 require 'uri/file'

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

@@ -0,0 +1,23 @@
+module JSON
+  class Schema
+    class AdditionalItemsAttribute < Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+        if data.is_a?(Array) && current_schema.schema['items'].is_a?(Array)
+          if current_schema.schema['additionalItems'] == false && current_schema.schema['items'].length != data.length
+            message = "The property '#{build_fragment(fragments)}' contains additional array elements outside of the schema when none are allowed"
+            raise ValidationError.new(message, fragments, current_schema)
+          elsif current_schema.schema['additionalItems'].is_a?(Hash)
+            schema = JSON::Schema.new(current_schema.schema['additionalItems'],current_schema.uri,validator)
+            data.each_with_index do |item,i|
+              if i >= current_schema.schema['items'].length
+                fragments << i.to_s
+                schema.validate(item, fragments)
+                fragments.pop
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module JSON
+  class Schema
+    class AdditionalPropertiesAttribute < Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+        if data.is_a?(Hash)
+          extra_properties = data.keys
+
+          if current_schema.schema['properties']
+            extra_properties = extra_properties - current_schema.schema['properties'].keys
+          end
+
+          if current_schema.schema['patternProperties']
+            current_schema.schema['patternProperties'].each_key do |key|
+              r = Regexp.new(key)
+              extras_clone = extra_properties.clone
+              extras_clone.each do |prop|
+                if r.match(prop)
+                  extra_properties = extra_properties - [prop]
+                end
+              end
+            end
+          end
+
+          if current_schema.schema['additionalProperties'] == false && !extra_properties.empty?
+            message = "The property '#{build_fragment(fragments)}' contains additional properties outside of the schema when none are allowed"
+            raise ValidationError.new(message, fragments, current_schema)
+          elsif current_schema.schema['additionalProperties'].is_a?(Hash)
+            extra_properties.each do |key|
+              schema = JSON::Schema.new(current_schema.schema['additionalProperties'],current_schema.uri,validator)
+              fragments << key
+              schema.validate(data[key],fragments)
+              fragments.pop
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module JSON
+  class Schema
+    class DependenciesAttribute < Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+        if data.is_a?(Hash)
+          current_schema.schema['dependencies'].each do |property,dependency_value|
+            if data.has_key?(property)
+              if dependency_value.is_a?(String) && !data.has_key?(dependency_value)
+                message = "The property '#{build_fragment(fragments)}' has a property '#{property}' that depends on a missing property '#{dependency_value}'"
+                raise ValidationError.new(message, fragments, current_schema)
+              elsif dependency_value.is_a?(Array)
+                dependency_value.each do |value|
+                  if !data.has_key?(value)
+                    message = "The property '#{build_fragment(fragments)}' has a property '#{property}' that depends on a missing property '#{value}'"
+                    raise ValidationError.new(message, fragments, current_schema)
+                  end
+                end
+              else
+                schema = JSON::Schema.new(dependency_value,current_schema.uri,validator)
+                schema.validate(data, fragments)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module JSON
+  class Schema
+    class DisallowAttribute < Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+        if validator.attributes['type']
+          validator.attributes['type'].validate(current_schema, data, fragments, validator, {:disallow => true})
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module JSON
+  class Schema
+    class DivisibleByAttribute < Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+        if data.is_a?(Numeric)
+          if current_schema.schema['divisibleBy'] == 0 || 
+             current_schema.schema['divisibleBy'] == 0.0 ||
+             (BigDecimal.new(data.to_s) % BigDecimal.new(current_schema.schema['divisibleBy'].to_s)).to_f != 0
+             message = "The property '#{build_fragment(fragments)}' was not divisible by #{current_schema.schema['divisibleBy']}"
+             raise ValidationError.new(message, fragments, current_schema)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module JSON
+  class Schema
+    class EnumAttribute < Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+        if !current_schema.schema['enum'].include?(data)
+          message = "The property '#{build_fragment(fragments)}' did not match one of the following values:"
+          current_schema.schema['enum'].each {|val|
+            if val.is_a?(NilClass)
+              message += " null,"
+            elsif val.is_a?(Array)
+              message += " (array),"
+            elsif val.is_a?(Hash)
+              message += " (object),"
+            else
+              message += " #{val.to_s},"
+            end
+          }
+          message.chop!
+          raise ValidationError.new(message, fragments, current_schema)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module JSON
+  class Schema
+    class ExtendsAttribute < Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+        schemas = current_schema.schema['extends']
+        schemas = [schemas] if !schemas.is_a?(Array)
+        schemas.each do |s|
+          schema = JSON::Schema.new(s,current_schema.uri,validator)
+          schema.validate(data, fragments)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+module JSON
+  class Schema
+    class FormatAttribute < Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+        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
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module JSON
+  class Schema
+    class ItemsAttribute < Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+        if data.is_a?(Array)
+           if current_schema.schema['items'].is_a?(Hash)
+             data.each_with_index do |item,i|
+               schema = JSON::Schema.new(current_schema.schema['items'],current_schema.uri,validator)
+               fragments << i.to_s
+               schema.validate(item,fragments)
+               fragments.pop
+             end
+           elsif current_schema.schema['items'].is_a?(Array)
+             current_schema.schema['items'].each_with_index do |item_schema,i|
+               schema = JSON::Schema.new(item_schema,current_schema.uri,validator)
+               fragments << i.to_s
+               schema.validate(data[i],fragments)
+               fragments.pop
+             end
+           end
+        end
+      end
+    end
+  end
+end