kharon 0.4.0 → 0.5.0

data/README.md

@@ -26,6 +26,20 @@ gem install kharon
 
 And... That's it ! Now it's installed and you can learn how to properly use it !
 
+### With bundler
+
+Add it to your Gemfile :
+
+```
+gem "kharon", "~> 0.4.0"
+```
+
+then run the following command :
+
+```
+bundle install
+```
+
 ### From sources
 
 Clone this repository whenether you want, go inside, then type the following command :

data/kharon.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |specification|
   specification.summary     = "Ruby Hash validator"
   specification.description = "Kharon is a ruby hash validator that helps you fix the structure of a hash (type of the keys, dependencies, ...)."
   specification.authors     = ["Vincent Courtois"]
-  specification.email       = "vincent.courtois@mycar-innovations.com"
+  specification.email       = "courtois.vincent@outlook.com"
   specification.files       = `git ls-files`.split($/)
   specification.homepage    = "https://rubygems.org/gems/kharon"
   specification.license     = "Apache License 2"

data/lib/kharon.rb

@@ -1,7 +1,24 @@
 require "kharon/version"
 require "kharon/validator"
 require "kharon/helpers/validate"
+require "kharon/configuration"
+
+require "kharon/errors/validation"
+
+require "kharon/handlers/exceptions"
+require "kharon/handlers/messages"
 
 module Kharon
 
+  # Configuration method used to tell the module if it uses exceptions or stores error messages.
+  # @param [Boolean] use TRUE if you want to use exceptions, FALSE else.
+  def self.use_exceptions(use = true)
+    Kharon::Configuration.instance.use_exceptions(use)
+  end
+
+  # Returns the current error handler, defined by if you use exceptions or not.
+  # @return [Object] an instance of Kharon::Handlers::Exceptions if you use exceptions, an instance of Kharon::Handlers::Messages else.
+  def self.errors_handler
+    Kharon::Configuration.instance.uses_exceptions? ? Kharon::Handlers::Exceptions.instance : Kharon::Handlers::Messages.new
+  end
 end

data/lib/kharon/configuration.rb

@@ -0,0 +1,28 @@
+require "singleton"
+require "yaml"
+
+module Kharon
+
+  # Simple wrapper for the configuration.
+  # @author Vincent Courtois <courtois.vincent@outlook.com>
+  class Configuration
+    include Singleton
+
+    attr_accessor :configuration
+
+    # Constructor of the configuration, initializes default values for each usable key.
+    def initialize
+      @configuration = {
+        exceptions: true
+      }
+    end
+
+    def use_exceptions(use = true)
+      @configuration[:exceptions] = use
+    end
+
+    def uses_exceptions?
+      @configuration[:exceptions]
+    end
+  end
+end

data/lib/kharon/errors/validation.rb

@@ -0,0 +1,25 @@
+module Kharon
+  module Errors
+
+    # Standard exception raised in case the exceptions are used, and there is an error in the validation.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    class Validation < Exception
+
+      # @!attribute [rw] error_hash
+        # @return [Hash] the description of the encountered error as a Hash.
+      attr_accessor :error_hash
+
+      # Constructor of the class.
+      # @param [Hash] error_hash the description of the encountered error as a Hash.
+      def initialize(error_hash)
+        @error_hash = error_hash
+      end
+
+      # Generates a JSON version of the encountered error description hash.
+      # @return [String] the JSON representation of an error.
+      def message
+        JSON.generate(error_hash)
+      end
+    end
+  end
+end

data/lib/kharon/handlers/exceptions.rb

@@ -0,0 +1,17 @@
+module Kharon
+  module Handlers
+
+    # Errors handler that raises exception as soon as a problem is encountered during validation.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    class Exceptions
+      include Singleton
+
+      # Method used to report an error by raising the correct type of exception.
+      # @param [Hash] error_hash a Hash describing the error.
+      # @raises [Kharon::Errors::Validation] the exception raised when an error is encountered.
+      def report_error(error_hash)
+        raise Kharon::Errors::Validation.new(error_hash)
+      end
+    end
+  end
+end

