kharon 0.3.1 → 0.4.0

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org/"
+ruby   "1.9.3"
+
+gem "bson", "2.2.2"
+
+# These gems are only used for testing purposes, and shouldn't be used in another environment than the local development one.
+group :test do
+  gem "rack-test", "0.6.2"
+  gem "rspec"    , "3.0.0.beta2"
+end

data/Gemfile.lock

@@ -0,0 +1,28 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    bson (2.2.2)
+    diff-lcs (1.2.5)
+    rack (1.5.2)
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rspec (3.0.0.beta2)
+      rspec-core (= 3.0.0.beta2)
+      rspec-expectations (= 3.0.0.beta2)
+      rspec-mocks (= 3.0.0.beta2)
+    rspec-core (3.0.0.beta2)
+      rspec-support (= 3.0.0.beta2)
+    rspec-expectations (3.0.0.beta2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (= 3.0.0.beta2)
+    rspec-mocks (3.0.0.beta2)
+      rspec-support (= 3.0.0.beta2)
+    rspec-support (3.0.0.beta2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bson (= 2.2.2)
+  rack-test (= 0.6.2)
+  rspec (= 3.0.0.beta2)

data/LICENSE

@@ -0,0 +1,201 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   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.

data/README.md

@@ -0,0 +1,206 @@
+# Kharon the boatkeeper
+
+## What is kharon ?
+
+Charon (or Khàrôn in ancient greek) was, in the greek mythology, the ferryman to cross the Styx river. He decided who passed, and who didn't pass, and it's exactly what this gem does.
+
+It validates the datas in a hash given criterias about its keys, and let the execution of the program continue if the requirements are fulfilled, stop it if not. The datas in the hash are supposed to be strings, Kharon being designed to validate datas coming in a web application from the outside (tipically, datas passed in a querystring or a POST body).
+
+## Contact me
+
+For any question or advice, contact me at vincent.courtois@mycar-innovations.com. I'll answer as soon as possible, and thank you by advance for giving me some of your time.
+
+## Requirements
+
+You'll just need Ruby 1.9.3 at least to make it work.
+
+## Installation
+
+### From Rubygems.org
+
+It's a gem, you know how to install a gem, or you should if you're using it in a ruby application. Okay, let's consider you don't, just type :
+
+```
+gem install kharon
+```
+
+And... That's it ! Now it's installed and you can learn how to properly use it !
+
+### From sources
+
+Clone this repository whenether you want, go inside, then type the following command :
+
+```
+gem install kharon-0.3.0
+```
+
+The gem will be installed on your system, from then on you can use it inside your applications.
+
+## Configuration
+
+The configuration of the module is simple, juste use the #configure method from the Kharon::Factory module as follow :
+
+```ruby
+Kharon::Factory.configure do |configuration|
+  # Decides whether you want to use exceptions or not. Default is TRUE.
+  configuration.use_exceptions(true)
+end
+```
+
+## Run tests
+
+This gem is tested using RSpec, to run the tests, clone the repository, go in, then type :
+
+```
+% bundle install
+% bundle exec rspec --format documentation --color
+```
+
+## How to use the gem
+
+First, you need to include the gem to your application. Usually you can just do :
+
+```ruby
+require "kharon"
+```
+
+### The validator
+
+The Kharon::Validator class is the main class of this gem, it offers an interface to validate hashes and see if they fulfill requirements. first, you have to create an instance of the validator :
+
+```ruby
+validator = Kharon::Factory.validator(hash_to_validate)
+```
+
+Now your validator knows which hash it has to validate, now you can do :
+
+```ruby
+# Sees if the "required_integer_key" key is present, and an integer
+validator.integer("required_integer_key", required: true)
+```
+
+All the functions are listed in the full documentation below.
+
+### The helper
+
+This gem was firstly designed to be used as a helper for Sinatra applications, so it contains another useful module : Kharon::Helpers. To use it in your Sinatra application, just type this in the controllers where you want it included :
+
+```ruby
+helpers Kharon::Helpers
+```
+
+From there, you can type it in any of the routes of this controller :
+
+```ruby
+validate(hash_to_validate) do
+  integer "required_integer_key", required: true
+end
+```
+
+This code is strictly equivalent to the one presented above, it uses the block syntax of ruby to give you a nice and fancy way to validate your datas !
+
+## Full documentation
+
+### Methods
+
+Methods signification are pretty straight-forward as it validates type :
+- :integer
+- :numeric
+- :text
+- :any
+- :datetime
+- :date
+- :array
+- :hash
+- :boolean
+- :mongoid
+
+#### :any
+
+This method will validate any value associated to the given key, it's useful if you just want to pass options like :required or :dependency
+
+#### :mongoid
+
+This method is only useful if you use Mongoid or an ORM linking MongoDB to your application. It validates the data associated with the key only if it's a string formatted as a MongoDB unique identifier.
+
+### Options
+
+#### :required
+
+This option can be given to say that a key has to be in the hash for it to be validated. It can be used with all methods.
+
+#### :dependency
+
+This options say that this key needs another key to be present for the hash to be validated. It can be used with all methods.
+
+#### :dependencies
+
+This options is used to pass several dependecies at once, as an array of keys. See :dependency option for details. It can be used with all methods.
+Note: the :dependencies option *overrides* the :dependency option if both are given.
+
+#### :in
+
+This option is used to give an array of possible values for the given key. If the value of the key is not in thius array, the validator fails. It can be used with all methods.
+
+#### :equals
+
+For the value of a given key in the hash to be equal to the given value. It can be used with all methods.
+
+#### :min
+
+This option allows you to specify a non-strict minimum limit for the value associated with the given key. The value has to be passed as an integer. It can be used with :numeric or :integer methods.
+
+#### :max
+
+This option allows you to specify a non-strict maximum limit for the value associated with the given key. The value has to be passed as an integer. It can be used with :numeric or :integer methods.
+
+#### :between
+
+This option gives an interval in which the value of the given key must be to fulfill the requirement. The value has to be passed as an array of two integers, first the minimum, then the maximum. It can be used with :numeric or :integer methods.
+Note: the :between option *overrides* the :min *and* :max options if several are given.
+
+#### :contains
+
+This option is used to see if an array or a hash situated at the given key contains some values. The values must be passed as an array. This option can be used with the :hash and :array methods.
+
+#### :has_keys
+
+This option is used to see if a hash situated at the given key contains some keys. The values must be passed as an array. This option can be used with the :hash and :array methods.
+
+#### :cast
+
+This option, if not given, is set to TRUE. If given at false, doesn't type cast the result of the validation so you keep the original string and just check its type. It can be used with all methods.
+
+#### :extract
+
+This option, if not given, is set to TRUE. If given at false, doesn't extract the given key, just validate its type. It can be used with all methods.
+
+#### :floor
+
+The value of round must be a boolean to work properly. If given at TRUE, floor the decimal number identified by this key. This option can be used with the :numeric method.
+
+#### :ceil
+
+The value of round must be a boolean to work properly. If given at TRUE, ceil the decimal number identified by this key. This option can be used with the :numeric method.
+
+#### :round
+
+The value of round must be an integer to work properly. If given, round the decimal number keeping the given number of digits after the comma. This option can be used with the :numeric method.
+
+#### :regex
+
+The value of this option must be passed as a string. If given as a string, verity that the associated string matches the given regular expression. This option can be used with the :text method.
+
+### Example god damn it !
+
+Here is an example to demonstrate the power of Kharon (made with the helper) :
+
+```ruby
+@validated = validate(parameters) do
+  numeric  "price", required: true, min: 0
+  datetime "added"
+  text     "added_by", dependency: "added"
+end
+```
+
+This example could validate the datas coming in the application in a search engine route for products in a supermarket.

data/kharon.gemspec

@@ -0,0 +1,21 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kharon/version'
+
+Gem::Specification.new do |specification|
+  specification.name        = "kharon"
+  specification.version     = Kharon::VERSION
+  specification.date        = "2014-04-02"
+  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.files       = `git ls-files`.split($/)
+  specification.homepage    = "https://rubygems.org/gems/kharon"
+  specification.license     = "Apache License 2"
+  specification.test_files  = ["spec/spec_helper.rb", "spec/lib/kharon/validator_spec.rb"]
+
+  specification.required_ruby_version = ">= 1.9.3"
+  specification.add_runtime_dependency "bson", ">= 2.2.2"
+end

data/lib/kharon.rb

@@ -0,0 +1,7 @@
+require "kharon/version"
+require "kharon/validator"
+require "kharon/helpers/validate"
+
+module Kharon
+
+end

data/lib/{validator.rb → kharon/validator.rb}

@@ -1,4 +1,5 @@
 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>
   class Validator
@@ -120,6 +121,26 @@ module Kharon
       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
 
+    # Checks if the given key is a box (geofences) or not. A box is composed of four numbers (positive or negative, decimal or not) separed by commas.
+    # @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).
+    # @example Validates a key so it has to be a box.
+    #   @validator.box(:a_box)
+    def box(key, options = {})
+      before_all(key, options)
+      match?(key, /^(?:[+-]?\d{1,3}(?:\.\d{1,7})?,?){4}$/) ? store_box(key, options) : raise_type_error(key, "Box")
+    end
+
+    # Checks if the given key is an email 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).
+    # @example Validates a key so it has to be an email.
+    #   @validator.email(:email)
+    def email(key, options = {})
+      before_all(key, options)
+      match?(key, /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}$/) ? store(key, ->(item){item}, options) : raise_type_error(key, "Email")
+    end
+
     private
 
     # This method is executed before any call to a public method.
@@ -192,6 +213,16 @@ module Kharon
       store(key, process, options)
     end
 
+    def store_box(key, options)
+      if(options.has_key?(:at_least))
+        box_contains?(datas[key], options[:at_least])
+      end
+      if(options.has_key?(:at_most))
+        box_contains?(options[:at_most], datas[key])
+      end
+      store(key, ->(item){parse_box(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.
@@ -310,6 +341,32 @@ module Kharon
       end
     end
 
+    # 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)
+      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")
+        end
+      end
+      return box
+    end
+
+    # Verify if a box contains another box.
+    # @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)
+      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
+    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.
@@ -320,6 +377,9 @@ module Kharon
 
     protected
 
+    # Raises an error giving a message to display.
+    # @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)
     end

data/lib/kharon/version.rb

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

data/spec/lib/{validator_spec.rb → kharon/validator_spec.rb}

@@ -488,4 +488,99 @@ describe "Validator" do
     end
   end
 
+  context "box" do
+    let(:valid_datas)    { {is_a_box: "-2,-2.0,100,100.0"} }
+    let(:valid_filtered) { {is_a_box: [[-2, -2], [100, 100]]} }
+    let(:invalid_datas)  { {is_not_a_box: "anything else"} }
+
+    before do
+      @validator = Kharon::Validator.new(valid_datas)
+    end
+
+    it "succeeds when given a valid box" do
+      @validator.box(:is_a_box)
+      expect(@validator.filtered).to eq(valid_filtered)
+    end
+
+    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)
+    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)
+    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)
+    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)
+    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)
+    end
+
+    context "options" do
+      include_examples "options", :box
+
+      context ":at_least" do
+
+        it "succeeds if the box is bigger than the one given with the at_least option" do
+          expect(->{@validator.box(:is_a_box, at_least: [[10, 10], [20, 20]])}).to_not raise_error
+        end
+
+        it "succeeds if the box is equal than the one given with the at_least option" do
+          expect(->{@validator.box(:is_a_box, at_least: [[-2, -2], [100, 100]])}).to_not raise_error
+        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)
+        end
+      end
+
+      context "at_most" do
+
+        it "succeeds if the box is smaller than the one given with the at_most option" do
+          expect(->{@validator.box(:is_a_box, at_most: [[-20, -20], [1000, 1000]])}).to_not raise_error
+        end
+
+        it "succeeds if the box is equal than the one given with the at_most option" do
+          expect(->{@validator.box(:is_a_box, at_most: [[-2, -2], [100, 100]])}).to_not raise_error
+        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)
+        end
+      end
+    end
+  end
+
+  context "email" do
+    let(:valid_datas)    { {is_an_email: "vincent.courtois@mycar-innovations.com"} }
+    let(:valid_filtered) { valid_datas }
+    let(:invalid_datas)  { {is_not_an_email: "anything else"} }
+
+    it "succeeds when given a valid email" do
+      validator = Kharon::Validator.new(valid_datas)
+      validator.email(:is_an_email)
+      expect(validator.filtered).to eq(valid_filtered)
+    end
+
+    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)
+    end
+
+    context "options" do
+      include_examples "options", :email
+    end
+  end
+
 end

