seomoz-json-schema 1.0.1

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

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

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

@@ -0,0 +1,15 @@
+module JSON
+  class Schema
+    class MaxDecimalAttribute < Attribute
+      def self.validate(current_schema, data, fragments, 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, options[:record_errors])
+          end
+        end
+      end
+    end
+  end
+end

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'
+            validation_error(message, fragments, current_schema, options[:record_errors])
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,15 @@
+module JSON
+  class Schema
+    class MinimumInclusiveAttribute < Attribute
+      def self.validate(current_schema, data, fragments, 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, options[:record_errors])
+          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']}"
+          validation_error(message, fragments, current_schema, options[:record_errors])
+        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']}"
+            validation_error(message, fragments, current_schema, options[:record_errors])
+          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']}'"
+            validation_error(message, fragments, current_schema, options[:record_errors])
+          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,options)
+                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}'"
+              validation_error(message, fragments, current_schema, 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)
+              fragments.pop
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module JSON
+  class Schema
+    class PropertiesOptionalAttribute < 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['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, 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)
+              fragments.pop
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+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 = current_schema.uri.merge(path)
+          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, options)
+        else
+          message = "The referenced schema '#{temp_uri.to_s}' cannot be found"
+          validation_error(message, fragments, current_schema, options[:record_errors])
+        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,options)
+              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!
+            validation_error(message, fragments, current_schema, options[:record_errors])
+          end
+        elsif !valid
+          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, options[:record_errors])
+        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"
+            validation_error(message, fragments, current_schema, options[:record_errors])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json-schema/schema.rb

@@ -0,0 +1,50 @@
+require 'pathname'
+
+module JSON
+  class Schema
+
+    attr_accessor :schema, :uri, :validator
+    
+    def initialize(schema,uri,parent_validator=nil)
+      @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 = uri.merge(@schema['id'])
+          temp_uri = uri
+        end
+        @uri = temp_uri
+      end
+      @uri.fragment = ''
+      
+      # 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, options = {})
+      @validator.validate(self, data, fragments, options)
+    end
+    
+    def base_uri
+      parts = @uri.to_s.split('/')
+      parts.pop
+      parts.join('/') + '/'
+    end
+
+    
+  end
+end
+