json-schema 0.1.0

data/README.textile

@@ -0,0 +1,89 @@
+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 project is far from complete but is in a somewhat usable state...
+
+h2. Usage
+
+If downloading the git repo, build the gem and install it:
+
+<pre>
+$ rake package
+$ gem install pkg/json-schema-0.1.0.gem
+</pre>
+
+<pre>
+require 'rubygems'
+require 'json-schema'
+
+JSON::Validator.validate('schema.json', 'data.json')
+
+schema = {
+  "properties" => {
+    "a" => {"type" => "integer"}
+  }
+}
+
+data = {
+  "a" => 5
+}
+
+JSON::Validator.validate(schema, data)
+</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:
+
+* 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 (not much to do with validation...)
+* fragmentResolution (only handles default slash-delimited)
+* readonly
+* contentEncoding
+* pathStart
+* mediaType
+
+
+h2. To Do
+
+* Massive re-factoring - the whole validation process needs to be broken down into something a bit more manageable
+* (Much) More testing
+* Better interface to validator to allow for error messages in validation to propogate

data/lib/json-schema.rb

@@ -0,0 +1,5 @@
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/json-schema"
+
+require 'schema'
+require 'validator'
+require 'uri/file'

data/lib/json-schema/schema.rb

@@ -0,0 +1,39 @@
+require 'rubygems'
+require 'json'
+require 'pathname'
+
+module JSON
+  class Schema
+
+    attr_accessor :schema, :uri
+    
+    def initialize(schema,uri)
+      @schema = schema
+      @uri = uri
+      
+      # If there is an ID on this schema, use it to generate the URI
+      if @schema['id']
+        temp_uri = URI.parse(@schema['id'])
+        if temp_uri.relative?
+          uri.path = (Pathname.new(uri.path).parent + @schema['id']).cleanpath
+          temp_uri = uri
+        end
+        @uri = temp_uri
+      end
+      @uri.fragment = nil
+    end
+    
+    def base_uri
+      parts = @uri.to_s.split('/')
+      parts.pop
+      parts.join('/') + '/'
+    end
+    
+    def to_s
+      @schema.to_json
+    end
+  
+    
+  end
+end
+

data/lib/json-schema/uri/file.rb

@@ -0,0 +1,32 @@
+require 'uri'
+
+module URI
+
+  # Ruby does not have built-in support for filesystem URIs, and definitely does not have built-in support for
+  # using open-uri with filesystem URIs
+  class File < Generic
+    
+    COMPONENT = [
+          :scheme,  
+          :path, 
+          :fragment,
+          :host
+        ].freeze
+        
+    def initialize(*arg)
+      arg[2] = ""
+      super(*arg)
+    end
+    
+    def self.build(args)
+      tmp = Util::make_components_hash(self, args)
+      return super(tmp)
+    end
+    
+    def open(*rest, &block)
+      ::File.open(self.path, *rest, &block)
+    end
+    
+    @@schemes['FILE'] = File
+  end
+end

data/lib/json-schema/validator.rb

@@ -0,0 +1,480 @@
+require 'uri'
+require 'open-uri'
+require 'pathname'
+require 'bigdecimal'
+
+module JSON
+    class Validator
+    
+    def initialize(schema_data, data)
+      @schemas = {}
+      @base_schema = initialize_schema(schema_data)
+      @data = initialize_data(data)
+      @schemas[@base_schema.uri.to_s] = @base_schema
+      
+      build_schemas(@base_schema)
+    end  
+    
+    
+    def validate()
+      validate_schema(@base_schema, @data)
+    end
+    
+    
+    def validate_schema(current_schema, data)
+      valid = true # Actually doing true/false on validation. Return at any point if invalid
+      
+      # Check the type
+      if current_schema.schema['type']
+        valid = validate_type(current_schema.schema['type'],data,current_schema)
+      end
+      return valid if !valid
+      if current_schema.schema['disallow']
+        valid = !validate_type(current_schema.schema['disallow'],data,current_schema)
+      end
+      return valid if !valid
+      
+      # Check the values
+      if current_schema.schema['minimum'] && data.is_a?(Numeric)
+        valid = current_schema.schema['exclusiveMinimum'] ? data > current_schema.schema['minimum'] : data >= current_schema.schema['minimum']
+      end
+      return valid if !valid
+      
+      if current_schema.schema['maximum'] && data.is_a?(Numeric)
+        valid = current_schema.schema['exclusiveMaximum'] ? data < current_schema.schema['maximum'] : data <= current_schema.schema['maximum']
+      end
+      return valid if !valid
+      
+      if current_schema.schema['minItems'] && data.is_a?(Array)
+        valid = data.nitems >= current_schema.schema['minItems']
+      end
+      return valid if !valid
+      
+      if current_schema.schema['maxItems'] && data.is_a?(Array)
+        valid = data.nitems <= current_schema.schema['maxItems']
+      end
+      return valid if !valid
+      
+      if current_schema.schema['uniqueItems'] && data.is_a?(Array)
+        d = data.clone
+        dupes = d.uniq!
+        valid = dupes.nil?
+      end
+      return valid if !valid
+      
+      if current_schema.schema['pattern'] && data.is_a?(String)
+        r = Regexp.new(current_schema.schema['pattern'])
+        valid = !(r.match(data)).nil?
+      end
+      return valid if !valid
+      
+      if current_schema.schema['minLength'] && data.is_a?(String)
+        valid = data.length >= current_schema.schema['minLength']
+      end
+      return valid if !valid
+      
+      if current_schema.schema['maxLength'] && data.is_a?(String)
+        valid = data.length <= current_schema.schema['maxLength']
+      end
+      return valid if !valid
+      
+      if current_schema.schema['divisibleBy'] && data.is_a?(Numeric)
+        if current_schema.schema['divisibleBy'] == 0 || current_schema.schema['divisibleBy'] == 0.0
+          return false
+        else
+          valid = (BigDecimal.new(data.to_s) % BigDecimal.new(current_schema.schema['divisibleBy'].to_s)).to_f == 0
+        end
+      end
+      return valid if !valid
+      
+      if current_schema.schema['enum']
+        valid = current_schema.schema['enum'].include?(data)
+      end
+      return valid if !valid
+      
+      
+      if current_schema.schema['properties'] && data.is_a?(Hash)
+        current_schema.schema['properties'].each do |property,property_schema|
+          valid = false if (property_schema['required'] && !data.has_key?(property))
+          
+          if data.has_key?(property)
+            schema = JSON::Schema.new(property_schema,current_schema.uri)
+            valid = validate_schema(schema, data[property])
+          end
+          return valid if !valid
+        end
+      end
+      return valid if !valid
+      
+      if current_schema.schema['patternProperties'] && data.is_a?(Hash)
+        current_schema.schema['properties'].each do |property,property_schema|
+          
+          r = Regexp.new(property)
+          
+          # Check each key in the data hash to see if it matches the regex
+          data.each do |key,value|
+            if r.match(key)
+              schema = JSON::Schema.new(property_schema,current_schema.uri)
+              valid = validate_schema(schema, data[key])
+            end
+            return valid if !valid
+          end
+        end
+      end
+      return valid if !valid
+      
+      if current_schema.schema['additionalProperties'] && 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
+          valid = extra_properties.empty?
+        elsif current_schema.schema['additionalProperties'].is_a?(Hash)
+          data.each do |key,value|
+            schema = JSON::Schema.new(current_schema.schema['additionalProperties'],current_schema.uri)
+            valid = validate_schema(schema,value)
+            return valid if !valid
+          end
+        end
+      end
+      return valid if !valid
+      
+      if current_schema.schema['items'] && data.is_a?(Array)
+        if current_schema.schema['items'].is_a?(Hash)
+          data.each do |item|
+            schema = JSON::Schema.new(current_schema.schema['items'],current_schema.uri)
+            valid = validate_schema(schema,item)
+            return valid if !valid
+          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)
+            valid = validate_schema(schema,data[i])
+            return valid if !valid
+          end
+        end
+      end
+      return valid if !valid
+      
+      if current_schema.schema['additionalItems'] && data.is_a?(Array) && current_schema.schema['items'].is_a?(array)
+        if current_schema.schema['additionalItems'] == false
+          return current_schema.schema['additionalItems'].length == data.length
+        elsif current_schema.schema['additionaItems'].is_a?(Hash)
+          data.each do |item|
+            schema = JSON::Schema.new(current_schema.schema['additionalItems'],current_schema.uri)
+            valid = validate_schema(schema, item)
+            return valid if !valid
+          end
+        end
+      end
+      return valid if !valid
+      
+      if current_schema.schema['dependences'] && data.is_a?(Hash)
+        current_schema.schema['dependencies'].each do |property,dependency_value|
+          if data.has_key?(property)
+            if dependency_value.is_a?(String)
+              valid = data.has_key?(dependency_value)
+            elsif dependency_value.is_a?(Array)
+              dependency_value.each do |value|
+                valid = data.has_key?(value)
+                break if !valid
+              end
+            else
+              schema = JSON::Schema.new(dependency_value,current_schema.uri)
+              valid = validate_schema(schema, data)
+            end
+            return valid if !valid
+          end
+        end
+      end
+      return valid if !valid
+      
+      # We're referencing another schema
+      if current_schema.schema['$ref']
+        temp_uri = URI.parse(current_schema.schema['$ref'])
+        if temp_uri.relative?
+          temp_uri = current_schema.uri.clone
+          temp_uri.path = (Pathname.new(current_schema.uri.path).parent + current_schema.schema['$ref'].split("#")[0]).cleanpath
+          temp_uri.fragment = current_schema.schema['$ref'].split("#")[1]
+        end
+        temp_uri.fragment = "" if temp_uri.fragment.nil?
+        
+        # Grab the parent schema from the schema list
+        schema_key = temp_uri.to_s.split("#")[0]
+        ref_schema = @schemas[schema_key]
+        
+        if ref_schema
+          # Perform fragment resolution to retrieve the appropriate level for the schema
+          target_schema = ref_schema.schema
+          fragments = temp_uri.fragment.split("/")
+          fragments.each do |fragment|
+            if fragment && fragment != ''
+              if target_schema.is_a?(Array)
+                target_schema = target_schema[fragment.to_i]
+              else
+                target_schema = target_schema[fragment]
+              end
+            end
+          end
+          
+          # We have the schema finally, build it and validate!
+          schema = JSON::Schema.new(target_schema,temp_uri)
+          valid = validate_schema(schema, data)
+        end 
+      end
+      
+      if current_schema.schema['extends']
+        schemas = current_schema.schema['extends']
+        schemas = [schemas] if !schema.is_a?(Array)
+        schemas.each do |s|
+          schema = JSON::Schema.new(s,current_schema.uri)
+          valid = validate_schema(schema, item)
+          return valid if !valid
+        end
+      end
+      
+      valid
+    end
+    
+    
+    def validate_type(types, data,current_schema)
+      union = true
+      if !types.is_a?(Array)
+        types = [types]
+        union = true
+      end
+      valid = false
+      
+      types.each do |type|
+        if type.is_a?(String)
+          case type
+          when "string"
+            valid = data.is_a?(String)
+          when "number"
+            valid = data.is_a?(Numeric)
+          when "integer"
+            valid = data.is_a?(Integer)
+          when "boolean"
+            valid = (data.is_a?(TrueClass) || data.is_a?(FalseClass))
+          when "object"
+            valid = data.is_a?(Hash)
+          when "array"
+            valid = data.is_a?(Array)
+          when "null"
+            valid = data.is_a?(NilClass)
+          else
+            valid = true
+          end
+        elsif type.is_a?(Hash) && union
+          # Validate as a schema
+          schema = JSON::Schema.new(type,current_schema.uri)
+          valid = validate_schema(schema,data)
+        end
+      
+        return valid if valid
+      end
+      
+      valid
+    end
+    
+    def load_ref_schema(parent_schema,ref)
+      uri = URI.parse(ref)
+      if uri.relative?
+        uri = parent_schema.uri.clone
+        uri.path = (Pathname.new(parent_schema.uri.path).parent + ref.split("#")[0]).cleanpath
+        uri.fragment = nil
+      end
+      
+      if @schemas[uri.to_s].nil?
+        begin
+          schema = JSON::Schema.new(JSON.parse(open(uri.to_s).read), uri)
+          @schemas[uri.to_s] = schema
+          build_schemas(schema)
+        rescue
+          # 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
+      end
+    end
+    
+    
+    # Build all schemas with IDs, mapping out the namespace
+    def build_schemas(parent_schema)
+      if parent_schema.schema["type"] && parent_schema.schema["type"].is_a?(Array) # If we're dealing with a Union type, there might be schemas a-brewin'
+        parent_schema.schema["type"].each_with_index do |type,i|
+          if type.is_a?(Hash) 
+            if type['$ref']
+              load_ref_schema(parent_schema, type['$ref'])
+            else
+              schema_uri = parent_schema.uri.clone
+              schema = JSON::Schema.new(type,schema_uri)
+              if type['id']
+                @schemas[schema.uri.to_s] = schema
+              end
+              build_schemas(schema)
+            end
+          end
+        end
+      end
+      
+      if parent_schema.schema["disallow"] && parent_schema.schema["disallow"].is_a?(Array) # If we're dealing with a Union type, there might be schemas a-brewin'
+        parent_schema.schema["disallow"].each_with_index do |type,i|
+          if type.is_a?(Hash)
+            if type['$ref']
+              load_ref_schema(parent_schema, type['$ref'])
+            else
+              type['id']
+              schema_uri = parent_schema.uri.clone
+              schema = JSON::Schema.new(type,schema_uri)
+              if type['id']
+                @schemas[schema.uri.to_s] = schema
+              end
+              build_schemas(schema)
+            end
+          end
+        end
+      end
+        
+      if parent_schema.schema["properties"]
+        parent_schema.schema["properties"].each do |k,v|
+          if v['$ref']
+            load_ref_schema(parent_schema, v['$ref'])
+          else
+            schema_uri = parent_schema.uri.clone
+            schema = JSON::Schema.new(v,schema_uri)
+            if v['id']
+              @schemas[schema.uri.to_s] = schema
+            end
+            build_schemas(schema)
+          end
+        end
+      end
+      
+      if parent_schema.schema["additionalProperties"].is_a?(Hash) 
+        if parent_schema.schema["additionalProperties"]["$ref"]
+          load_ref_schema(parent_schema, parent_schema.schema["additionalProperties"]["$ref"])
+        else
+          schema_uri = parent_schema.uri.clone
+          schema = JSON::Schema.new(parent_schema.schema["additionalProperties"],schema_uri)
+          if parent_schema.schema["additionalProperties"]['id']
+            @schemas[schema.uri.to_s] = schema
+          end
+          build_schemas(schema)
+        end
+      end
+      
+      if parent_schema.schema["items"]
+        items = parent_schema.schema["items"].clone
+        single = false
+        if !items.is_a?(Array)
+          items = [items]
+          single = true
+        end
+        items.each_with_index do |item,i|
+          if item['$ref']
+            load_ref_schema(parent_schema, item['$ref'])
+          else
+            schema_uri = parent_schema.uri.clone
+            schema = JSON::Schema.new(item,schema_uri)
+            if item['id']
+              @schemas[schema.uri.to_s] = schema
+            end
+            build_schemas(schema)
+          end
+        end
+      end
+      
+      if parent_schema.schema["additionalItems"].is_a?(Hash)
+        if parent_schema.schema["additionalItems"]['$ref']
+          load_ref_schema(parent_schema, parent_schema.schema["additionalItems"]['$ref'])
+        else
+          schema_uri = parent_schema.uri.clone
+          schema = JSON::Schema.new(parent_schema.schema["additionalItems"],schema_uri)
+          if parent_schema.schema["additionalItems"]['id']
+            @schemas[schema.uri.to_s] = schema
+          end
+          build_schemas(schema)
+        end
+      end
+      
+      if parent_schema.schema["dependencies"].is_a?(Hash)
+        if parent_schema.schema["dependencies"]["$ref"]
+          load_ref_schema(parent_schema, parent_schema.schema["dependencies"]['$ref'])
+        else
+          schema_uri = parent_schema.uri.clone
+          schema = JSON::Schema.new(parent_schema.schema["dependencies"],schema_uri)
+          if parent_schema.schema["dependencies"]['id']
+            @schemas[schema.uri.to_s] = schema
+          end
+          build_schemas(schema)
+        end
+      end
+    end
+        
+    
+    class << self
+      def validate(schema, data)
+        validator = JSON::Validator.new(schema, data)
+        validator.validate
+      end
+    end
+    
+    
+    private
+    
+    def initialize_schema(schema)
+      schema_uri = URI.parse("file://#{Dir.pwd}/__base_schema__.json")
+      if schema.is_a?(String)
+        begin
+          schema = JSON.parse(schema)
+        rescue
+          begin
+            # Build a uri for it
+            schema_uri = URI.parse(schema)
+            schema_uri = URI.parse("file://#{Dir.pwd}/#{schema}") if schema_uri.relative?
+            schema = JSON.parse(open(schema_uri.to_s).read)
+          rescue            
+            raise "Invalid schema: #{schema_uri.to_s}"
+          end
+        end
+      end
+      
+      JSON::Schema.new(schema,schema_uri)
+    end
+    
+    
+    def initialize_data(data)
+      # Parse the data, if any
+      if data.is_a?(String)
+        begin
+          data = JSON.parse(data)
+        rescue
+          begin
+            json_uri = URI.parse(data)
+            json_uri = URI.parse("file://#{Dir.pwd}/#{data}") if json_uri.relative?
+            data = JSON.parse(open(json_uri.to_s).read)
+          rescue
+            raise "Invalid JSON: #{json_uri.to_s}"
+          end
+        end
+      end
+      data
+    end
+    
+  end
+end

data/test/test_jsonschema.rb

@@ -0,0 +1,569 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/json-schema'
+
+class JSONSchemaTest < 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))
+
+    data["a"] = 5.2
+    assert(!JSON::Validator.validate(schema,data))
+    
+    data['a'] = 'string'
+    assert(!JSON::Validator.validate(schema,data))
+    
+    data['a'] = true
+    assert(!JSON::Validator.validate(schema,data))
+    
+    
+    # Test numbers
+    schema["properties"]["a"]["type"] = "number"
+    data["a"] = 5
+    assert(JSON::Validator.validate(schema,data))
+
+    data["a"] = 5.2
+    assert(JSON::Validator.validate(schema,data))
+    
+    data['a'] = 'string'
+    assert(!JSON::Validator.validate(schema,data))
+    
+    data['a'] = true
+    assert(!JSON::Validator.validate(schema,data))
+    
+    
+    # Test strings
+    schema["properties"]["a"]["type"] = "string"
+    data["a"] = 5
+    assert(!JSON::Validator.validate(schema,data))
+
+    data["a"] = 5.2
+    assert(!JSON::Validator.validate(schema,data))
+    
+    data['a'] = 'string'
+    assert(JSON::Validator.validate(schema,data))
+    
+    data['a'] = true
+    assert(!JSON::Validator.validate(schema,data))
+    
+    
+    # Test booleans
+    schema["properties"]["a"]["type"] = "boolean"
+    data["a"] = 5
+    assert(!JSON::Validator.validate(schema,data))
+
+    data["a"] = 5.2
+    assert(!JSON::Validator.validate(schema,data))
+    
+    data['a'] = 'string'
+    assert(!JSON::Validator.validate(schema,data))
+    
+    data['a'] = true
+    assert(JSON::Validator.validate(schema,data))
+    
+    data['a'] = false
+    assert(JSON::Validator.validate(schema,data))
+    
+    
+    # Test object
+    schema["properties"]["a"]["type"] = "object"
+    data["a"] = {}
+    assert(JSON::Validator.validate(schema,data))
+
+    data["a"] = 5.2
+    assert(!JSON::Validator.validate(schema,data))
+    
+    data['a'] = 'string'
+    assert(!JSON::Validator.validate(schema,data))
+    
+    data['a'] = true
+    assert(!JSON::Validator.validate(schema,data))
+    
+    
+    # Test array
+    schema["properties"]["a"]["type"] = "array"
+    data["a"] = []
+    assert(JSON::Validator.validate(schema,data))
+
+    data["a"] = 5.2
+    assert(!JSON::Validator.validate(schema,data))
+    
+    data['a'] = 'string'
+    assert(!JSON::Validator.validate(schema,data))
+    
+    data['a'] = true
+    assert(!JSON::Validator.validate(schema,data))
+    
+    
+    # Test null
+    schema["properties"]["a"]["type"] = "null"
+    data["a"] = nil
+    assert(JSON::Validator.validate(schema,data))
+
+    data["a"] = 5.2
+    assert(!JSON::Validator.validate(schema,data))
+    
+    data['a'] = 'string'
+    assert(!JSON::Validator.validate(schema,data))
+    
+    data['a'] = true
+    assert(!JSON::Validator.validate(schema,data))
+    
+    
+    # Test any
+    schema["properties"]["a"]["type"] = "any"
+    data["a"] = 5
+    assert(JSON::Validator.validate(schema,data))
+
+    data["a"] = 5.2
+    assert(JSON::Validator.validate(schema,data))
+    
+    data['a'] = 'string'
+    assert(JSON::Validator.validate(schema,data))
+    
+    data['a'] = true
+    assert(JSON::Validator.validate(schema,data))
+    
+    
+    # Test a union type
+    schema["properties"]["a"]["type"] = ["integer","string"]
+    data["a"] = 5
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = 'boo'
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = false
+    assert(!JSON::Validator.validate(schema,data))
+  end
+  
+  
+  
+  def test_required
+    # Set up the default datatype
+    schema = {
+      "properties" => {
+        "a" => {"required" => true}
+      }
+    }
+    data = {
+    }
+    
+    assert(!JSON::Validator.validate(schema,data))
+    data['a'] = "Hello"
+    assert(JSON::Validator.validate(schema,data))
+  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))
+    
+    data["a"] = 4
+    assert(!JSON::Validator.validate(schema,data))
+    
+    # Test a float
+    data["a"] = 5.0
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = 4.9
+    assert(!JSON::Validator.validate(schema,data))
+    
+    # Test a non-number
+    data["a"] = "a string"
+    assert(JSON::Validator.validate(schema,data))
+    
+    # Test exclusiveMinimum
+    schema["properties"]["a"]["exclusiveMinimum"] = true
+    
+    data["a"] = 6
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = 5
+    assert(!JSON::Validator.validate(schema,data))
+    
+    # Test with float
+    data["a"] = 5.00000001
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = 5.0
+    assert(!JSON::Validator.validate(schema,data))
+  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))
+    
+    data["a"] = 6
+    assert(!JSON::Validator.validate(schema,data))
+    
+    # Test a float
+    data["a"] = 5.0
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = 5.1
+    assert(!JSON::Validator.validate(schema,data))
+    
+    # Test a non-number
+    data["a"] = "a string"
+    assert(JSON::Validator.validate(schema,data))
+    
+    # Test exclusiveMinimum
+    schema["properties"]["a"]["exclusiveMaximum"] = true
+    
+    data["a"] = 4
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = 5
+    assert(!JSON::Validator.validate(schema,data))
+    
+    # Test with float
+    data["a"] = 4.9999999
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = 5.0
+    assert(!JSON::Validator.validate(schema,data))
+  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))
+    
+    data["a"] = []
+    assert(!JSON::Validator.validate(schema,data))
+    
+    # Test with a non-array
+    data["a"] = "boo"
+    assert(JSON::Validator.validate(schema,data))
+  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))
+    
+    data["a"] = ["boo","taco"]
+    assert(!JSON::Validator.validate(schema,data))
+    
+    # Test with a non-array
+    data["a"] = "boo"
+    assert(JSON::Validator.validate(schema,data))
+  end
+  
+  
+  
+  def test_unique_items
+    # Set up the default datatype
+    schema = {
+      "properties" => {
+        "a" => {"uniqueItems" => true}
+      }
+    }
+    
+    data = {
+      "a" => nil
+    }
+    
+    # Test with nulls
+    data["a"] = [nil,5]
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = [nil,nil]
+    assert(!JSON::Validator.validate(schema,data))
+    
+    # Test with booleans
+    data["a"] = [true,4]
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = [true,false]
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = [true,true]
+    assert(!JSON::Validator.validate(schema,data))
+    
+    # Test with numbers
+    data["a"] = [4,true]
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = [4,4.1]
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = [4,4]
+    assert(!JSON::Validator.validate(schema,data))
+    
+    # Test with strings
+    data["a"] = ['a',true]
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = ['a','ab']
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = ['a','a']
+    assert(!JSON::Validator.validate(schema,data))
+    
+    # Test with arrays
+    data["a"] = [[1],true]
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = [[1,2],[1,3]]
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = [[1,2,3],[1,2,3]]
+    assert(!JSON::Validator.validate(schema,data))
+    
+    # Test with objects
+    data["a"] = [{"a" => 1},true]
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = [{"a" => 1},{"a" => 2}]
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = [{"a" => 1, "b" => 2}, {"a" => 1, "b" => 2}]
+    assert(!JSON::Validator.validate(schema,data))
+  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))
+    
+    data["a"] = "taco"
+    assert(!JSON::Validator.validate(schema,data))
+    
+    # Test a non-string
+    data["a"] = 5
+    assert(JSON::Validator.validate(schema,data))
+  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))
+    
+    data["a"] = ""
+    assert(!JSON::Validator.validate(schema,data))
+    
+    # Try out non-string
+    data["a"] = 5
+    assert(JSON::Validator.validate(schema,data))
+  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))
+    
+    data["a"] = "tt"
+    assert(!JSON::Validator.validate(schema,data))
+    
+    # Try out non-string
+    data["a"] = 5
+    assert(JSON::Validator.validate(schema,data))
+  end
+  
+  
+  def test_enum
+    # Set up the default datatype
+    schema = {
+      "properties" => {
+        "a" => {"enum" => [1,'boo',[1,2,3],{"a" => "b"}]}
+      }
+    }
+    
+    data = {
+      "a" => nil
+    }
+    
+    # Make sure all of the above are valid...
+    data["a"] = 1
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = 'boo'
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = [1,2,3]
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = {"a" => "b"}
+    assert(JSON::Validator.validate(schema,data))
+    
+    # Test something that doesn't exist
+    data["a"] = 'taco'
+    assert(!JSON::Validator.validate(schema,data))
+    
+    # Try it without the key
+    data = {}
+    assert(JSON::Validator.validate(schema,data))
+  end
+  
+  
+  def test_divisible_by
+    # Set up the default datatype
+    schema = {
+      "properties" => {
+        "a" => {"divisibleBy" => 1.1}
+      }
+    }
+    
+    data = {
+      "a" => nil
+    }
+    
+    data["a"] = 3.3
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = 3.4
+    assert(!JSON::Validator.validate(schema,data))
+    
+    schema["properties"]["a"]["divisibleBy"] = 2.0
+    
+    data["a"] = 4.0
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = 'boo'
+    assert(JSON::Validator.validate(schema,data))
+    
+    data["a"] = 5
+    schema["properties"]["a"]["divisibleBy"] = 0
+    assert(!JSON::Validator.validate(schema,data))
+  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))
+    
+    data["a"] = 5
+    assert(!JSON::Validator.validate(schema,data))
+    
+    
+    schema["properties"]["a"]["disallow"] = ["integer","string"]
+    data["a"] = 'string'
+    assert(!JSON::Validator.validate(schema,data))
+    
+    data["a"] = 5
+    assert(!JSON::Validator.validate(schema,data))
+    
+    data["a"] = false
+    assert(JSON::Validator.validate(schema,data))
+
+  end
+  
+  
+end
+

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: json-schema
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Kenny Hoxworth
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-24 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: A Ruby JSON Schema Validator based on JSON Schema draft 03
+email: hoxworth@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.textile
+files: 
+- lib/json-schema.rb
+- lib/json-schema/schema.rb
+- lib/json-schema/validator.rb
+- lib/json-schema/uri/file.rb
+- README.textile
+- test/test_jsonschema.rb
+has_rdoc: true
+homepage: http://github.com/hoxworth/json-schema/tree/master
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby JSON Schema Validator
+test_files: 
+- test/test_jsonschema.rb