kharon 0.1.0 → 0.2.0

data/lib/validate.rb

@@ -1,4 +1,4 @@
-module Charon
+module Kharon
   module Helpers
 
     # Validates the datas passed as parameter with a Phenix::Validator and the given instructions.
@@ -6,7 +6,7 @@ module Charon
     # @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 = Kharon::Validator.new(datas)
       validator.instance_eval(&block)
       return validator.filtered
     end

data/lib/validator.rb

@@ -1,4 +1,4 @@
-module Charon
+module Kharon
   # 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
@@ -32,7 +32,7 @@ module Charon
     # @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")
+      match?(key, /\A([+-]?\d+)([,.](\d+))?\Z/) ? store(key, ->(item){item.to_s.sub(/,/, ".").to_f}, options) : raise_type_error(key, "Numeric")
     end
 
     # Checks if the given key is a not-empty string or not.
@@ -108,7 +108,7 @@ module Charon
     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|
+    before 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])
@@ -120,6 +120,18 @@ module Charon
       end
     end
 
+    after calls_to: [:numeric] do |joint_point, validator, *args|
+      unless !defined?(args[1]) or args[1].nil? or args[1].empty?
+        if(args[1].has_key?(:round) and args[1][:round].kind_of?(Integer))
+          validator.filtered[args[0]] = validator.filtered[args[0]].round(args[1][:round]) if validator.filtered.has_key?(args[0])
+        elsif(args[1].has_key?(:floor) and args[1][:floor] == true)
+          validator.filtered[args[0]] = validator.filtered[args[0]].floor if validator.filtered.has_key?(args[0])
+        elsif(args[1].has_key?(:ceil) and args[1][:ceil] == true)
+          validator.filtered[args[0]] = validator.filtered[args[0]].ceil if validator.filtered.has_key?(args[0])
+        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?
@@ -146,6 +158,12 @@ module Charon
       end
     end
 
+    after calls_to: [:text] do |joint_point, validator, *args|
+      unless !defined?(args[1]) or args[1].nil? or args[1].empty?
+        validator.match_regex?(args[0], validator.datas[args[0]], args[1][:regex]) if(args[1].has_key?(:regex))
+      end
+    end
+
     # @!endgroup Advices
 
     # Checks if a required key is present in provided datas.
@@ -220,6 +238,11 @@ module Charon
       raise ArgumentError.new("The key #{key} was supposed to contains values [#{required_values.join(", ")}]") if (values & required_values) != required_values
     end
 
+    def match_regex?(key, value, regex)
+      regex = Regexp.new(regex) if regex.kind_of?(String)
+      raise ArgumentError.new("The key #{key} was supposed to match the regex #{regex} but its value was #{value}") unless regex.match(value)
+    end
+
     private
 
     # Check if the value associated with the given key matches the given regular expression.

data/spec/lib/validator_spec.rb

@@ -4,103 +4,103 @@ 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 = Kharon::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)
+      validator = Kharon::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 = Kharon::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)
+      validator = Kharon::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 = Kharon::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"}))
+      validator = Kharon::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 = Kharon::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 = Kharon::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)
+      validator = Kharon::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 = Kharon::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 = Kharon::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)
+      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)
     end
   end
 
   context ":equals" do
     it "succeeds when the value is equal to the given value" do
-      validator = Charon::Validator.new(valid_datas)
+      validator = Kharon::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)
+      validator = Kharon::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 = Kharon::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 = Kharon::Validator.new(valid_datas)
       validator.send(process, valid_datas.keys.first, :extract => true)
       expect(validator.filtered).to eq(valid_filtered)
     end
@@ -108,13 +108,13 @@ shared_examples "options" do |process|
 
   context ":cast" do
     it "casts the data when given at true" do
-      validator = Charon::Validator.new(valid_datas)
+      validator = Kharon::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 = Kharon::Validator.new(valid_datas)
       validator.send(process, valid_datas.keys.first, :cast => false)
       expect(validator.filtered).to eq(valid_datas)
     end
@@ -123,20 +123,20 @@ end
 
 shared_examples "type checker" do |type, process|
   it "succeeds when given an instance of #{type}" do
-    validator = Charon::Validator.new(valid_datas)
+    validator = Kharon::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)
+    validator = Kharon::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) }
+  let(:validator) { Kharon::Validator.new(valid_datas) }
 
   context ":min" do
     it "succeeds when a min option is given, and the value is strictly greater than it" do
@@ -200,18 +200,18 @@ 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 = Kharon::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)
+      validator = Kharon::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)
+      validator = Kharon::Validator.new(valid_datas)
       expect(->{validator.send(process, key, contains: ["val3", "val4"])}).to raise_error(ArgumentError)
     end
   end
@@ -224,18 +224,18 @@ describe "Validator" do
     let(:invalid_datas)  { {is_not_an_integer: "something else"} }
 
     it "succeeds when given an integer" do
-      validator = Charon::Validator.new(valid_datas)
+      validator = Kharon::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})
+      validator = Kharon::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)
+      validator = Kharon::Validator.new(invalid_datas)
       expect(->{validator.integer(:is_not_an_integer)}).to raise_error(ArgumentError)
     end
 
@@ -251,31 +251,73 @@ describe "Validator" do
     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 = Kharon::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 = Kharon::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 = Kharon::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)
+      validator = Kharon::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
+
+      context ":round" do
+        it "rounds the number when the option is passed as an integer" do
+          validator = Kharon::Validator.new({is_a_double: 1.02363265})
+          validator.numeric(:is_a_double, round: 4)
+          expect(validator.filtered).to eq({is_a_double: 1.0236})
+        end
+
+        it "doesn't round the number if passed with another type" do
+          validator = Kharon::Validator.new({is_a_double: "1.02363265"})
+          validator.numeric(:is_a_double, round: "anything here")
+          expect(validator.filtered).to eq({is_a_double: 1.02363265})
+        end
+      end
+
+      context ":floor" do
+        it "floors the number if passed to true" do
+          validator = Kharon::Validator.new(valid_datas)
+          validator.numeric(:is_a_double, floor: true)
+          expect(validator.filtered).to eq({is_a_double: 1000})
+        end
+
+        it "doesn't floor the number if passed to false" do
+          validator = Kharon::Validator.new(valid_datas)
+          validator.numeric(:is_a_double, floor: false)
+          expect(validator.filtered).to eq({is_a_double: 1000.5})
+        end
+      end
+
+      context ":ceil" do
+        it "ceils the number if passed to true" do
+          validator = Kharon::Validator.new(valid_datas)
+          validator.numeric(:is_a_double, ceil: true)
+          expect(validator.filtered).to eq({is_a_double: 1001})
+        end
+
+        it "doesn't ceil the number if passed to false" do
+          validator = Kharon::Validator.new(valid_datas)
+          validator.numeric(:is_a_double, ceil: false)
+          expect(validator.filtered).to eq({is_a_double: 1000.5})
+        end
+      end
     end
   end
 
@@ -288,6 +330,19 @@ describe "Validator" do
 
     context "options" do
       include_examples "options", :text
+
+      context ":regex" do
+        it "succeeds when the regular expression is respected" do
+          validator = Kharon::Validator.new(valid_datas)
+          validator.text(:is_a_string, regex: "some")
+          expect(validator.filtered).to eq(valid_filtered)
+        end
+
+        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)
+        end
+      end
     end
   end
 
@@ -298,19 +353,19 @@ describe "Validator" do
     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 = Kharon::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 = Kharon::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)
+      validator = Kharon::Validator.new(invalid_datas)
       expect(->{validator.datetime(:is_not_a_datetime)}).to raise_error(ArgumentError)
     end
 
@@ -326,19 +381,19 @@ describe "Validator" do
     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 = Kharon::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 = Kharon::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)
+      validator = Kharon::Validator.new(invalid_datas)
       expect(->{validator.date(:is_not_a_date)}).to raise_error(ArgumentError)
     end
 
@@ -373,18 +428,18 @@ describe "Validator" do
 
       context ":has_keys" do
         it "succeeds if all keys are contained in the hash" do
-          validator = Charon::Validator.new(valid_datas)
+          validator = Kharon::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)
+          validator = Kharon::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)
+          validator = Kharon::Validator.new(valid_datas)
           expect(->{validator.hash(:is_a_hash, has_keys: [:key3, :key4])}).to raise_error(ArgumentError)
         end
       end
@@ -397,13 +452,13 @@ describe "Validator" do
     let(:invalid_datas)  { {is_not_a_boolean: "anything else"} }
 
     it "succeeds when given a boolean" do
-      validator = Charon::Validator.new(valid_datas)
+      validator = Kharon::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)
+      validator = Kharon::Validator.new(invalid_datas)
       expect(->{validator.boolean(:is_not_a_boolean)}).to raise_error(ArgumentError)
     end
 
@@ -419,13 +474,13 @@ describe "Validator" do
     let(:invalid_datas)  { {is_not_a_ssid: "anything else"} }
 
     it "succeeds when given a valid SSID" do
-      validator = Charon::Validator.new(valid_datas)
+      validator = Kharon::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)
+      validator = Kharon::Validator.new(invalid_datas)
       expect(->{validator.ssid(:is_not_a_ssid)}).to raise_error(ArgumentError)
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kharon
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors: