seomoz-json-schema 1.0.1

data/README.textile

@@ -0,0 +1,216 @@
+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. Legacy support for "JSON Schema Draft 2":http://tools.ietf.org/html/draft-zyp-json-schema-02 and "JSON Schema Draft 1":http://tools.ietf.org/html/draft-zyp-json-schema-01 is also included.
+
+h2. Dependencies
+
+The JSON::Schema library has no dependencies if the validation methods are called using Ruby objects. However, either the <code>json</code> or the <code>yajl-ruby</code> gem needs to be installed to validate JSON strings or files containing JSON data.
+
+h2. Installation
+
+From rubygems.org:
+
+<pre>
+gem install json-schema
+</pre>
+
+From the git repo:
+
+<pre>
+$ gem build json-schema.gemspec
+$ gem install json-schema-1.0.1.gem
+</pre>
+
+
+h2. Usage
+
+Three base validation methods exist: <code>validate</code>, <code>validate!</code>, and <code>fully_validate</code>. The first returns a boolean on whether a validation attempt passes and the second will throw a <code>JSON::Schema::ValidationError</code> with an appropriate message/trace on where the validation failed. The third validation method does not immediately fail upon a validation error and instead builds an array of validation errors return when validation is complete.
+
+All 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. An optional third options argument is also accepted; available options are used in the examples below.
+
+By default, the validator uses 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. Legacy support for Draft 1 and Draft 2 is included by either passing an optional <code>:version</code> parameter to the <code>validate</code> method (set either as <code>:draft1</code> or <code>draft2</code>), or by declaring the <code>$schema</code> attribute in the schema and referencing the appropriate specification URI. Note that the <code>$schema</code> attribute takes precedence over the <code>:version</code> option during parsing and validation.
+
+h3. Validate Ruby objects against a Ruby schema
+
+<pre>
+require 'rubygems'
+require 'json-schema'
+
+schema = {
+  "type" => "object",
+  "properties" => {
+    "a" => {"type" => "integer", "required" => true}
+  }
+}
+
+data = {
+  "a" => 5
+}
+
+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>
+
+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.validate!(schema, data)
+rescue JSON::Schema::ValidationError
+  puts $!.message
+end
+</pre>
+
+h3. Validate a JSON object against a JSON schema object, while also validating the schema itself
+
+<pre>
+require 'rubygems'
+require 'json-schema'
+
+schema = {
+  "type" => "object",
+  "properties" => {
+    "a" => {"type" => "integer", "required" => "true"}  # This will fail schema validation!
+  }
+}
+
+data = {
+  "a" => 5
+}
+
+JSON::Validator.validate(schema, data, :validate_schema => true)
+</pre>
+
+h3. Validate an object against a JSON Schema Draft 2 schema
+
+<pre>
+require 'rubygems'
+require 'json-schema'
+
+schema = {
+  "type" => "object",
+  "properties" => {
+    "a" => {"type" => "integer", "optional" => true}
+  }
+}
+
+data = {
+  "a" => 5
+}
+
+JSON::Validator.validate(schema, data, :version => :draft2)
+</pre>
+
+
+h3. Extend an existing schema and validate 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. JSON Backends
+
+The JSON::Schema library currently supports the <code>json</code> and <code>yajl-ruby</code> backend JSON parsers. If either of these libraries are installed, they will be automatically loaded and used to parse any JSON strings supplied by the user.
+
+If more than one of the supported JSON backends are installed, the <code>yajl-ruby</code> parser is used by default. This can be changed by issuing the following before validation:
+
+<pre>
+JSON::Validator.json_backend = :json
+</pre>
+  
+
+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.
+
+The 'format' attribute is only validated for the following values:
+
+* date-time
+* date
+* time
+* ip-address
+* ipv6
+
+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').
+
+Additionally, JSON::Validator does not handle any json hyperschema attributes.

data/lib/json-schema.rb

