Files
one/flow/lib/validator.rb
T
2013-01-23 12:44:19 +01:00

413 lines
13 KiB
Ruby

# -------------------------------------------------------------------------- #
# Copyright 2010-2013, C12G Labs S.L. #
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may #
# not use this file except in compliance with the License. You may obtain #
# a copy of the License at #
# #
# http://www.apache.org/licenses/LICENSE-2.0 #
# #
# Unless required by applicable law or agreed to in writing, software #
# distributed under the License is distributed on an "AS IS" BASIS, #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
# See the License for the specific language governing permissions and #
# limitations under the License. #
#--------------------------------------------------------------------------- #
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)
Integer(body)
rescue ArgumentError
raise ParseException, "KEY: '#{schema_key}' must be an Integer;"\
" SCHEMA: #{schema_array}"
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