json-schema 1.0.12 → 1.1.0

data/README.textile

@@ -18,7 +18,7 @@ From the git repo:
 
 <pre>
 $ gem build json-schema.gemspec
-$ gem install json-schema-1.0.12.gem
+$ gem install json-schema-1.1.0.gem
 </pre>
 
 
@@ -225,7 +225,7 @@ require 'rubygems'
 require 'json-schema'
   
 class BitwiseAndAttribute < JSON::Schema::Attribute
-  def self.validate(current_schema, data, fragments, validator, options = {})
+  def self.validate(current_schema, data, fragments, processor, 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)

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

@@ -1,17 +1,17 @@
 module JSON
   class Schema
     class AdditionalItemsAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, 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, self, options[:record_errors])
+            validation_error(processor, message, fragments, current_schema, self, 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)
+                schema.validate(item, fragments, processor, options)
                 fragments.pop
               end
             end

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

@@ -3,7 +3,7 @@ require 'json-schema/attributes/extends'
 module JSON
   class Schema
     class AdditionalPropertiesAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
         if data.is_a?(Hash)
           extra_properties = data.keys
 
@@ -15,14 +15,14 @@ module JSON
             matching_properties.each do |key|
               schema = JSON::Schema.new(addprop[key] || addprop, current_schema.uri, validator)
               fragments << key
-              schema.validate(data[key],fragments,options)
+              schema.validate(data[key],fragments,processor,options)
               fragments.pop
             end
             extra_properties -= matching_properties
           end
           if !extra_properties.empty? and (addprop == false or (addprop.is_a?(Hash) and !addprop.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, self, options[:record_errors])
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

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

@@ -1,25 +1,25 @@
 module JSON
   class Schema
     class DependenciesAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, 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, self, options[:record_errors])
+                  validation_error(processor, message, fragments, current_schema, self, 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, self, options[:record_errors])
+                    validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
                   end
                 end
               else
                 schema = JSON::Schema.new(dependency_value,current_schema.uri,validator)
-                schema.validate(data, fragments, options)
+                schema.validate(data, fragments, processor, options)
               end
             end
           end

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

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

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

@@ -1,13 +1,13 @@
 module JSON
   class Schema
     class DivisibleByAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, 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, self, options[:record_errors])
+             validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

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

@@ -1,7 +1,7 @@
 module JSON
   class Schema
     class EnumAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, 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|
@@ -16,7 +16,7 @@ module JSON
             end
           }
           message.chop!
-          validation_error(message, fragments, current_schema, self, options[:record_errors])
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
         end
       end
     end

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

@@ -3,19 +3,19 @@ require 'json-schema/attributes/ref'
 module JSON
   class Schema
     class ExtendsAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
         schemas = current_schema.schema['extends']
         schemas = [schemas] if !schemas.is_a?(Array)
         schemas.each do |s|
           uri,schema = get_extended_uri_and_schema(s, current_schema, validator)
           if schema
-            schema.validate(data, fragments, options)
+            schema.validate(data, fragments, processor, options)
           elsif uri
             message = "The extended schema '#{uri.to_s}' cannot be found"
-            validation_error(message, fragments, current_schema, self, options[:record_errors])
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
           else
             message = "The property '#{build_fragment(fragments)}' was not a valid schema"
-            validation_error(message, fragments, current_schema, self, options[:record_errors])
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

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

@@ -1,33 +1,33 @@
 module JSON
   class Schema
     class FormatAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
         case current_schema.schema['format']
 
         # Timestamp in restricted ISO-8601 YYYY-MM-DDThh:mm:ssZ with optional decimal fraction of the second
         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 or YYYY-MM-DDThh:mm:ss.ssZ"
-            validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if !data.is_a?(String)
+            validation_error(processor, error_message, fragments, current_schema, self, 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)([\.,]\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, self, options[:record_errors])
+                validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
                 return
               end
               begin
-                validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if m[1].to_i > 23
-                validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if m[2].to_i > 59
-                validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if m[3].to_i > 59
+                validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if m[1].to_i > 23
+                validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if m[2].to_i > 59
+                validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if m[3].to_i > 59
               rescue Exception
-                validation_error(error_message, fragments, current_schema, self, options[:record_errors])
+                validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
                 return
               end
             else
-              validation_error(error_message, fragments, current_schema, self, options[:record_errors])
+              validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
               return
             end
           end
@@ -36,17 +36,17 @@ module JSON
         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, self, options[:record_errors]) and return if !data.is_a?(String)