data/lib/kharon/handlers/messages.rb

@@ -0,0 +1,21 @@
+module Kharon
+  module Handlers
+
+    # Errors handler that stores each problem encountered during validation.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    class Messages
+
+      # @!attribute [rw] errors the errors stored if encountered during validation process.
+        # @return [Array] an array of hashes, each Hash being the description of an error.
+      attr_accessor :errors
+
+      # Method used to report an error by storing it in an array.
+      # @param [Hash] error_hash a Hash describing the error.
+      # @return [Kharon::Handlers::Messages] the errors handler after insertion, so several calls can be chained.
+      def report_error(error_hash)
+        errors.push(error_hash)
+        self
+      end
+    end
+  end
+end

data/lib/kharon/helpers/validate.rb

@@ -6,7 +6,7 @@ module Kharon
     # @param  [Proc] block the instructions to apply on the validator.
     # @return [Hash] the validated and filtered datas.
     def validate(datas, &block)
-      validator = Kharon::Factory.validator(datas)
+      validator = Kharon::Validator.new(datas)
       validator.instance_eval(&block)
       return validator.filtered
     end

data/lib/kharon/validator.rb

@@ -1,17 +1,21 @@
 module Kharon
 
   # The validator is the main class of Kharon, it validates a hash given a structure.
-  # @author Vincent Courtois <vincent.courtois@mycar-innovations.com>
+  # @author Vincent Courtois <courtois.vincent@outlook.com>
   class Validator
 
     # @!attribute [r] datas
-      # @return The datas to filter, they shouldn't be modified to guarantee their integrity.
+      # @return [Hash] 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.
+      # @return [Hash] The filtered datas are the datas after they have been filtered (renamed keys for example) by the validator.
     attr_accessor :filtered
 
+    # @!attribute [rw] handler
+      # @return [Object] the error handler given to this instance of the validator.
+    attr_accessor :handler
+
     # Constructor of the classe, receiving the datas to validate and filter.
     # @param [Hash] datas the datas to validate in the validator.
     # @example create a new instance of validator.
@@ -19,6 +23,7 @@ module Kharon
     def initialize(datas)
       @datas    = datas
       @filtered = Hash.new
+      @handler  = Kharon.errors_handler
     end
 
     # Checks if the given key is an integer or not.
@@ -215,19 +220,19 @@ module Kharon
 
     def store_box(key, options)
       if(options.has_key?(:at_least))
-        box_contains?(datas[key], options[:at_least])
+        box_contains?(key, datas[key], options[:at_least])
       end
       if(options.has_key?(:at_most))
-        box_contains?(options[:at_most], datas[key])
+        box_contains?(key, options[:at_most], datas[key])
       end
-      store(key, ->(item){parse_box(datas[key])}, options)
+      store(key, ->(item){parse_box(key, datas[key])}, options)
     end
 
     # 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_error("The key #{key} is required and not provided.") unless @datas.has_key?(key)
+      raise_error(type: "required", key: key) unless @datas.has_key?(key)
     end
 
     # Syntaxic sugar used to chack several dependencies at once.
@@ -244,7 +249,7 @@ module Kharon
     # @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_error("The key #{key} needs the key #{dependency} but it was not provided.") unless @datas.has_key?(dependency)
+      raise_error(type: "dependency", key: "key", needed: dependency) unless @datas.has_key?(dependency)
     end
 
     # Checks if the value associated with the given key is greater than the given minimum value.
@@ -252,7 +257,7 @@ module Kharon
     # @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_error("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
