kharon 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c25325fecde2ed9bb57cc60983980dba2b50f700
+  data.tar.gz: 46a7a17a5075d66e9552eb083d8428edb428147f
+SHA512:
+  metadata.gz: 9e5ed5dc943275d41234da3c1c36507968b11df77dd0403e2553b2362a6959561990231cc155b0d572f586fffffc2c1265b0a67eb623957fb4b6c8c3296bdc5b
+  data.tar.gz: c6a47f792e0644c6bae66269352d167c4b770f043a133e5481dacd6a8ce1eebe02390abbe7606315645bda4f2f629fbcc64c4dad7f01ea036c30b2f73a432083

data/lib/validate.rb

@@ -0,0 +1,15 @@
+module Charon
+  module Helpers
+
+    # Validates the datas passed as parameter with a Phenix::Validator and the given instructions.
+    # @param  [Hash] the parameters to validate with the given instructions.
+    # @param  [Proc] the instructions to apply on the validator.
+    # @return [Hash] the validated and filtered datas.
+    def validate(datas, &block)
+      validator = Phenix::Validator.new(datas)
+      validator.instance_eval(&block)
+      return validator.filtered
+    end
+
+  end
+end

data/lib/validator.rb

@@ -0,0 +1,272 @@
+require "pry"
+
+module Charon
+  # The validator uses aquarium as an AOP DSL to provide "before" and "after" joint point to its main methods.
+  # @author Vincent Courtois <vincent.courtois@mycar-innovations.com>
+  class Validator
+    include Aquarium::DSL
+
+    # @!attribute [r] datas
+      # @return The datas to filter, they shouldn't be modified to guarantee their integrity.
+    attr_reader :datas
+
+    # @!attribute [rw] filtered
+      # @return The filtered datas are the datas after they have been filtered (renamed keys for example) by the validator.
+    attr_accessor :filtered
+
+    # Constructor of the classe, receiving the datas to validate and filter.
+    # @param [Hash] datas the datas to validate in the validator.
+    def initialize(datas)
+      @datas    = datas
+      @filtered = Hash.new
+    end
+
+    # @!group Public_interface
+
+    # Checks if the given key is an integer or not.
+    # @param [Object] key the key about which verify the type.
+    # @param [Hash]   options a hash of options passed to this method (see documentation to know which options pass).
+    def integer(key, options = {})
+      match?(key, /\A\d+\Z/) ? store(key, ->(item){item.to_i}, options) : raise_type_error(key, "Integer")
+    end
+
+    # Checks if the given key is a numeric or not.
+    # @param [Object] key the key about which verify the type.
+    # @param [Hash]   options a hash of options passed to this method (see documentation to know which options pass).
+    def numeric(key, options = {})
+      match?(key, /\A([+-]?\d+)([,.](\d+))?\Z/) ? store(key, ->(item){item.sub(/,/, ".").to_f}, options) : raise_type_error(key, "Numeric")
+    end
+
+    # Checks if the given key is a not-empty string or not.
+    # @param [Object] key the key about which verify the type.
+    # @param [Hash]   options a hash of options passed to this method (see documentation to know which options pass).
+    def text(key, options = {})
+      is_typed?(key, String) ? store(key, ->(item){item.to_s}, options) : raise_type_error(key, "String")
+    end
+
+    # Doesn't check the type of the key and let it pass without modification.
+    # @param [Object] key the key about which verify the type.
+    # @param [Hash]   options a hash of options passed to this method (see documentation to know which options pass).
+    def any(key, options = {})
+      store(key, ->(item){item}, options)
+    end
+
+    # Checks if the given key is a datetime or not.
+    # @param [Object] key the key about which verify the type.
+    # @param [Hash]   options a hash of options passed to this method (see documentation to know which options pass).
+    def datetime(key, options = {})
+      begin; store(key, ->(item){DateTime.parse(item.to_s)} , options); rescue; raise_type_error(key, "DateTime"); end
+    end
+
+    # Checks if the given key is a date or not.
+    # @param [Object] key the key about which verify the type.
+    # @param [Hash]   options a hash of options passed to this method (see documentation to know which options pass).
+    def date(key, options = {})
+      begin; store(key, ->(item){Date.parse(item.to_s)}, options); rescue; raise_type_error(key, "Date"); end
+    end
+
+    # Checks if the given key is an array or not.
+    # @param [Object] key the key about which verify the type.
+    # @param [Hash]   options a hash of options passed to this method (see documentation to know which options pass).
+    def array(key, options = {})
+      is_typed?(key, Array) ? store(key, ->(item){item.to_a}, options) : raise_type_error(key, "Array")
+    end
+
+    # Checks if the given key is a hash or not.
+    # @param [Object] key the key about which verify the type.
+    # @param [Hash]   options a hash of options passed to this method (see documentation to know which options pass).
+    def hash(key, options = {})
+      is_typed?(key, Hash) ? store(key, ->(item){item.to_h}, options) : raise_type_error(key, "Hash")
+    end
+
+    # Checks if the given key is a boolean or not.
+    # @param [Object] key the key about which verify the type.
+    # @param [Hash]   options a hash of options passed to this method (see documentation to know which options pass).
+    def boolean(key, options = {})
+      match?(key, /(true)|(false)/) ? store(key, ->(item){to_boolean(item)}, options) : raise_type_error(key, "Numeric")
+    end
+
+    # Checks if the given key is a SSID for a MongoDB object or not.
+    # @param [Object] key the key about which verify the type.
+    # @param [Hash]   options a hash of options passed to this method (see documentation to know which options pass).
+    def ssid(key, options = {})
+      match?(key, /^[0-9a-fA-F]{24}$/) ? store(key, ->(item){BSON::ObjectId.from_string(item.to_s)}, options) : raise_type_error(key, "Moped::BSON::ObjectId")
+    end
+
+    # @!endgroup Public_interface
+
+    # @!group Advices
+
+    # Before advice checking for "required", "dependency", and "dependencies" options.
+    before calls_to: self.instance_methods(false), exclude_methods: [:initialize, :new, :required, :dependency, :dependencies] do |joint_point, validator, *args|
+      unless !defined?(args[1]) or args[1].nil? or args[1].empty?
+        validator.required(args[0]) if (args[1].has_key?(:required) and args[1][:required] == true)
+        if args[1].has_key?(:dependencies)
+          validator.dependencies(args[0], args[1][:dependencies])
+        elsif args[1].has_key?(:dependency)
+          validator.dependency(args[0], args[1][:dependency])
+        end
+      end
+    end
+
+    # After advice checking in numerics if limits are given, and if there are, if they are respected.
+    after calls_to: [:integer, :numeric] do |joint_point, validator, *args|
+      unless !defined?(args[1]) or args[1].nil? or args[1].empty?
+        if(args[1].has_key?(:between))
+          validator.check_min_value(args[0], args[1][:between][0])
+          validator.check_max_value(args[0], args[1][:between][1])
+        else
+          validator.check_min_value(args[0], args[1][:min]) if(args[1].has_key?(:min))
+          validator.check_max_value(args[0], args[1][:max]) if(args[1].has_key?(:max))
+        end
+      end
+    end
+
+    # After advcie for all methods, checking the "in" and "equals" options.
+    after calls_to: self.instance_methods(false), exclude_methods: [:initialize, :new, :required, :dependency, :dependencies] do |joint_point, validator, *args|
+      unless !defined?(args[1]) or args[1].nil? or args[1].empty?
+        if(args[1].has_key?(:in))
+         validator.in_array?(args[0], args[1][:in])
+        elsif(args[1].has_key?(:equals))
+          validator.equals_to?(args[0], args[1][:equals])
+        end
+      end
+    end
+
+    # After advice for hashes, checking the "has_keys" and "contains" options.
+    after calls_to: [:hash] do |joint_point, validator, *args|
+      unless !defined?(args[1]) or args[1].nil? or args[1].empty?
+        validator.has_keys?(args[0], args[1][:has_keys]) if(args[1].has_key?(:has_keys))
+        validator.contains?(args[0], validator.datas[args[0]].values, args[1][:contains]) if(args[1].has_key?(:contains))
+      end
+    end
+
+    # After advice for arrays, checking the "contains" option.
+    after calls_to: [:array] do |joint_point, validator, *args|
+      unless !defined?(args[1]) or args[1].nil? or args[1].empty?
+        validator.contains?(args[0], validator.datas[args[0]], args[1][:contains]) if(args[1].has_key?(:contains))
+      end
+    end
+
+    # @!endgroup Advices
+
+    # Checks if a required key is present in provided datas.
+    # @param [Object] key the key of which check the presence.
+    # @raise [ArgumentError] if the key is not present.
+    def required(key)
+      raise ArgumentError.new("The key #{key} is required and not provided.") unless @datas.has_key?(key)
+    end
+
+    # Syntaxic sugar used to chack several dependencies at once.
+    # @param [Object] key the key needing another key to properly work.
+    # @param [Object] dependency the key needed by another key for it to properly work.
+    # @raise [ArgumentError] if the required dependencies are not present.
+    # @see self#check_dependency the associated singular method.
+    def dependencies(key, dependencies)
+      dependencies.each { |dependency| dependency(key, dependency) }
+    end
+
+    # Checks if a dependency is respected. A dependency is a key openly needed by another key.
+    # @param [Object] key the key needing another key to properly work.
+    # @param [Object] dependency the key needed by another key for it to properly work.
+    # @raise [ArgumentError] if the required dependency is not present.
+    def dependency(key, dependency)
+      raise ArgumentError.new("The key #{key} needs the key #{dependency} but it was not provided.") unless @datas.has_key?(dependency)
+    end
+
+    # Checks if the value associated with the given key is greater than the given minimum value.
+    # @param [Object]  key the key associated with the value to compare.
+    # @param [Numeric] min_value the required minimum value.
+    # @raise [ArgumentError] if the initial value is strictly lesser than the minimum value.
+    def check_min_value(key, min_value)
+      raise ArgumentError.new("The key #{key} was supposed to be greater or equal than #{min_value}, the value was #{datas[key]}") unless datas[key].to_i >= min_value.to_i
+    end
+
+    # Checks if the value associated with the given key is lesser than the given maximum value.
+    # @param [Object]  key the key associated with the value to compare.
+    # @param [Numeric] max_value the required maximum value.
+    # @raise [ArgumentError] if the initial value is strictly greater than the minimum value.
+    def check_max_value(key, max_value)
+      raise ArgumentError.new("The key #{key} was supposed to be lesser or equal than #{max_value}, the value was #{datas[key]}") unless datas[key].to_i <= max_value.to_i
+    end
+
+    # Checks if the value associated with the given key is included in the given array of values.
+    # @param [Object] key the key associated with the value to check.
+    # @param [Array]  values the values in which the initial value should be contained.
+    # @raise [ArgumentError] if the initial value is not included in the given possible values.
+    def in_array?(key, values)
+      raise ArgumentError.new("The key #{key} was supposed to be in [#{values.join(", ")}], the value was #{datas[key]}") unless (values.empty? or values.include?(datas[key]))
+    end
+
+    # Checks if the value associated with the given key is equal to the given value.
+    # @param [Object] key the key associated with the value to check.
+    # @param [Object] value the values with which the initial value should be compared.
+    # @raise [ArgumentError] if the initial value is not equal to the given value.
+    def equals_to?(key, value)
+      raise ArgumentError.new("The key #{key} was supposed to equal than #{value}, the value was #{datas[key]}") unless datas[key] == value
+    end
+
+    # Checks if the value associated with the given key has the given required keys.
+    # @param [Object] key the key associated with the value to check.
+    # @param [Array]  required_keys the keys that the initial Hash typed value should contain.
+    # @raise [ArgumentError] if the initial value has not each and every one of the given keys.
+    def has_keys?(key, required_keys)
+      raise ArgumentError.new("The key #{key} was supposed to contains keys [#{required_keys.join(", ")}]") if (datas[key].keys & required_keys) != required_keys
+    end
+
+    # Checks if the value associated with the given key has the given required values.
+    # @param [Object] key the key associated with the value to check.
+    # @param [Array]  required_keys the values that the initial Enumerable typed value should contain.
+    # @raise [ArgumentError] if the initial value has not each and every one of the given values.
+    def contains?(key, values, required_values)
+      raise ArgumentError.new("The key #{key} was supposed to contains values [#{required_values.join(", ")}]") if (values & required_values) != required_values
+    end
+
+    private
+
+    # Check if the value associated with the given key matches the given regular expression.
+    # @param [Object]   key the key of the value to compare with the given regexp.
+    # @param [Regexp]   regex the regex with which match the initial value.
+    # @return [Boolean] true if the initial value matches the regex, false if not.
+    def match?(key, regex)
+      return (!datas.has_key?(key) or datas[key].to_s.match(regex))
+    end
+
+    # Check if the value associated with the given key is typed with the given type, or with a type inheriting from it.
+    # @param [Object]   key the key of the value to check the type from.
+    # @param [Class]    type the type with which check the initial value.
+    # @return [Boolean] true if the initial value is from the right type, false if not.
+    def is_typed?(key, type)
+      return (!datas.has_key?(key) or datas[key].kind_of?(type))
+    end
+
+    # Tries to store the associated key in the filtered key, transforming it with the given process.
+    # @param [Object] key the key associated with the value to store in the filtered datas.
+    # @param [Proc]   process a process (lambda) to execute on the initial value. Must contain strictly one argument.
+    # @param [Hash]   options the options applied to the initial value. Only the option "rename" is checked and executed here.
+    def store(key, process, options = {})
+      unless (options.has_key?(:extract) and options[:extract] == false)
+        if datas.has_key?(key)
+          value = ((options.has_key?(:cast) and options[:cast] == false) ? datas[key] : process.call(datas[key]))
+          options.has_key?(:rename) ? (@filtered[options[:rename]] = value) : (@filtered[key] = value)
+        end
+      end
+    end
+
+    # Raises a type error with a generic message.
+    # @param [Object] key the key associated from the value triggering the error.
+    # @param [Class]  type the expected type, not respected by the initial value.
+    # @raise [ArgumentError] the chosen type error.
+    def raise_type_error(key, type)
+      raise ArgumentError.new("The key {key} was supposed to be an instance of #{type}, #{key.class} found.")
+    end
+
+    # Transforms a given value in a boolean.
+    # @param [Object] value the value to transform into a boolean.
+    # @return [Boolean] true if the value was true, 1 or yes, false if not.
+    def to_boolean(value)
+      ["true", "1", "yes"].include?(value.to_s) ? true : false
+    end
+
+  end
+end

data/spec/lib/validator_spec.rb

@@ -0,0 +1,437 @@
+require 'spec_helper'
+require './lib/validator.rb'
+
+shared_examples "options" do |process|
+  context ":rename" do
+    it "correctly renames a key when the value is valid" do
+      validator = Charon::Validator.new(valid_datas)
+      validator.send(process, valid_datas.keys.first, rename: :another_name)
+      expect(validator.filtered[:another_name]).to eq(valid_filtered[valid_datas.keys.first])
+    end
+
+    it "correctly doesn't rename a key when the value is invalid" do
+      validator = Charon::Validator.new(invalid_datas)
+      expect(->{validator.send(process, invalid_datas.keys.first, rename: :another_name)}).to raise_error(ArgumentError)
+    end
+  end
+
+  context ":dependency" do
+    it "succeeds when a dependency is given as a key and respected" do
+      validator = Charon::Validator.new(valid_datas.merge({dep: "anything"}))
+      validator.send(process, valid_datas.keys.first, dependency: :dep)
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "fails when a dependency is not respected" do
+      validator = Charon::Validator.new(valid_datas)
+      expect(->{validator.send(process, valid_datas.keys.first, dependency: :another_key_not_existing)}).to raise_error(ArgumentError)
+    end
+  end
+
+  context ":dependencies" do
+    it "succeeds when dependencies are given as an array and respected" do
+      validator = Charon::Validator.new(valid_datas.merge({dep1: "something", dep2: "something else"}))
+      validator.send(process, valid_datas.keys.first, dependencies: [:dep1, :dep2])
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "fails when one of the dependencies is not respected" do
+      validator = Charon::Validator.new(valid_datas.merge({dep1: "anything"}))
+      expect(->{validator.send(process, valid_datas.keys.first, dependencies: [:dep1, :dep2])}).to raise_error(ArgumentError)
+    end
+  end
+
+  context ":required" do
+    it "succeeds when a not required key is not given, but filters nothing" do
+      validator = Charon::Validator.new(valid_datas)
+      validator.send(process, :not_required_key)
+      expect(validator.filtered).to be_empty
+    end
+
+    it "suceeds when a key has a required option to false, and is not given, but filters nothing" do
+      validator = Charon::Validator.new(valid_datas)
+      validator.send(process, :not_in_hash, required: false)
+      expect(validator.filtered).to be_empty
+    end
+
+    it "fails when a required key is not given" do
+      validator = Charon::Validator.new(valid_datas)
+      expect(->{validator.send(process, :not_in_hash, required: true)}).to raise_error(ArgumentError)
+    end
+  end
+
+  context ":in" do
+    it "succeeds when the value is effectively in the possible values" do
+      validator = Charon::Validator.new(valid_datas)
+      validator.send(process, valid_datas.keys.first, :in => [valid_datas[valid_datas.keys.first], "another random data"])
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "succeeds if there are no values" do
+      validator = Charon::Validator.new(valid_datas)
+      validator.send(process, valid_datas.keys.first, :in => [])
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "fails if the value is not in the possible values" do
+      validator = Charon::Validator.new(valid_datas)
+      expect(->{validator.send(process, valid_datas.keys.first, :in => ["anything but the value", "another impossible thing"])}).to raise_error(ArgumentError)
+    end
+  end
+
+  context ":equals" do
+    it "succeeds when the value is equal to the given value" do
+      validator = Charon::Validator.new(valid_datas)
+      validator.send(process, valid_datas.keys.first, :equals => valid_datas[valid_datas.keys.first])
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "fails if the value is not equal to the given value" do
+      validator = Charon::Validator.new(valid_datas)
+      expect(->{validator.send(process, valid_datas.keys.first, :equals => "anything but the given value")}).to raise_error(ArgumentError)
+    end
+  end
+
+  context ":extract" do
+    it "etracts the data when given at true" do
+      validator = Charon::Validator.new(valid_datas)
+      validator.send(process, valid_datas.keys.first, :extract => false)
+      expect(validator.filtered).to eq({})
+    end
+
+    it "doesn't extract the data when given at false" do
+      validator = Charon::Validator.new(valid_datas)
+      validator.send(process, valid_datas.keys.first, :extract => true)
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+  end
+
+  context ":cast" do
+    it "casts the data when given at true" do
+      validator = Charon::Validator.new(valid_datas)
+      validator.send(process, valid_datas.keys.first, :cast => true)
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "doesn't cast the data when given at false" do
+      validator = Charon::Validator.new(valid_datas)
+      validator.send(process, valid_datas.keys.first, :cast => false)
+      expect(validator.filtered).to eq(valid_datas)
+    end
+  end
+end
+
+shared_examples "type checker" do |type, process|
+  it "succeeds when given an instance of #{type}" do
+    validator = Charon::Validator.new(valid_datas)
+    validator.send(process, valid_datas.keys.first)
+    expect(validator.filtered).to eq(valid_filtered)
+  end
+
+  it "fails when given something else than an instance of #{type}" do
+    validator = Charon::Validator.new(invalid_datas)
+    expect(->{validator.send(process, invalid_datas.keys.first)}).to raise_error(ArgumentError)
+  end
+end
+
+shared_examples "min/max checker" do |process, key, transformation|
+  let(:value)     { valid_datas[key].send(transformation) }
+  let(:validator) { Charon::Validator.new(valid_datas) }
+
+  context ":min" do
+    it "succeeds when a min option is given, and the value is strictly greater than it" do
+      validator.send(process, key, {min: value-1})
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "succeeds when a min option is given, and the value is equal to it" do
+      validator.send(process, key, {min: value})
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "fails when a min option is given, but not respected" do
+      expect(->{validator.send(process, key, {min: value+1})}).to raise_error(ArgumentError)
+    end
+  end
+
+  context ":max" do
+    it "succeeds when a max option is given, and the value is strictly lesser than it" do
+      validator.send(process, key, {max: value+1})
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "succeeds when a max option is given, and the value is equal to it" do
+      validator.send(process, key, {max: value})
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "fails when a max option is given, but not respected" do
+      expect(->{validator.send(process, key, {max: value-1})}).to raise_error(ArgumentError)
+    end
+  end
+
+  context ":between" do
+
+    it "succeeds when a between option is given, and respected" do
+      validator.send(process, key, {between: [value-1, value+1]})
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "fails when a max between option is given, but the value is strictly lesser" do
+      expect(->{validator.send(process, key, {between: [value+1, value+2]})}).to raise_error(ArgumentError)
+    end
+
+    it "fails when a max between option is given, but the value is strictly greater" do
+      expect(->{validator.send(process, key, {between: [value-2, value-1]})}).to raise_error(ArgumentError)
+    end
+
+    it "fails when a max between option is given, but the value is equal to the inferior limit" do
+      validator.send(process, key, {between: [value, value+1]})
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "fails when a max between option is given, but the value is equal to the superio limit" do
+      validator.send(process, key, {between: [value-1, value]})
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+  end
+end
+
+shared_examples "contains option" do |process, key|
+  context ":contains" do
+    it "succeeds if all values are contained" do
+      validator = Charon::Validator.new(valid_datas)
+      validator.send(process, key, contains: ["val1", "val2"])
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "fails if only some values are contained" do
+      validator = Charon::Validator.new(valid_datas)
+      expect(->{validator.send(process, key, contains: ["val1", "val3"])}).to raise_error(ArgumentError)
+    end
+
+    it "fails if none of the values are contained" do
+      validator = Charon::Validator.new(valid_datas)
+      expect(->{validator.send(process, key, contains: ["val3", "val4"])}).to raise_error(ArgumentError)
+    end
+  end
+end
+
+describe "Validator" do
+  context "integer" do
+    let(:valid_datas)    { {is_an_integer: "1000"} }
+    let(:valid_filtered) { {is_an_integer: 1000} }
+    let(:invalid_datas)  { {is_not_an_integer: "something else"} }
+
+    it "succeeds when given an integer" do
+      validator = Charon::Validator.new(valid_datas)
+      validator.integer(:is_an_integer)
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "fails when given a float" do
+      validator = Charon::Validator.new({is_not_an_integer: 1000.5})
+      expect(->{validator.integer(:is_not_an_integer)}).to raise_error(ArgumentError)
+    end
+
+    it "fails when not given a numeric" do
+      validator = Charon::Validator.new(invalid_datas)
+      expect(->{validator.integer(:is_not_an_integer)}).to raise_error(ArgumentError)
+    end
+
+    context "options" do
+      include_examples "options", :integer
+      include_examples "min/max checker", :integer, :is_an_integer, :to_i
+    end
+  end
+
+  context "numeric" do
+    let(:valid_datas)    { {is_a_double: "1000.5"} }
+    let(:valid_filtered) { {is_a_double: 1000.5} }
+    let(:invalid_datas)  { {is_not_a_numeric: "something else"} }
+
+    it "succeeds when given an integer" do
+      validator = Charon::Validator.new({is_an_integer: "1000"})
+      validator.numeric(:is_an_integer)
+      expect(validator.filtered).to eq({is_an_integer: 1000})
+    end
+
+    it "succeeds when given an decimal number with a dot" do
+      validator = Charon::Validator.new(valid_datas)
+      validator.numeric(:is_a_double)
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "succeeds when given an decimal number with a comma" do
+      validator = Charon::Validator.new({is_a_double: "1000,5"})
+      validator.numeric(:is_a_double)
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "fails when not given a numeric" do
+      validator = Charon::Validator.new(invalid_datas)
+      expect(->{validator.integer(:is_not_a_numeric)}).to raise_error(ArgumentError)
+    end
+
+    context "options" do
+      include_examples "options", :numeric
+      include_examples "min/max checker", :numeric, :is_a_double, :to_f
+    end
+  end
+
+  context "text" do
+    let(:valid_datas)    { {is_a_string: "something"} }
+    let(:valid_filtered) { {is_a_string: "something"} }
+    let(:invalid_datas)  { {is_not_a_string: 1000} }
+
+    include_examples "type checker", "String", :text
+
+    context "options" do
+      include_examples "options", :text
+    end
+  end
+
+  context "datetime" do
+    let(:date_time)      { DateTime.new }
+    let(:valid_datas)    { {is_a_datetime: date_time.to_s} }
+    let(:valid_filtered) { {is_a_datetime: date_time} }
+    let(:invalid_datas)  { {is_not_a_datetime: "something else"} }
+
+    it "succeeds when given a valid datetime as a string" do
+      validator = Charon::Validator.new(valid_datas)
+      validator.datetime(:is_a_datetime)
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "succeeds when given a valid datetime as a DateTime Object" do
+      validator = Charon::Validator.new(valid_filtered)
+      validator.datetime(:is_a_datetime)
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "fails when given something else than a valid datetime" do
+      validator = Charon::Validator.new(invalid_datas)
+      expect(->{validator.datetime(:is_not_a_datetime)}).to raise_error(ArgumentError)
+    end
+
+    context "options" do
+      include_examples "options", :datetime
+    end
+  end
+
+  context "date" do
+    let(:date)           { Date.new }
+    let(:valid_datas)    { {is_a_date: date.to_s} }
+    let(:valid_filtered) { {is_a_date: date} }
+    let(:invalid_datas)  { {is_not_a_date: "something else"} }
+
+    it "succeeds when given a valid date as a string" do
+      validator = Charon::Validator.new(valid_datas)
+      validator.date(:is_a_date)
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "succeeds when given a valid date as a Date Object" do
+      validator = Charon::Validator.new(valid_filtered)
+      validator.date(:is_a_date)
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "fails when given something else than a valid date" do
+      validator = Charon::Validator.new(invalid_datas)
+      expect(->{validator.date(:is_not_a_date)}).to raise_error(ArgumentError)
+    end
+
+    context "options" do
+      include_examples "options", :date
+    end
+  end
+
+  context "array" do
+    let(:valid_datas)    { {is_an_array: ["val1", "val2"]} }
+    let(:valid_filtered) { {is_an_array: ["val1", "val2"]} }
+    let(:invalid_datas)  { {is_not_an_array: 1000} }
+
+    include_examples "type checker", "Array", :array
+
+    context "options" do
+      include_examples "options", :array
+      include_examples "contains option", :array, :is_an_array
+    end
+  end
+
+  context "hash" do
+    let(:valid_datas)    { {is_a_hash: {key1: "val1", key2: "val2"}} }
+    let(:valid_filtered) { {is_a_hash: {key1: "val1", key2: "val2"}} }
+    let(:invalid_datas)  { {is_not_a_hash: 1000} }
+
+    include_examples "type checker", "Hash", :hash
+
+    context "options" do
+      include_examples "options", :hash
+      include_examples "contains option", :hash, :is_a_hash
+
+      context ":has_keys" do
+        it "succeeds if all keys are contained in the hash" do
+          validator = Charon::Validator.new(valid_datas)
+          validator.hash(:is_a_hash, has_keys: [:key1, :key2])
+          expect(validator.filtered).to eq(valid_filtered)
+        end
+
+        it "fails if not all keys are given in the hash" do
+          validator = Charon::Validator.new(valid_datas)
+          expect(->{validator.hash(:is_a_hash, has_keys: [:key1, :key3])}).to raise_error(ArgumentError)
+        end
+
+        it "fails if no keys are contained in the hash" do
+          validator = Charon::Validator.new(valid_datas)
+          expect(->{validator.hash(:is_a_hash, has_keys: [:key3, :key4])}).to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+
+  context "boolean" do
+    let(:valid_datas)    { {is_a_boolean: "true"} }
+    let(:valid_filtered) { {is_a_boolean: true} }
+    let(:invalid_datas)  { {is_not_a_boolean: "anything else"} }
+
+    it "succeeds when given a boolean" do
+      validator = Charon::Validator.new(valid_datas)
+      validator.boolean(:is_a_boolean)
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "fails when not given a boolean" do
+      validator = Charon::Validator.new(invalid_datas)
+      expect(->{validator.boolean(:is_not_a_boolean)}).to raise_error(ArgumentError)
+    end
+
+    context "options" do
+      include_examples "options", :boolean
+    end
+  end
+
+  context "ssid" do
+    let(:valid_ssid)     { BSON::ObjectId.new }
+    let(:valid_datas)    { {is_a_ssid: valid_ssid.to_s} }
+    let(:valid_filtered) { {is_a_ssid: valid_ssid} }
+    let(:invalid_datas)  { {is_not_a_ssid: "anything else"} }
+
+    it "succeeds when given a valid SSID" do
+      validator = Charon::Validator.new(valid_datas)
+      validator.ssid(:is_a_ssid)
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    it "fails when not given a SSID" do
+      validator = Charon::Validator.new(invalid_datas)
+      expect(->{validator.ssid(:is_not_a_ssid)}).to raise_error(ArgumentError)
+    end
+
+    context "options" do
+      include_examples "options", :ssid
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+# Sets the environment variable to test before loading all the files.
+ENV['RACK_ENV'] = 'test'
+
+require 'rack/test'
+require 'mocha/api'
+require 'aquarium'
+require 'moped'
+
+module RSpec
+  configure do |configuration|
+    # Configuration rspec to use mocha as mocking API.
+    configuration.mock_with :mocha
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: kharon
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Vincent Courtois
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aquarium
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+description: Charon let you pass or not pass depending if you meet the criterias for
+  this... Or not.
+email: vincent.courtois@mycar-innovations.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/validator.rb
+- lib/validate.rb
+- spec/spec_helper.rb
+- spec/lib/validator_spec.rb
+homepage: https://rubygems.org/gems/kharon
+licenses:
+- Apache License 2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Ruby Hash validator
+test_files:
+- spec/spec_helper.rb
+- spec/lib/validator_spec.rb