+            validation_error(processor, error_message, fragments, current_schema, self, 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, self, options[:record_errors])
+                validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
                 return
               end
             else
-              validation_error(error_message, fragments, current_schema, self, options[:record_errors])
+              validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
               return
             end
           end
@@ -55,14 +55,14 @@ module JSON
         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, self, options[:record_errors]) and return if !data.is_a?(String)
+            validation_error(processor, error_message, fragments, current_schema, self, 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, self, options[:record_errors]) and return if m[1].to_i > 23
-              validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if m[2].to_i > 59
-              validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if m[3].to_i > 59
+              validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if m[1].to_i > 23
+              validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if m[2].to_i > 59
+              validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if m[3].to_i > 59
             else
-              validation_error(error_message, fragments, current_schema, self, options[:record_errors])
+              validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
               return
             end
           end
@@ -71,14 +71,14 @@ module JSON
         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, self, options[:record_errors]) and return if !data.is_a?(String)
+            validation_error(processor, error_message, fragments, current_schema, self, 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, self, options[:record_errors]) and return if m[x].to_i > 255
+                validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if m[x].to_i > 255
               end
             else
-              validation_error(error_message, fragments, current_schema, self, options[:record_errors])
+              validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
               return
             end
           end
@@ -87,22 +87,22 @@ module JSON
         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, self, options[:record_errors]) and return if !data.is_a?(String)
+            validation_error(processor, error_message, fragments, current_schema, self, 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, self, options[:record_errors]) and return if parts.length > 8
+              validation_error(processor, error_message, fragments, current_schema, self, 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, self, options[:record_errors]) and return if condensed_zeros
+                  validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if condensed_zeros
                   condensed_zeros = true
                 end
-                validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if part.length > 4
+                validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if part.length > 4
               end
             else
-              validation_error(error_message, fragments, current_schema, self, options[:record_errors])
+              validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
               return
             end
           end

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

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

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

@@ -1,12 +1,12 @@
 module JSON
   class Schema
     class MaxDecimalAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
         if data.is_a?(Numeric)
           s = data.to_s.split(".")[1]
           if s && s.length > current_schema.schema['maxDecimal']
             message = "The property '#{build_fragment(fragments)}' had more decimal places than the allowed #{current_schema.schema['maxDecimal']}"
-            validation_error(message, fragments, current_schema, self, options[:record_errors])
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

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

@@ -1,12 +1,12 @@
 module JSON
   class Schema
     class MaximumAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, 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'
-            validation_error(message, fragments, current_schema, self, options[:record_errors])
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

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

@@ -1,12 +1,12 @@
 module JSON
   class Schema
     class MaximumInclusiveAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
         if data.is_a?(Numeric)
           if (current_schema.schema['maximumCanEqual'] == false ? 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'
-            validation_error(message, fragments, current_schema, self, options[:record_errors])
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

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

@@ -1,10 +1,10 @@
 module JSON
   class Schema
     class MaxItemsAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, 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']}"
-          validation_error(message, fragments, current_schema, self, options[:record_errors])
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
         end
       end
     end

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

@@ -1,11 +1,11 @@
 module JSON
   class Schema
     class MaxLengthAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, 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']}"
-            validation_error(message, fragments, current_schema, self, options[:record_errors])
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

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

@@ -1,12 +1,12 @@
 module JSON
   class Schema
     class MinimumAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, 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'
-            validation_error(message, fragments, current_schema, self, options[:record_errors])
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

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

@@ -1,12 +1,12 @@
 module JSON
   class Schema
     class MinimumInclusiveAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
         if data.is_a?(Numeric)
           if (current_schema.schema['minimumCanEqual'] == false ? 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'
-            validation_error(message, fragments, current_schema, self, options[:record_errors])
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

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

@@ -1,10 +1,10 @@
 module JSON
   class Schema
     class MinItemsAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, 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']}"
-          validation_error(message, fragments, current_schema, self, options[:record_errors])
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
         end
       end
     end

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

@@ -1,11 +1,11 @@
 module JSON
   class Schema
     class MinLengthAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, 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']}"
-            validation_error(message, fragments, current_schema, self, options[:record_errors])
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

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

@@ -1,12 +1,12 @@
 module JSON
   class Schema
     class PatternAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, 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)}' value #{data.inspect} did not match the regex '#{current_schema.schema['pattern']}'"
-            validation_error(message, fragments, current_schema, self, options[:record_errors])
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

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

