require 'uri' class Hash # Returns a new hash containing the contents of other_hash and the # contents of self. If the value for entries with duplicate keys # is a Hash, it will be merged recursively, otherwise it will be that # of other_hash. # # @param [Hash] other_hash # # @return [Hash] Containing the merged values # # @example Merging two hashes # h1 = {:a => 3, {:b => 3, :c => 7}} # h2 = {:a => 22, c => 4, {:b => 5}} # # h1.deep_merge(h2) #=> {:a => 22, c => 4, {:b => 5, :c => 7}} def deep_merge(other_hash) target = dup other_hash.each do |hash_key, hash_value| if hash_value.is_a?(Hash) and self[hash_key].is_a?(Hash) target[hash_key] = self[hash_key].deep_merge(hash_value) elsif hash_value.is_a?(Array) and self[hash_key].is_a?(Array) hash_value.each_with_index { |elem, i| if self[hash_key][i].is_a?(Hash) and elem.is_a?(Hash) target[hash_key][i] = self[hash_key][i].deep_merge(elem) else target[hash_key] = hash_value end } else target[hash_key] = hash_value end end target end end module Validator class ParseException < StandardError; end class SchemaException < StandardError; end class Validator # @param [Hash] opts the options to validate a body # @option opts [Boolean] :default_values Set default values if the schema # specifies it (if true) # @option opts [Booblean] :delete_extra_properties If the body contains properties # not specified in the schema delete them from the body (if true) # or raise an exception (if false) def initialize(opts={}) @opts = { :default_values => true, :delete_extra_properties => false }.merge(opts) end # Recursively validate and modify a JSON body based on a schema. # # @see http://tools.ietf.org/html/draft-zyp-json-schema-03 # # @param [Hash, Array, String, nil] body JSON represented as Ruby objects # @param [Hash] schema that will be used to validate # @param [String] key of the body that will be validated in this step # # @return [Hash, Array, String, nil] The modified body # # @raise [SchemaException] If the schema is not correctly defined # @raise [ParseException] if the body does not meet the schema definition # # @example Validate a User # schema = { # :type => :object, # :properties => { # 'username' => { # :type => :string # } # } # } # # hash = { # 'username' => 'pepe' # } # # Validator.validate!(hash, schema) # #=> {'username' => 'pepe'} # # @note The parameter body will be modified # @note Schema options supported # :extends # :type => [:object, :array, :string, :null] # def validate!(body, schema, key="") if schema[:extends] base_schema = schema.delete(:extends) schema = base_schema.deep_merge(schema) end case schema[:type] when :object then validate_object(body, schema, key) when :array then validate_array(body, schema, key) when :string then validate_string(body, schema, key) when :integer then validate_integer(body, schema, key) when :null then validate_null(body, schema, key) else raise SchemaException, "type #{schema[:type]} is not a valid type" end end private # Validate an object type # # @param [Hash] body to be validated # @param [Hash] schema_object of the objectto validate the body # @param [String] key of the body that will be validated in this step # # @return [Hash] The modified body # # @raise [ParseException] if the body does not meet the schema definition # # @example Validate with default values # schema_body = { # :type => :object, # :properties => { # 'username' => { # :type => :string, # :default => 'def' # } # } # # body = {} # # Validator.validate_object(body, schema_body) # #=> {'username' => 'def'} # # @note The parameter body will be modified # @note Schema options supported # :properties # :required # :default # def validate_object(body, schema_object, key) unless body.is_a?(Hash) raise ParseException, "KEY: #{key} must be a Hash; SCHEMA:"\ "#{schema_object}" end new_body = body.dup schema_object[:properties].each{ |schema_key, schema_value| body_value = new_body.delete(schema_key) if body_value body[schema_key] = validate!(body_value, schema_value, schema_key) else if schema_value[:required] raise ParseException, "KEY: '#{schema_key}' is required;"\ " SCHEMA: #{schema_value}" end if @opts[:default_values] && schema_value[:default] body[schema_key] = schema_value[:default] end end } # raise error if body.keys is not empty unless new_body.keys.empty? if @opts[:delete_extra_properties] new_body.keys.each{ |key| body.delete(key) } else raise ParseException, "KEY: #{new_body.keys.join(', ')} not"\ " allowed; SCHEMA: #{schema_object}" end end body end # Validate an array type # # @param [Array] body to be validated # @param [Hash] schema_array of the object to validate the body # @param [String] schema_key of the body that will be validated in this step # # @return [Hash] The modified body # # @raise [ParseException] if the body does not meet the schema definition # # @example Validate array # schema = { # :type => :array, # :items => { # :type => :string # } # } # # body = ['pepe', 'luis', 'juan'] # # Validator.validate_array(body, schema) # #=> 'username' => ['pepe', 'luis', 'juan'] # # @note The parameter body will be modified # @note Schema options supported # :items # def validate_array(body, schema_array, schema_key) if body.instance_of?(Array) body.collect { |body_item| validate!(body_item, schema_array[:items], schema_key) } else raise ParseException, "KEY: '#{schema_key}' must be an Array;"\ " SCHEMA: #{schema_array}" end end # Validate an integer type # # @param [Array] body to be validated # @param [Hash] schema_array of the object to validate the body # @param [String] schema_key of the body that will be validated in this step # # @return [Hash] The modified body # # @raise [ParseException] if the body does not meet the schema definition # # @example Validate array # schema = { # :type => :integer # } # # body = 5 # # Validator.validate_integer(body, schema) # #=> 5 # # def validate_integer(body, schema_array, schema_key) if body.is_a?(Integer) body else raise ParseException, "KEY: '#{schema_key}' must be an Integer;"\ " SCHEMA: #{schema_array}" end end # Validate an null type # # @param [nil] body to be validated # @param [Hash] schema_null of the object to validate the body # @param [String] schema_key of the body that will be validated in this step # # @return [nil] # # @raise [ParseException] if the body is not nil # # @example Validate array # schema = { # :type => :null # } # # body = nil # # Validator.validate_null(body, schema) # #=> nil # # def validate_null(body, schema_null, schema_key) if body != nil raise ParseException, "KEY: '#{schema_key}' is not allowed;"\ " SCHEMA: #{schema_null}" end end # Validate an string type # # @param [String] body to be validated # @param [Hash] schema_string of the object to validate the body # @param [String] schema_key of the body that will be validated in this step # # @return [String] The modified body # # @raise [ParseException] if the body does not meet the schema definition # # @example Validate array # schema = { # :type => :string # } # # body = "pepe" # # Validator.validate_string(body, schema) # #=> "pepe" # # @note The parameter body will be modified # @note Schema options supported # :format # :enum # def validate_string(body, schema_string, schema_key) if body.instance_of?(String) if schema_string[:format] check_format(body, schema_string, schema_key) elsif schema_string[:enum] check_enum(body, schema_string, schema_key) else body end else raise ParseException, "KEY: '#{schema_key}' must be a String;"\ " SCHEMA: #{schema_string}" end end # Validate an string format # # @param [String] body_value to be validated # @param [Hash] schema_string of the object to validate the body # @param [String] schema_key of the body that will be validated in this step # # @return [String] The modified body # # @raise [ParseException] if the body does not meet the schema definition # # @example Validate array # schema = { # :type => :string, # :format => :url # } # # body = "http://localhost:4567" # # Validator.check_format(body, schema) # #=> "http://localhost:4567" # # @note The parameter body will be modified # @note Schema options supported # :url # def check_format(body_value, schema_string, schema_key) case schema_string[:format] when :uri begin require 'uri' uri = URI.parse(body_value) rescue raise ParseException, "KEY: '#{schema_key}' must be a valid URL;"\ " SCHEMA: #{schema_string} #{$!.message}" end body_value end body_value end # Validate an string enum # # @param [String] body_value to be validated # @param [Hash] schema_string of the object to validate the body # @param [String] schema_key of the body that will be validated in this step # # @return [String] The modified body # # @raise [ParseException] if the body does not meet the schema definition # # @example Validate array # schema = { # :type => :string, # :enum => ['juan', 'luis'] # } # # body = "juan" # # Validator.check_enum(body, schema) # #=> "juan" # # @note The parameter body will be modified # @note Schema options supported # :enum # def check_enum(body_value, schema_string, schema_key) if schema_string[:enum].include?(body_value) body_value else raise ParseException, "KEY: '#{schema_key}' must be one of"\ " #{schema_string[:enum].join(', ')}; SCHEMA: #{schema_string}" end end end end