@@ -0,0 +1,13 @@
+require 'multi_json'
+# Force MultiJson to load an engine before we define the JSON constant here; otherwise,
+# it looks for things that are under the JSON namespace that aren't there (since we have defined it here)
+MultiJson.engine
+
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/json-schema"
+
+require 'rubygems'
+require 'schema'
+require 'validator'
+Dir[File.join(File.dirname(__FILE__), "json-schema/attributes/*.rb")].each {|file| require file }
+Dir[File.join(File.dirname(__FILE__), "json-schema/validators/*.rb")].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"
+            validation_error(message, fragments, current_schema, options[:record_errors])
+          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, options)
+                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 #{extra_properties.inspect} outside of the schema when none are allowed"
+            validation_error(message, fragments, current_schema, options[:record_errors])
+          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,options)
+              fragments.pop
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+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)
+                if !data.has_key?(dependency_value)
+                  message = "The property '#{build_fragment(fragments)}' has a property '#{property}' that depends on a missing property '#{dependency_value}'"
+                  validation_error(message, fragments, current_schema, options[:record_errors])
+                end
+              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}'"
+                    validation_error(message, fragments, current_schema, options[:record_errors])
+                  end
+                end
+              else
+                schema = JSON::Schema.new(dependency_value,current_schema.uri,validator)
+                schema.validate(data, fragments, options)
+              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}.merge(options))
+        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']}"
+             validation_error(message, fragments, current_schema, options[:record_errors])
+          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)}' value #{data.inspect} 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!
+          validation_error(message, fragments, current_schema, options[:record_errors])
+        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, options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+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'
+          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"
+            validation_error(error_message, fragments, current_schema, 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)Z$')
+            if (m = r.match(data))
+              parts = data.split("T")
+              begin
+                Date.parse(parts[0])
+              rescue Exception
+                validation_error(error_message, fragments, current_schema, options[:record_errors])
+                return
+              end
+              begin
+                validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if m[1].to_i > 23
+                validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if m[2].to_i > 59
+                validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if m[3].to_i > 59
+              rescue Exception
+                validation_error(error_message, fragments, current_schema, options[:record_errors])
+                return
+              end
+            else
+              validation_error(error_message, fragments, current_schema, options[:record_errors])
+              return
+            end
+          end
+
+        # Date in the format of YYYY-MM-DD
+        when 'date'
+          if data.is_a?(String)
+            error_message = "The property '#{build_fragment(fragments)}' must be a date in the format of YYYY-MM-DD"
+            validation_error(error_message, fragments, current_schema, options[:record_errors]) and return 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
+                validation_error(error_message, fragments, current_schema, options[:record_errors])
+                return
+              end
+            else
+              validation_error(error_message, fragments, current_schema, options[:record_errors])
+              return
+            end
+          end
+
+        # Time in the format of HH:MM:SS
+        when 'time'
+          if data.is_a?(String)
+            error_message = "The property '#{build_fragment(fragments)}' must be a time in the format of hh:mm:ss"
+            validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if !data.is_a?(String)
+            r = Regexp.new('^(\d\d):(\d\d):(\d\d)$')
+            if (m = r.match(data))
+              validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if m[1].to_i > 23
+              validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if m[2].to_i > 59
+              validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if m[3].to_i > 59
+            else
+              validation_error(error_message, fragments, current_schema, options[:record_errors])
+              return
+            end
+          end
+
+        # IPv4 in dotted-quad format
+        when 'ip-address', 'ipv4'
+          if data.is_a?(String)
+            error_message = "The property '#{build_fragment(fragments)}' must be a valid IPv4 address"
+            validation_error(error_message, fragments, current_schema, options[:record_errors]) and return 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|
+                validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if m[x].to_i > 255
+              end
+            else
+              validation_error(error_message, fragments, current_schema, options[:record_errors])
+              return
+            end
+          end
+
+        # IPv6 in standard format (including abbreviations)
+        when 'ipv6'
+          if data.is_a?(String)
+            error_message = "The property '#{build_fragment(fragments)}' must be a valid IPv6 address"
+            validation_error(error_message, fragments, current_schema, options[:record_errors]) and return 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(":")
+              validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if parts.length > 8
+              condensed_zeros = false
+              parts.each do |part|
+                if part.length == 0
+                  validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if condensed_zeros
+                  condensed_zeros = true
+                end
+                validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if part.length > 4
+              end
+            else
+              validation_error(error_message, fragments, current_schema, options[:record_errors])
+              return
+            end
+          end
+        end
+      end
+    end
+  end
+end