data/spec/spec_helper.rb

@@ -1,9 +1,7 @@
+require 'bundler/setup'
+Bundler.setup
+
 # Sets the environment variable to test before loading all the files.
 ENV['RACK_ENV'] = 'test'
 
-require 'rack/test'
-require 'bson'
-
-require './lib/cool_validator.rb'
-require './lib/validator_factory.rb'
-require './lib/validator.rb'
+require "kharon"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kharon
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -16,7 +16,7 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - '='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: 2.2.2
   type: :runtime
@@ -24,7 +24,7 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - '='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: 2.2.2
 description: Kharon is a ruby hash validator that helps you fix the structure of a
@@ -34,14 +34,25 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/validator.rb
-- lib/validate.rb
-- lib/validator_factory.rb
-- lib/cool_validator.rb
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- kharon-0.0.1.gem
+- kharon-0.0.2.gem
+- kharon-0.0.3.gem
+- kharon-0.1.0.gem
+- kharon-0.2.0.gem
+- kharon-0.3.0.gem
+- kharon-0.3.1.gem
+- kharon.gemspec
+- lib/kharon.rb
+- lib/kharon/helpers/validate.rb
+- lib/kharon/validator.rb
+- lib/kharon/version.rb
+- spec/lib/kharon/validator_spec.rb
 - spec/spec_helper.rb