+      raise_error(type: "min", supposed: min_value, key: key, value: 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.
@@ -260,7 +265,7 @@ module Kharon
     # @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_error("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
+      raise_error(type: "max", supposed: max_value, key: key, value: 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.
@@ -268,7 +273,7 @@ module Kharon
     # @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_error("The key #{key} was supposed to be in [#{values.join(", ")}], the value was #{datas[key]}") unless (values.empty? or values.include?(datas[key]))
+      raise_error(type: "array.in", key: key, supposed: values, value: 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.
@@ -276,7 +281,7 @@ module Kharon
     # @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_error("The key #{key} was supposed to equal than #{value}, the value was #{datas[key]}") unless datas[key] == value
+      raise_error(type: "equals", key: key, supposed: value, found: datas[key]) unless datas[key] == value
     end
 
     # Checks if the value associated with the given key has the given required keys.
@@ -284,7 +289,7 @@ module Kharon
     # @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_error("The key #{key} was supposed to contains keys [#{required_keys.join(", ")}]") if (datas[key].keys & required_keys) != required_keys
+      raise_error(type: "contains.keys", required: required_keys, key: key) if (datas[key].keys & required_keys) != required_keys
     end
 
     # Checks if the value associated with the given key has the given required values.
@@ -292,12 +297,12 @@ module Kharon
     # @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_error("The key #{key} was supposed to contains values [#{required_values.join(", ")}]") if (values & required_values) != required_values
+      raise_error(type: "contains.values", required: required_values, key: key) if (values & required_values) != required_values
     end
 
     def match_regex?(key, value, regex)
       regex = Regexp.new(regex) if regex.kind_of?(String)
-      raise_error("The key #{key} was supposed to match the regex #{regex} but its value was #{value}") unless regex.match(value)
+      raise_error(type: "regex", regex: regex, value: value, key: key) unless regex.match(value)
     end
 
     # Check if the value associated with the given key matches the given regular expression.
@@ -344,13 +349,13 @@ module Kharon
     # Parses a box given as a string of four numbers separated by commas.
     # @param [String] box the string representing the box.
     # @return [Array] an array of size 2, containing two arrays of size 2 (the first being the coordinates of the top-left corner, the second the ones of the bottom-right corner)
-    def parse_box(box)
+    def parse_box(key, box)
       if box.kind_of?(String)
         begin
           raw_box = box.split(",").map(&:to_f)
           box = [[raw_box[0], raw_box[1]], [raw_box[2], raw_box[3]]]
         rescue
-          raise_error("The box was not correctly formatted")
+          raise_error(type: "box.format", key: "key", value: box)
         end
       end
       return box
@@ -360,11 +365,11 @@ module Kharon
     # @param [Object] container any object that can be treated as a box, container of the other box
     # @param [Object] contained any object that can be treated as a box, contained in the other box
     # @return [Boolean] TRUE if the box is contained in the other one, FALSE if not.
-    def box_contains?(container, contained)
-      container = parse_box(container)
-      contained = parse_box(contained)
+    def box_contains?(key, container, contained)
+      container = parse_box(key, container)
+      contained = parse_box(key, contained)
       result = ((container[0][0] <= contained[0][0]) and (container[0][1] <= container[0][1]) and (container[1][0] >= container[1][0]) and (container[1][1] >= container[1][1]))
-      raise_error("The box #{contained} was supposed to be contained in #{container}") unless result
+      raise_error(type: "box.containment", contained: contained, container: container, key: key) unless result
     end
 
     # Raises a type error with a generic message.
@@ -372,7 +377,7 @@ module Kharon
     # @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_error("The key {key} was supposed to be an instance of #{type}, #{key.class} found.")
+      raise_error(type: "type", key: key, supposed: type, found: key.class)
     end
 
     protected
@@ -381,7 +386,13 @@ module Kharon
     # @param [String] message the the message to display with the exception.
     # @raises ArgumentError an error to stop the execution when this method is invoked.
     def raise_error(message)
-      raise ArgumentError.new(message)
+      handler.report_error(message)
+    end
+
+    # Accessor for the errors, use only if the handler is a Kharon::Handlers::Messages.
+    # @return [Array] the errors encountered during validation or an empty array if the handler was a Kharon::Handlers::Exceptions.
+    def errors
+      handler.respond_to?(:errors) ? handler.errors : []
     end
 
   end

data/lib/kharon/version.rb

@@ -1,3 +1,3 @@
 module Kharon
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/spec/lib/kharon/errors/validation_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe "Errors::Validation" do
+  let!(:error_hash) { {type: "type", key: "custom key"} }
+
+  it "correctly stores the error hash" do
+    expect(Kharon::Errors::Validation.new(error_hash).error_hash).to eq(error_hash)
+  end
+
+  it "correctly return the JSON equivalent of the error hash as message" do
+    expect(Kharon::Errors::Validation.new(error_hash).message).to eq(JSON.generate(error_hash))
+  end
+end

data/spec/lib/kharon/handlers/exceptions_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe "Handlers::Exceptions" do
+  it "always returns the same instance" do
+    expect(Kharon::Handlers::Exceptions.instance).to be(Kharon::Handlers::Exceptions.instance)
+  end
+
+  context "#report_error" do
+    it "raises an error of the right type" do
+      expect{Kharon::Handlers::Exceptions.instance.report_error({})}.to raise_error(Kharon::Errors::Validation)
+    end
+  end
+end

data/spec/lib/kharon/validator_spec.rb

@@ -10,7 +10,7 @@ shared_examples "options" do |process|
 
     it "correctly doesn't rename a key when the value is invalid" do
       validator = Kharon::Validator.new(invalid_datas)
-      expect(->{validator.send(process, invalid_datas.keys.first, rename: :another_name)}).to raise_error(ArgumentError)
+      expect(->{validator.send(process, invalid_datas.keys.first, rename: :another_name)}).to raise_error(Kharon::Errors::Validation)
     end
   end
 
@@ -23,7 +23,7 @@ shared_examples "options" do |process|
 
     it "fails when a dependency is not respected" do
       validator = Kharon::Validator.new(valid_datas)
-      expect(->{validator.send(process, valid_datas.keys.first, dependency: :another_key_not_existing)}).to raise_error(ArgumentError)
+      expect(->{validator.send(process, valid_datas.keys.first, dependency: :another_key_not_existing)}).to raise_error(Kharon::Errors::Validation)
     end
   end
 
@@ -36,7 +36,7 @@ shared_examples "options" do |process|
 
     it "fails when one of the dependencies is not respected" do
       validator = Kharon::Validator.new(valid_datas.merge({dep1: "anything"}))
-      expect(->{validator.send(process, valid_datas.keys.first, dependencies: [:dep1, :dep2])}).to raise_error(ArgumentError)
+      expect(->{validator.send(process, valid_datas.keys.first, dependencies: [:dep1, :dep2])}).to raise_error(Kharon::Errors::Validation)
     end
   end
 
@@ -55,7 +55,7 @@ shared_examples "options" do |process|
 
     it "fails when a required key is not given" do
       validator = Kharon::Validator.new(valid_datas)
-      expect(->{validator.send(process, :not_in_hash, required: true)}).to raise_error(ArgumentError)
+      expect(->{validator.send(process, :not_in_hash, required: true)}).to raise_error(Kharon::Errors::Validation)
     end
   end
 
@@ -74,7 +74,7 @@ shared_examples "options" do |process|
 
     it "fails if the value is not in the possible values" do
       validator = Kharon::Validator.new(valid_datas)
-      expect(->{validator.send(process, valid_datas.keys.first, :in => ["anything but the value", "another impossible thing"])}).to raise_error(ArgumentError)
+      expect(->{validator.send(process, valid_datas.keys.first, :in => ["anything but the value", "another impossible thing"])}).to raise_error(Kharon::Errors::Validation)
     end
   end
 
@@ -87,7 +87,7 @@ shared_examples "options" do |process|
 
     it "fails if the value is not equal to the given value" do
       validator = Kharon::Validator.new(valid_datas)
-      expect(->{validator.send(process, valid_datas.keys.first, :equals => "anything but the given value")}).to raise_error(ArgumentError)
+      expect(->{validator.send(process, valid_datas.keys.first, :equals => "anything but the given value")}).to raise_error(Kharon::Errors::Validation)
     end
   end
 
@@ -129,7 +129,7 @@ shared_examples "type checker" do |type, process|
 
   it "fails when given something else than an instance of #{type}" do
     validator = Kharon::Validator.new(invalid_datas)
-    expect(->{validator.send(process, invalid_datas.keys.first)}).to raise_error(ArgumentError)
+    expect(->{validator.send(process, invalid_datas.keys.first)}).to raise_error(Kharon::Errors::Validation)
   end
 end
 
@@ -149,7 +149,7 @@ shared_examples "min/max checker" do |process, key, transformation|
     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)
+      expect(->{validator.send(process, key, {min: value+1})}).to raise_error(Kharon::Errors::Validation)
     end
   end
 
@@ -165,7 +165,7 @@ shared_examples "min/max checker" do |process, key, transformation|
     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)
+      expect(->{validator.send(process, key, {max: value-1})}).to raise_error(Kharon::Errors::Validation)
     end
   end
 
@@ -177,11 +177,11 @@ shared_examples "min/max checker" do |process, key, transformation|
     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)
+      expect(->{validator.send(process, key, {between: [value+1, value+2]})}).to raise_error(Kharon::Errors::Validation)
     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)
+      expect(->{validator.send(process, key, {between: [value-2, value-1]})}).to raise_error(Kharon::Errors::Validation)
     end
 
     it "fails when a max between option is given, but the value is equal to the inferior limit" do
@@ -206,12 +206,12 @@ shared_examples "contains option" do |process, key|
 
     it "fails if only some values are contained" do
       validator = Kharon::Validator.new(valid_datas)
-      expect(->{validator.send(process, key, contains: ["val1", "val3"])}).to raise_error(ArgumentError)
+      expect(->{validator.send(process, key, contains: ["val1", "val3"])}).to raise_error(Kharon::Errors::Validation)
     end
 
     it "fails if none of the values are contained" do
       validator = Kharon::Validator.new(valid_datas)
-      expect(->{validator.send(process, key, contains: ["val3", "val4"])}).to raise_error(ArgumentError)
+      expect(->{validator.send(process, key, contains: ["val3", "val4"])}).to raise_error(Kharon::Errors::Validation)
     end
   end
 end
@@ -230,12 +230,12 @@ describe "Validator" do
 
     it "fails when given a float" do
       validator = Kharon::Validator.new({is_not_an_integer: 1000.5})
-      expect(->{validator.integer(:is_not_an_integer)}).to raise_error(ArgumentError)
+      expect(->{validator.integer(:is_not_an_integer)}).to raise_error(Kharon::Errors::Validation)
     end
 
     it "fails when not given a numeric" do
       validator = Kharon::Validator.new(invalid_datas)
-      expect(->{validator.integer(:is_not_an_integer)}).to raise_error(ArgumentError)
+      expect(->{validator.integer(:is_not_an_integer)}).to raise_error(Kharon::Errors::Validation)
     end
 
     context "options" do
@@ -269,7 +269,7 @@ describe "Validator" do
 
     it "fails when not given a numeric" do
       validator = Kharon::Validator.new(invalid_datas)
-      expect(->{validator.integer(:is_not_a_numeric)}).to raise_error(ArgumentError)
+      expect(->{validator.integer(:is_not_a_numeric)}).to raise_error(Kharon::Errors::Validation)
     end
 
     context "options" do
@@ -339,7 +339,7 @@ describe "Validator" do
 
         it "fails when the regular expression is not respected" do
           validator = Kharon::Validator.new(valid_datas)
-          expect(->{validator.text(:is_a_string, regex: "anything else")}).to raise_error(ArgumentError)
+          expect(->{validator.text(:is_a_string, regex: "anything else")}).to raise_error(Kharon::Errors::Validation)
         end
       end
     end
@@ -365,7 +365,7 @@ describe "Validator" do
 
     it "fails when given something else than a valid datetime" do
       validator = Kharon::Validator.new(invalid_datas)
-      expect(->{validator.datetime(:is_not_a_datetime)}).to raise_error(ArgumentError)
+      expect(->{validator.datetime(:is_not_a_datetime)}).to raise_error(Kharon::Errors::Validation)
     end
 
     context "options" do
@@ -393,7 +393,7 @@ describe "Validator" do
 
     it "fails when given something else than a valid date" do
       validator = Kharon::Validator.new(invalid_datas)
-      expect(->{validator.date(:is_not_a_date)}).to raise_error(ArgumentError)
+      expect(->{validator.date(:is_not_a_date)}).to raise_error(Kharon::Errors::Validation)
     end
 
     context "options" do
@@ -434,12 +434,12 @@ describe "Validator" do
 
         it "fails if not all keys are given in the hash" do
           validator = Kharon::Validator.new(valid_datas)
-          expect(->{validator.hash(:is_a_hash, has_keys: [:key1, :key3])}).to raise_error(ArgumentError)
+          expect(->{validator.hash(:is_a_hash, has_keys: [:key1, :key3])}).to raise_error(Kharon::Errors::Validation)
         end
 
         it "fails if no keys are contained in the hash" do
           validator = Kharon::Validator.new(valid_datas)
-          expect(->{validator.hash(:is_a_hash, has_keys: [:key3, :key4])}).to raise_error(ArgumentError)
+          expect(->{validator.hash(:is_a_hash, has_keys: [:key3, :key4])}).to raise_error(Kharon::Errors::Validation)
         end
       end
     end
@@ -458,7 +458,7 @@ describe "Validator" do
 
     it "fails when not given a boolean" do
       validator = Kharon::Validator.new(invalid_datas)
-      expect(->{validator.boolean(:is_not_a_boolean)}).to raise_error(ArgumentError)
+      expect(->{validator.boolean(:is_not_a_boolean)}).to raise_error(Kharon::Errors::Validation)
     end
 
     context "options" do
@@ -480,7 +480,7 @@ describe "Validator" do
 
     it "fails when not given a SSID" do
       validator = Kharon::Validator.new(invalid_datas)
-      expect(->{validator.ssid(:is_not_a_ssid)}).to raise_error(ArgumentError)
+      expect(->{validator.ssid(:is_not_a_ssid)}).to raise_error(Kharon::Errors::Validation)
     end
 
     context "options" do
@@ -504,27 +504,27 @@ describe "Validator" do
 
     it "fails when not given a box" do
       validator = Kharon::Validator.new(invalid_datas)
-      expect(->{validator.box(:is_not_a_box)}).to raise_error(ArgumentError)
+      expect(->{validator.box(:is_not_a_box)}).to raise_error(Kharon::Errors::Validation)
     end
 
     it "fails with an invalid top longitude" do
       validator = Kharon::Validator.new(is_an_invalid_box: "test,12,12.0,-12.0")
-      expect(->{validator.box(:is_an_invalid_box)}).to raise_error(ArgumentError)
+      expect(->{validator.box(:is_an_invalid_box)}).to raise_error(Kharon::Errors::Validation)
     end
 
     it "fails with an invalid top latitude" do
       validator = Kharon::Validator.new(is_an_invalid_box: "0,test,12.0,-12.0")
-      expect(->{validator.box(:is_an_invalid_box)}).to raise_error(ArgumentError)
+      expect(->{validator.box(:is_an_invalid_box)}).to raise_error(Kharon::Errors::Validation)
     end
 
     it "fails with an invalid down longitude" do
       validator = Kharon::Validator.new(is_an_invalid_box: "0,12,test,-12.0")
-      expect(->{validator.box(:is_an_invalid_box)}).to raise_error(ArgumentError)
+      expect(->{validator.box(:is_an_invalid_box)}).to raise_error(Kharon::Errors::Validation)
     end
 
     it "fails with an invalid down latitude" do
       validator = Kharon::Validator.new(is_an_invalid_box: "0,12,12.0,test")
-      expect(->{validator.box(:is_an_invalid_box)}).to raise_error(ArgumentError)
+      expect(->{validator.box(:is_an_invalid_box)}).to raise_error(Kharon::Errors::Validation)
     end
 
     context "options" do
@@ -541,7 +541,7 @@ describe "Validator" do
         end
 
         it "fails if the box is smaller than the one given with the at_least option" do
-          expect(->{@validator.box(:is_a_box, at_least: [[-20, -20], [1000, 1000]])}).to raise_error(ArgumentError)
+          expect(->{@validator.box(:is_a_box, at_least: [[-20, -20], [1000, 1000]])}).to raise_error(Kharon::Errors::Validation)
         end
       end
 
@@ -556,7 +556,7 @@ describe "Validator" do
         end
 
         it "fails if the box is bigger than the one given with the at_most option" do
-          expect(->{@validator.box(:is_a_box, at_most: [[10, 10], [20, 20]])}).to raise_error(ArgumentError)
+          expect(->{@validator.box(:is_a_box, at_most: [[10, 10], [20, 20]])}).to raise_error(Kharon::Errors::Validation)
         end
       end
     end
@@ -575,7 +575,7 @@ describe "Validator" do
 
     it "fails when not given a email" do
       validator = Kharon::Validator.new(invalid_datas)
-      expect(->{validator.email(:is_not_an_email)}).to raise_error(ArgumentError)
+      expect(->{validator.email(:is_not_an_email)}).to raise_error(Kharon::Errors::Validation)
     end
 
     context "options" do

data/spec/lib/kharon_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe "Kharon" do
+  it "Can not use exceptions" do
+    Kharon.use_exceptions(false)
+    expect(Kharon.errors_handler).to be_a(Kharon::Handlers::Messages)
+  end
+
+  it "Can use exceptions" do
+    Kharon.use_exceptions(true)
+    expect(Kharon.errors_handler).to be_a(Kharon::Handlers::Exceptions)
+  end
+end

data/spec/spec_helper.rb

@@ -4,4 +4,6 @@ Bundler.setup
 # Sets the environment variable to test before loading all the files.
 ENV['RACK_ENV'] = 'test'
 
+require "bson"
+require "json"
 require "kharon"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kharon
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -29,7 +29,7 @@ dependencies:
         version: 2.2.2
 description: Kharon is a ruby hash validator that helps you fix the structure of a
   hash (type of the keys, dependencies, ...).
-email: vincent.courtois@mycar-innovations.com
+email: courtois.vincent@outlook.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -46,13 +46,22 @@ files:
 - kharon-0.2.0.gem
 - kharon-0.3.0.gem
 - kharon-0.3.1.gem
+- kharon-0.4.0.gem
 - kharon.gemspec
 - lib/kharon.rb
+- lib/kharon/configuration.rb
+- lib/kharon/errors/validation.rb
+- lib/kharon/handlers/exceptions.rb
+- lib/kharon/handlers/messages.rb
 - lib/kharon/helpers/validate.rb
 - lib/kharon/validator.rb
 - lib/kharon/version.rb
+- spec/lib/kharon/errors/validation_spec.rb
+- spec/lib/kharon/handlers/exceptions_spec.rb
 - spec/lib/kharon/validator_spec.rb
+- spec/lib/kharon_spec.rb
 - spec/spec_helper.rb
+- spec/utils/fake_config.yml
 homepage: https://rubygems.org/gems/kharon
 licenses:
 - Apache License 2