@@ -1,7 +1,7 @@
 module JSON
   class Schema
     class PatternPropertiesAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
         if data.is_a?(Hash)
           current_schema.schema['patternProperties'].each do |property,property_schema|
             r = Regexp.new(property)
@@ -11,7 +11,7 @@ module JSON
               if r.match(key)
                 schema = JSON::Schema.new(property_schema,current_schema.uri,validator)
                 fragments << key
-                schema.validate(data[key],fragments,options)
+                schema.validate(data[key],fragments,processor,options)
                 fragments.pop
               end
             end

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

@@ -1,7 +1,7 @@
 module JSON
   class Schema
     class PropertiesAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
         if data.is_a?(Hash)
           current_schema.schema['properties'].each do |property,property_schema|
             if !data.has_key?(property) and property_schema['default'] and !property_schema['readonly'] and options[:insert_defaults]
@@ -11,13 +11,13 @@ module JSON
 
             if property_schema['required'] and !data.has_key?(property)
               message = "The property '#{build_fragment(fragments)}' did not contain a required property of '#{property}'"
-              validation_error(message, fragments, current_schema, self, options[:record_errors])
+              validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
             end
           
             if data.has_key?(property)
               schema = JSON::Schema.new(property_schema,current_schema.uri,validator)
               fragments << property
-              schema.validate(data[property],fragments,options)
+              schema.validate(data[property],fragments,processor,options)
               fragments.pop
             end
           end

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

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

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

@@ -1,17 +1,17 @@
 module JSON
   class Schema
     class RefAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
         uri,schema = get_referenced_uri_and_schema(current_schema.schema, current_schema, validator)
 
         if schema
-          schema.validate(data, fragments, options)
+          schema.validate(data, fragments, processor, options)
         elsif uri
           message = "The referenced schema '#{uri.to_s}' cannot be found"
-          validation_error(message, fragments, current_schema, self, options[:record_errors])
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
         else
           message = "The property '#{build_fragment(fragments)}' was not a valid schema"
-          validation_error(message, fragments, current_schema, self, options[:record_errors])
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
         end
       end
 

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

@@ -1,7 +1,7 @@
 module JSON
   class Schema
     class TypeAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
         union = true
 
         if options[:disallow]
@@ -28,20 +28,20 @@ module JSON
             
             # We're going to add a little cruft here to try and maintain any validation errors that occur in this union type
             # We'll handle this by keeping an error count before and after validation, extracting those errors and pushing them onto a union error
-            pre_validation_error_count = validation_errors.count
+            pre_validation_error_count = validation_errors(processor).count
             
             begin
-              schema.validate(data,fragments,options)
+              schema.validate(data,fragments,processor,options)
               valid = true
             rescue ValidationError
               # We don't care that these schemas don't validate - we only care that one validated
             end
             
-            diff = validation_errors.count - pre_validation_error_count
+            diff = validation_errors(processor).count - pre_validation_error_count
             valid = false if diff > 0
             while diff > 0
               diff = diff - 1
-              union_errors.push(validation_errors.pop)
+              union_errors.push(validation_errors(processor).pop)
             end
           end
 
@@ -53,20 +53,20 @@ module JSON
             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!
-            validation_error(message, fragments, current_schema, self, options[:record_errors])
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
           end
         elsif !valid
           if union
             message = "The property '#{build_fragment(fragments)}' of type #{data.class} did not match one or more of the following types:"
             types.each {|type| message += type.is_a?(String) ? " #{type}," : " (schema)," }
             message.chop!
-            validation_error(message, fragments, current_schema, self, options[:record_errors])
-            validation_errors.last.sub_errors = union_errors
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+            validation_errors(processor).last.sub_errors = union_errors
           else
             message = "The property '#{build_fragment(fragments)}' of type #{data.class} did not match the following type:"
             types.each {|type| message += type.is_a?(String) ? " #{type}," : " (schema)," }
             message.chop!
-            validation_error(message, fragments, current_schema, self, options[:record_errors])            
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])            
           end
         end
       end

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

@@ -1,13 +1,13 @@
 module JSON
   class Schema
     class UniqueItemsAttribute < Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, 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"
-            validation_error(message, fragments, current_schema, self, options[:record_errors])
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

data/lib/json-schema/schema.rb

@@ -34,8 +34,8 @@ module JSON
       end  
     end
     
-    def validate(data, fragments, options = {})
-      @validator.validate(self, data, fragments, options)
+    def validate(data, fragments, processor, options = {})
+      @validator.validate(self, data, fragments, processor, options)
     end
     
     def base_uri

data/lib/json-schema/validator.rb

