json-schema 0.1.13 → 0.1.14

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

@@ -0,0 +1,15 @@
+module JSON
+  class Schema
+    class MaximumAttribute < Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+        if data.is_a?(Numeric)
+          if (current_schema.schema['exclusiveMaximum'] ? data >= current_schema.schema['maximum'] : data > current_schema.schema['maximum'])
+            message = "The property '#{build_fragment(fragments)}' did not have a maximum value of #{current_schema.schema['maximum']}, "
+            message += current_schema.schema['exclusiveMaximum'] ? 'exclusively' : 'inclusively'
+            raise ValidationError.new(message, fragments, current_schema)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module JSON
+  class Schema
+    class MaxItemsAttribute < Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+        if data.is_a?(Array) && (data.compact.size > current_schema.schema['maxItems'])
+          message = "The property '#{build_fragment(fragments)}' did not contain a minimum number of items #{current_schema.schema['minItems']}"
+          raise ValidationError.new(message, fragments, current_schema)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module JSON
+  class Schema
+    class MaxLengthAttribute < Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+        if data.is_a?(String)
+          if data.length > current_schema.schema['maxLength']
+            message = "The property '#{build_fragment(fragments)}' was not of a maximum string length of #{current_schema.schema['maxLength']}"
+            raise ValidationError.new(message, fragments, current_schema)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module JSON
+  class Schema
+    class MinimumAttribute < Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+        if data.is_a?(Numeric)
+          if (current_schema.schema['exclusiveMinimum'] ? data <= current_schema.schema['minimum'] : data < current_schema.schema['minimum'])
+            message = "The property '#{build_fragment(fragments)}' did not have a minimum value of #{current_schema.schema['minimum']}, "
+            message += current_schema.schema['exclusiveMinimum'] ? 'exclusively' : 'inclusively'
+            raise ValidationError.new(message, fragments, current_schema)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module JSON
+  class Schema
+    class MinItemsAttribute < Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+        if data.is_a?(Array) && (data.compact.size < current_schema.schema['minItems'])
+          message = "The property '#{build_fragment(fragments)}' did not contain a minimum number of items #{current_schema.schema['minItems']}"
+          raise ValidationError.new(message, fragments, current_schema)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module JSON
+  class Schema
+    class MinLengthAttribute < Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+        if data.is_a?(String)
+          if data.length < current_schema.schema['minLength']
+            message = "The property '#{build_fragment(fragments)}' was not of a minimum string length of #{current_schema.schema['minLength']}"
+            raise ValidationError.new(message, fragments, current_schema)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module JSON
+  class Schema
+    class PatternAttribute < Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+        if data.is_a?(String)
+          r = Regexp.new(current_schema.schema['pattern'])
+          if (r.match(data)).nil?
+            message = "The property '#{build_fragment(fragments)}' did not match the regex '#{current_schema.schema['pattern']}'"
+            raise ValidationError.new(message, fragments, current_schema)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module JSON
+  class Schema
+    class PatternPropertiesAttribute < Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+        if data.is_a?(Hash)
+          current_schema.schema['patternProperties'].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,validator)
+                fragments << key
+                schema.validate(data[key],fragments)
+                fragments.pop
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module JSON
+  class Schema
+    class PropertiesAttribute < Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+        if data.is_a?(Hash)
+          current_schema.schema['properties'].each do |property,property_schema|
+            if (property_schema['required'] && !data.has_key?(property))
+              message = "The property '#{build_fragment(fragments)}' did not contain a required property of '#{property}'"
+              raise ValidationError.new(message, fragments, current_schema)
+            end
+          
+            if data.has_key?(property)
+              schema = JSON::Schema.new(property_schema,current_schema.uri,validator)
+              fragments << property
+              schema.validate(data[property],fragments)
+              fragments.pop
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module JSON
+  class Schema
+    class RefAttribute < Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+        temp_uri = URI.parse(current_schema.schema['$ref'])
+        if temp_uri.relative?
+          temp_uri = current_schema.uri.clone
+          # Check for absolute path
+          path = current_schema.schema['$ref'].split("#")[0]
+          if path.nil? || path == ''
+            temp_uri.path = current_schema.uri.path
+          elsif path[0,1] == "/"
+            temp_uri.path = Pathname.new(path).cleanpath.to_s
+          else
+            temp_uri.path = (Pathname.new(current_schema.uri.path).parent + path).cleanpath.to_s
+          end
+          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 = JSON::Validator.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("/")
+          fragment_path = ''
+          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
+              fragment_path = fragment_path + "/#{fragment}"
+              if target_schema.nil?
+                raise SchemaError.new("The fragment '#{fragment_path}' does not exist on schema #{ref_schema.uri.to_s}")
+              end
+            end
+          end
+
+          # We have the schema finally, build it and validate!
+          schema = JSON::Schema.new(target_schema,temp_uri,validator)
+          schema.validate(data, fragments)
+        else
+          raise ValidationError.new("The referenced schema '#{temp_uri.to_s}' cannot be found", fragments, current_schema)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module JSON
+  class Schema
+    class TypeAttribute < Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+        union = true
+
+        if options[:disallow]
+          types = current_schema.schema['disallow']
+        else
+          types = current_schema.schema['type']
+        end
+
+        if !types.is_a?(Array)
+          types = [types]
+          union = false
+        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)
+            when "any"
+              valid = true
+            else
+              valid = true
+            end
+          elsif type.is_a?(Hash) && union
+            # Validate as a schema
+            schema = JSON::Schema.new(type,current_schema.uri,validator)
+            begin
+              schema.validate(data,fragments)
+              valid = true
+            rescue ValidationError
+              # We don't care that these schemas don't validate - we only care that one validated
+            end
+          end
+
+          break if valid
+        end
+
+        if (options[:disallow])
+          if valid
+            message = "The property '#{build_fragment(fragments)}' matched one or more of the following types:"
+            types.each {|type| message += type.is_a?(String) ? " #{type}," : " (schema)," }
+            message.chop!
+            raise ValidationError.new(message, fragments, current_schema)
+          end
+        elsif !valid
+          message = "The property '#{build_fragment(fragments)}' did not match one or more of the following types:"
+          types.each {|type| message += type.is_a?(String) ? " #{type}," : " (schema)," }
+          message.chop!
+          raise ValidationError.new(message, fragments, current_schema)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module JSON
+  class Schema
+    class UniqueItemsAttribute < Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+        if data.is_a?(Array)
+          d = data.clone
+          dupes = d.uniq!
+          if dupes
+            message = "The property '#{build_fragment(fragments)}' contained duplicated array values"
+            raise ValidationError.new(message, fragments, current_schema)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json-schema/schema.rb

@@ -5,9 +5,9 @@ require 'pathname'
 module JSON
   class Schema
 
-    attr_accessor :schema, :uri
+    attr_accessor :schema, :uri, :validator
     
-    def initialize(schema,uri)
+    def initialize(schema,uri,parent_validator=nil)
       @schema = schema
       @uri = uri
       
@@ -21,6 +21,23 @@ module JSON
         @uri = temp_uri
       end
       @uri.fragment = nil
+      
+      # If there is a $schema on this schema, use it to determine which validator to use
+      if @schema['$schema']
+        u = URI.parse(@schema['$schema'])
+        @validator = JSON::Validator.validators["#{u.scheme}://#{u.host}#{u.path}"]
+        if @validator.nil?
+          raise SchemaError.new("This library does not have support for schemas defined by #{u.scheme}://#{u.host}#{u.path}")
+        end
+      elsif parent_validator
+        @validator = parent_validator
+      else
+        @validator = JSON::Validator.default_validator
+      end  
+    end
+    
+    def validate(data, fragments)
+      @validator.validate(self, data, fragments)
     end
     
     def base_uri

data/lib/json-schema/validator.rb

@@ -7,19 +7,62 @@ require 'date'
 
 module JSON
   
-  class ValidationError < Exception
-    attr_reader :fragments, :schema
+  class Schema
+    class ValidationError < Exception
+      attr_reader :fragments, :schema
+
+      def initialize(message, fragments, schema)
+        @fragments = fragments
+        @schema = schema
+        message = "#{message} in schema #{schema.uri}"
+        super(message)
+      end
+    end
+    
+    class SchemaError < Exception
+    end
+    
+    class Attribute
+      def self.validate(current_schema, data, fragments, validator, options = {})
+      end
+      
+      def self.build_fragment(fragments)
+        "#/#{fragments.join('/')}"
+      end
+    end
     
-    def initialize(message, fragments, schema)
-      @fragments = fragments
-      @schema = schema
-      message = "#{message} in schema #{schema.uri}"
-      super(message)
+    class Validator
+      attr_accessor :attributes, :uri
+      
+      def initialize()
+        @attributes = {}
+        @uri = nil
+      end
+      
+      def extend_schema_definition(schema_uri)
+        u = URI.parse(schema_uri)
+        validator = JSON::Validator.validators["#{u.scheme}://#{u.host}#{u.path}"]
+        if validator.nil?
+          raise SchemaError.new("Schema not found: #{u.scheme}://#{u.host}#{u.path}")
+        end
+        @attributes.merge!(validator.attributes)
+      end
+      
+      def to_s
+        "#{@uri.scheme}://#{uri.host}#{uri.path}"
+      end
+      
+      def validate(current_schema, data, fragments)
+        current_schema.schema.each do |attr_name,attribute|
+          if @attributes.has_key?(attr_name)
+            @attributes[attr_name].validate(current_schema, data, fragments, self)
+          end
+        end
+        data
+      end
     end
   end
   
-  class SchemaError < Exception
-  end
 
   class Validator
 
@@ -28,31 +71,8 @@ module JSON
     @@default_opts = {
       :list => false
     }
-
-    ValidationMethods = [
-      "type",
-      "disallow",
-      "minimum",
-      "maximum",
-      "minItems",
-      "maxItems",
-      "uniqueItems",
-      "pattern",
-      "minLength",
-      "maxLength",
-      "divisibleBy",
-      "enum",
-      "properties",
-      "patternProperties",
-      "additionalProperties",
-      "items",
-      "additionalItems",
-      "dependencies",
-      "extends",
-      "format",
-      "$ref"
-    ]
-    
+    @@validators = {}
+    @@default_validator = nil
     
     def initialize(schema_data, data, opts={})
       @options = @@default_opts.clone.merge(opts)
@@ -65,549 +85,12 @@ module JSON
     # Run a simple true/false validation of data against a schema
     def validate()
       begin
-        validate_schema(@base_schema, @data, [])
-        Validator.clear_cache
-        return true
-      rescue ValidationError
-        Validator.clear_cache
-        return false
-      end
-    end
-    
-    
-    # Validate data against a schema, returning nil if the data is valid. If the data is invalid, 
-    # a ValidationError will be raised with links to the specific location that the first error
-    # occurred during validation 
-    def validate2()
-      begin
-        validate_schema(@base_schema, @data, [])
+        @base_schema.validate(@data,[])
         Validator.clear_cache
-      rescue ValidationError
+      rescue JSON::Schema::ValidationError
         Validator.clear_cache
         raise $!
       end
-      nil
-    end
-    
-    
-    # Validate the current schema
-    def validate_schema(current_schema, data, fragments)
-          
-      ValidationMethods.each do |method|
-        if !current_schema.schema[method].nil?
-          self.send(("validate_" + method.sub('$','')).to_sym, current_schema, data, fragments)
-        end
-      end
-      
-      data
-    end
-    
-    
-    # Validate the type
-    def validate_type(current_schema, data, fragments, disallow=false)
-      union = true
-      
-      if disallow
-        types = current_schema.schema['disallow']
-      else
-        types = current_schema.schema['type']
-      end
-      
-      if !types.is_a?(Array)
-        types = [types]
-        union = false
-      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)
-          when "any"
-            valid = true
-          else
-            valid = true
-          end
-        elsif type.is_a?(Hash) && union
-          # Validate as a schema
-          schema = JSON::Schema.new(type,current_schema.uri)
-          begin
-            validate_schema(schema,data,fragments)
-            valid = true
-          rescue ValidationError
-            # We don't care that these schemas don't validate - we only care that one validated
-          end
-        end
-
-        break if valid
-      end
-      
-      if (disallow)
-        if valid
-          message = "The property '#{build_fragment(fragments)}' matched one or more of the following types:"
-          types.each {|type| message += type.is_a?(String) ? " #{type}," : " (schema)," }
-          message.chop!
-          raise ValidationError.new(message, fragments, current_schema)
-        end
-      elsif !valid
-        message = "The property '#{build_fragment(fragments)}' did not match one or more of the following types:"
-        types.each {|type| message += type.is_a?(String) ? " #{type}," : " (schema)," }
-        message.chop!
-        raise ValidationError.new(message, fragments, current_schema)
-      end
-    end
-    
-    
-    # Validate the disallowed types
-    def validate_disallow(current_schema, data, fragments)
-      validate_type(current_schema, data, fragments, true)
-    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)
-        if (current_schema.schema['exclusiveMinimum'] ? data <= current_schema.schema['minimum'] : data < current_schema.schema['minimum'])
-          message = "The property '#{build_fragment(fragments)}' did not have a minimum value of #{current_schema.schema['minimum']}, "
-          message += current_schema.schema['exclusiveMinimum'] ? 'exclusively' : 'inclusively'
-          raise ValidationError.new(message, fragments, current_schema)
-        end
-      end
-    end
-    
-    
-    # Validate the maximum value of a number
-    def validate_maximum(current_schema, data, fragments)
-      if data.is_a?(Numeric)
-        if (current_schema.schema['exclusiveMaximum'] ? data >= current_schema.schema['maximum'] : data > current_schema.schema['maximum'])
-          message = "The property '#{build_fragment(fragments)}' did not have a maximum value of #{current_schema.schema['maximum']}, "
-          message += current_schema.schema['exclusiveMaximum'] ? 'exclusively' : 'inclusively'
-          raise ValidationError.new(message, fragments, current_schema)
-        end
-      end
-    end
-    
-    
-    # Validate the minimum number of items in an array
-    def validate_minItems(current_schema, data, fragments)
-      if data.is_a?(Array) && (data.compact.size < current_schema.schema['minItems'])
-        message = "The property '#{build_fragment(fragments)}' did not contain a minimum number of items #{current_schema.schema['minItems']}"
-        raise ValidationError.new(message, fragments, current_schema)
-      end
-    end
-    
-    
-    # Validate the maximum number of items in an array
-    def validate_maxItems(current_schema, data, fragments)
-      if data.is_a?(Array) && (data.compact.size > current_schema.schema['maxItems'])
-        message = "The property '#{build_fragment(fragments)}' did not contain a minimum number of items #{current_schema.schema['minItems']}"
-        raise ValidationError.new(message, fragments, current_schema)
-      end
-    end
-    
-    
-    # Validate the uniqueness of elements in an array
-    def validate_uniqueItems(current_schema, data, fragments)
-      if data.is_a?(Array)
-        d = data.clone
-        dupes = d.uniq!
-        if dupes
-          message = "The property '#{build_fragment(fragments)}' contained duplicated array values"
-          raise ValidationError.new(message, fragments, current_schema)
-        end
-      end
-    end
-    
-    
-    # Validate a string matches a regex pattern
-    def validate_pattern(current_schema, data, fragments)
-      if data.is_a?(String)
-        r = Regexp.new(current_schema.schema['pattern'])
-        if (r.match(data)).nil?
-          message = "The property '#{build_fragment(fragments)}' did not match the regex '#{current_schema.schema['pattern']}'"
-          raise ValidationError.new(message, fragments, current_schema)
-        end
-      end
-    end
-    
-    
-    # Validate a string is at least of a certain length
-    def validate_minLength(current_schema, data, fragments)
-      if data.is_a?(String)
-        if data.length < current_schema.schema['minLength']
-          message = "The property '#{build_fragment(fragments)}' was not of a minimum string length of #{current_schema.schema['minLength']}"
-          raise ValidationError.new(message, fragments, current_schema)
-        end
-      end
-    end
-    
-    
-    # Validate a string is at maximum of a certain length
-    def validate_maxLength(current_schema, data, fragments)
-      if data.is_a?(String)
-        if data.length > current_schema.schema['maxLength']
-          message = "The property '#{build_fragment(fragments)}' was not of a maximum string length of #{current_schema.schema['maxLength']}"
-          raise ValidationError.new(message, fragments, current_schema)
-        end
-      end
-    end
-    
-    
-    # Validate a numeric is divisible by another numeric
-    def validate_divisibleBy(current_schema, data, fragments)
-      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
-    
-    
-    # Validate an item matches at least one of an array of values
-    def validate_enum(current_schema, data, fragments)
-      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
-    
-    
-    # Validate a set of properties of an object
-    def validate_properties(current_schema, data, fragments)
-      if data.is_a?(Hash)
-        current_schema.schema['properties'].each do |property,property_schema|
-          if (property_schema['required'] && !data.has_key?(property))
-            message = "The property '#{build_fragment(fragments)}' did not contain a required property of '#{property}'"
-            raise ValidationError.new(message, fragments, current_schema)
-          end
-          
-          if data.has_key?(property)
-            schema = JSON::Schema.new(property_schema,current_schema.uri)
-            fragments << property
-            validate_schema(schema, data[property], fragments)
-            fragments.pop
-          end
-        end
-      end
-    end
-    
-    
-    # Validate properties of an object against a schema when the property name matches a specific regex
-    def validate_patternProperties(current_schema, data, fragments)
-      if data.is_a?(Hash)
-        current_schema.schema['patternProperties'].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)
-              fragments << key
-              validate_schema(schema, data[key], fragments)
-              fragments.pop
-            end
-          end
-        end
-      end
-    end
-    
-    
-    # Validate properties of an object that are not defined in the schema at least validate against a set of rules
-    def validate_additionalProperties(current_schema, data, fragments)
-      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)
-            fragments << key
-            validate_schema(schema, data[key], fragments)
-            fragments.pop
-          end
-        end
-      end
-    end
-    
-    
-    # Validate items in an array match a schema or a set of schemas
-    def validate_items(current_schema, data, fragments)
-      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)
-             fragments << i.to_s
-             validate_schema(schema,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)
-             fragments << i.to_s
-             validate_schema(schema,data[i],fragments)
-             fragments.pop
-           end
-         end
-      end
-    end
-    
-    
-    # Validate items in an array that are not part of the schema at least match a set of rules
-    def validate_additionalItems(current_schema, data, fragments)
-      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)
-          data.each_with_index do |item,i|
-            if i >= current_schema.schema['items'].length
-              fragments << i.to_s
-              validate_schema(schema, item, fragments)
-              fragments.pop
-            end
-          end
-        end
-      end
-    end
-    
-    
-    # Validate the dependencies of a property
-    def validate_dependencies(current_schema, data, fragments)
-      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)
-              validate_schema(schema, data, fragments)
-            end
-          end
-        end
-      end
-    end
-    
-    
-    # Validate extensions of other schemas
-    def validate_extends(current_schema, data, fragments)
-      schemas = current_schema.schema['extends']
-      schemas = [schemas] if !schemas.is_a?(Array)
-      schemas.each do |s|
-        schema = JSON::Schema.new(s,current_schema.uri)
-        validate_schema(schema, data, fragments)
-      end
-    end
-    
-    
-    # Validate schema references
-    def validate_ref(current_schema, data, fragments)
-      temp_uri = URI.parse(current_schema.schema['$ref'])
-      if temp_uri.relative?
-        temp_uri = current_schema.uri.clone
-        # Check for absolute path
-        path = current_schema.schema['$ref'].split("#")[0]
-        if path.nil? || path == ''
-          temp_uri.path = current_schema.uri.path
-        elsif path[0,1] == "/"
-          temp_uri.path = Pathname.new(path).cleanpath.to_s
-        else
-          temp_uri.path = (Pathname.new(current_schema.uri.path).parent + path).cleanpath.to_s
-        end
-        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 = Validator.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("/")
-        fragment_path = ''
-        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
-            fragment_path = fragment_path + "/#{fragment}"
-            if target_schema.nil?
-              raise SchemaError.new("The fragment '#{fragment_path}' does not exist on schema #{ref_schema.uri.to_s}")
-            end
-          end
-        end
-        
-        # We have the schema finally, build it and validate!
-        schema = JSON::Schema.new(target_schema,temp_uri)
-        validate_schema(schema, data, fragments)
-      else
-        raise ValidationError.new("The referenced schema '#{temp_uri.to_s}' cannot be found", fragments, current_schema)
-      end
-    end
-    
-
-    def build_fragment(fragments)
-      "#/#{fragments.join('/')}"
     end
 
     
@@ -707,14 +190,20 @@ module JSON
     
     class << self
       def validate(schema, data,opts={})
-        validator = JSON::Validator.new(schema, data, opts)
-        validator.validate
+        begin
+          validator = JSON::Validator.new(schema, data, opts)
+          validator.validate
+          return true
+        rescue JSON::Schema::ValidationError, JSON::Schema::SchemaError
+          return false
+        end
       end
     
-      def validate2(schema, data,opts={})
+      def validate!(schema, data,opts={})
         validator = JSON::Validator.new(schema, data, opts)
-        validator.validate2
+        validator.validate
       end
+      alias_method 'validate2', 'validate!'
       
       def clear_cache
         @@schemas = {} if @@cache_schemas == false
@@ -731,7 +220,22 @@ module JSON
       def cache_schemas=(val)
         @@cache_schemas = val == true ? true : false
       end
-        
+      
+      def validators
+        @@validators
+      end
+      
+      def default_validator
+        @@default_validator
+      end
+      
+      def register_validator(v)
+        @@validators[v.to_s] = v
+      end
+      
+      def register_default_validator(v)
+        @@default_validator = v
+      end
     end