-- spec/lib/validator_spec.rb
-- spec/lib/cool_validator_spec.rb
-- spec/lib/validator_factory_spec.rb
 homepage: https://rubygems.org/gems/kharon
 licenses:
 - Apache License 2
@@ -69,6 +80,5 @@ specification_version: 3
 summary: Ruby Hash validator
 test_files:
 - spec/spec_helper.rb
-- spec/lib/validator_spec.rb
-- spec/lib/cool_validator_spec.rb
-- spec/lib/validator_factory_spec.rb
+- spec/lib/kharon/validator_spec.rb
+has_rdoc: 

data/lib/cool_validator.rb

@@ -1,32 +0,0 @@
-require "./lib/validator.rb"
-
-module Kharon
-  # This validator is really cooler than the other one. It will help you validate datas without raising exception, if you don't want to.
-  # @author Vincent Courtois <vincent.courtois@mycar-innovations.com>
-  class CoolValidator < Kharon::Validator
-
-    # @!attribute [r] errors
-      # @return an array of strings, each string representing an error occured while validating the hash.
-    attr_reader :errors
-
-    # 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.
-    #   @validator = Kharon::CoolValidator.new({key: "value"})
-    def initialize(datas)
-      super(datas)
-      @errors = Array.new
-    end
-
-    # Fancy method to see if the validator have seen an error in the given hash.
-    def has_errors?
-      return (@errors.empty? ? false : true)
-    end
-
-    protected
-
-    def raise_error(message)
-      errors.push(message)
-    end
-  end
-end

data/lib/validator_factory.rb

@@ -1,34 +0,0 @@
-require "./lib/validator.rb"
-require "./lib/cool_validator.rb"
-
-module Kharon
-  module Factory
-
-    # @!attribute [r|w] use_exceptions
-      # @return TRUE if Kharon currently use exceptions, FALSE if not.
-    @@use_exceptions = true
-
-    # Acts as a creation method for validators, considering the options you transmitted.
-    # @param [Hash] datas the datas to validate in the validator.
-    def self.validator(datas)
-      @@use_exceptions ? Kharon::Validator.new(datas) : Kharon::CoolValidator.new(datas)
-    end
-
-    # Allows you to pass a whole block to configure the Kharon module.
-    # @param [Hash] block a block of configuration instructions to pass to the module. See documentation for further informations.
-    def self.configure(&block)
-      self.instance_eval(&block)
-    end
-
-    # Sets the use of exceptions in the whole process.
-    # @param [Boolean] status TRUE if you want to use the eceptions, FALSE if not.
-    def self.use_exceptions(status)
-      @@use_exceptions = status
-    end
-
-    # Fancy method to know if the module uses the exceptions or not.
-    def self.uses_exceptions?
-      return @@use_exceptions
-    end
-  end
-end

data/spec/lib/cool_validator_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe "CoolValidator" do
-  context "handling errors" do
-
-    before do
-      @validator = Kharon::CoolValidator.new({key: "value"})
-    end
-
-    it "doesn't raise an exception when an error occurs" do
-      expect(->{@validator.any(:another, required: true)}).to_not raise_error
-    end
-
-    it "has an error when an error has occured" do
-      @validator.any(:another, required: true)
-      expect(@validator.has_errors?).to be(true)
-    end
-
-    it "doesn't have an error when none has occured" do
-      @validator.any(:key, required: true)
-      expect(@validator.has_errors?).to be(false)
-    end
-  end
-end

data/spec/lib/validator_factory_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe "Kharon::Factory" do
-
-  context "validator" do
-    it "produces a Kharon::Validator when exceptions are wanted" do
-      Kharon::Factory.use_exceptions(true)
-      expect(Kharon::Factory.validator({key: "value"})).to be_a(Kharon::Validator)
-    end
-
-    it "produces a Kharon::CoolValidator when exceptions are not wanted" do
-      Kharon::Factory.use_exceptions(false)
-      expect(Kharon::Factory.validator({key: "value"})).to be_a(Kharon::CoolValidator)
-    end
-  end
-
-  context "configure" do
-    it "correctly configures the module to use exceptions" do
-      Kharon::Factory.configure do |configuration|
-        configuration.use_exceptions(true)
-      end
-      expect(Kharon::Factory.uses_exceptions?).to be(true)
-    end
-
-    it "correctly configures the module to not use exceptions" do
-      Kharon::Factory.configure do |configuration|
-        configuration.use_exceptions(false)
-      end
-      expect(Kharon::Factory.uses_exceptions?).to be(false)
-    end
-  end
-
-end