@@ -4,6 +4,7 @@ require 'pathname'
 require 'bigdecimal'
 require 'digest/sha1'
 require 'date'
+require 'thread'
 
 module JSON
 
@@ -46,24 +47,24 @@ module JSON
     end
 
     class Attribute
-      def self.validate(current_schema, data, fragments, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
       end
 
       def self.build_fragment(fragments)
         "#/#{fragments.join('/')}"
       end
 
-      def self.validation_error(message, fragments, current_schema, failed_attribute, record_errors)
+      def self.validation_error(processor, message, fragments, current_schema, failed_attribute, record_errors)
         error = ValidationError.new(message, fragments, failed_attribute, current_schema)
         if record_errors
-          ::JSON::Validator.validation_error(error)
+          processor.validation_error(error)
         else
           raise error
         end
       end
       
-      def self.validation_errors
-        ::JSON::Validator.validation_errors
+      def self.validation_errors(validator)
+        validator.validation_errors
       end
     end
 
@@ -88,10 +89,10 @@ module JSON
         "#{@uri.scheme}://#{uri.host}#{uri.path}"
       end
 
-      def validate(current_schema, data, fragments, options = {})
+      def validate(current_schema, data, fragments, processor, options = {})
         current_schema.schema.each do |attr_name,attribute|
           if @attributes.has_key?(attr_name.to_s)
-            @attributes[attr_name.to_s].validate(current_schema, data, fragments, self, options)
+            @attributes[attr_name.to_s].validate(current_schema, data, fragments, processor, self, options)
           end
         end
         data
@@ -116,9 +117,9 @@ module JSON
     @@default_validator = nil
     @@available_json_backends = []
     @@json_backend = nil
-    @@errors = []
     @@serializer = nil
-
+    @@mutex = Mutex.new
+    
     def self.version_string_for(version)
       # I'm not a fan of this, but it's quick and dirty to get it working for now
       return "draft-03" unless version
@@ -140,6 +141,7 @@ module JSON
 
     def initialize(schema_data, data, opts={})
       @options = @@default_opts.clone.merge(opts)
+      @errors = []
 
       # I'm not a fan of this, but it's quick and dirty to get it working for now
       version_string = "draft-03"
@@ -163,22 +165,21 @@ module JSON
         end
       end
       
-      @base_schema = initialize_schema(schema_data)
+      @@mutex.synchronize { @base_schema = initialize_schema(schema_data) }
       @data = initialize_data(data)
-      build_schemas(@base_schema)
+      @@mutex.synchronize { build_schemas(@base_schema) }
     end
 
 
     # Run a simple true/false validation of data against a schema
     def validate()
       begin
-        Validator.clear_errors
-        @base_schema.validate(@data,[],@validation_options)
+        @base_schema.validate(@data,[],self,@validation_options)
         Validator.clear_cache
         if @options[:errors_as_objects]
-          @@errors.map{|e| e.to_hash}
+          return @errors.map{|e| e.to_hash}
         else
-          @@errors.map{|e| e.to_string}
+          return @errors.map{|e| e.to_string}
         end
       rescue JSON::Schema::ValidationError
         Validator.clear_cache
@@ -286,6 +287,14 @@ module JSON
       end
     end
 
+    def validation_error(error)
+      @errors.push(error)
+    end
+    
+    def validation_errors
+      @errors
+    end
+
 
     class << self
       def validate(schema, data,opts={})
@@ -345,18 +354,6 @@ module JSON
         @@schemas = {} if @@cache_schemas == false
       end
 
-      def clear_errors
-        @@errors = []
-      end
-
-      def validation_error(error)
-        @@errors.push(error)
-      end
-      
-      def validation_errors
-        @@errors
-      end
-
       def schemas
         @@schemas
       end

data/test/test_extended_schema.rb

@@ -2,7 +2,7 @@ require 'test/unit'
 require File.dirname(__FILE__) + '/../lib/json-schema'
 
 class BitwiseAndAttribute < JSON::Schema::Attribute
-  def self.validate(current_schema, data, fragments, validator, options = {})
+  def self.validate(current_schema, data, fragments, processor, 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, self, current_schema)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json-schema
 version: !ruby/object:Gem::Version
-  version: 1.0.12
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-14 00:00:00.000000000 Z
+date: 2013-01-14 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: hoxworth@gmail.com
@@ -116,4 +116,3 @@ test_files:
 - test/schemas/good_schema_1.json
 - test/schemas/good_schema_2.json
 - test/schemas/inner.schema.json
-has_rdoc: