valideizer 1.1.5 → 1.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0bd366477b47fe01040eeda2773d34cfe36b36e9eebb56582993583c261025b
-  data.tar.gz: 2384ce4ca9f2747158d57efae38648c1ae2d6852368f836b698734c89bcddfea
+  metadata.gz: 7ef60decc451d279d677b03f23f19c08949373e402172b287233ce4a465dcb3a
+  data.tar.gz: cf07107455d7494378b5a6fbf10f7ad34a6a8b6e10e7d7411ab39fe164e0e740
 SHA512:
-  metadata.gz: aa229fac2d83b9932a0215ef162bb40ae122e654dd13fb926ea8a9a147f59715de933347739d30fc329ab4dc62682573f86aad18f542ac7c17963598bc2cb0d9
-  data.tar.gz: 55cad297da865296d710fdec62d74137770151d1e3d0058c4bae52df9a197eab14a478ed03651b2acdc9d51e93b9834d4f6c7febeee81c3d842c872e9e255be9
+  metadata.gz: 0c0747d2d6c23106d0de6eb6170ac79b2b0af1ba17a5219595cb8511406654496774fd8fb4b454342176c13662b3d71801c3b3439897cebce11c38630a55a90a
+  data.tar.gz: 56158376a80e583dfb06a47e938ebc829862bb9cbf3afef85f134387260c9f0421013967c4968fd4fade78bd84da68a87e215eeb32a66e331715aed36300ad79

data/lib/valideizer/caster.rb

@@ -0,0 +1,20 @@
+module Valideizer
+  module Caster
+    def cast_from_json(value)
+      JSON.parse(value) rescue nil
+    end
+
+    def cast_to_integer(value)
+      value.to_i rescue nil
+    end
+
+    def cast_to_float(value)
+      value.to_f rescue nil
+    end
+
+    def cast_to_bool(value)
+      return false if ['0', 'false'].include? value.to_s.downcase
+      return true  if ['1', 'true'].include? value.to_s.downcase
+    end
+  end
+end

data/lib/valideizer/core.rb

@@ -1,9 +1,11 @@
 require 'valideizer/rules'
 require 'valideizer/error_printer'
+require 'valideizer/caster'
 
 module Valideizer
   class Core
     include Valideizer::Rules
+    include Valideizer::Caster
     include Valideizer::ErrorPrinter
 
     def initialize
@@ -20,6 +22,7 @@ module Valideizer
     def valideized?(params)
       reinit_errrors
       setup_defaults(params)
+
       params.each do |param, value|
         next unless nil_check(param, value)
         @rules[param.to_s].each do |type, constraint|
@@ -32,7 +35,7 @@ module Valideizer
       end
 
       if @errors.empty?
-        type_cast params if @type_cast
+        recast(params)
         true
       else
         false
@@ -87,6 +90,30 @@ module Valideizer
       nil_rule.nil? ? false : nil_rule.last
     end
 
+    def recast(params)
+      @rules.each do |param, rules|
+        next if params[param.to_s].nil? && params[param.to_sym].nil?
+
+        type_rule = rules.find { |r, _c| r == :type }
+
+        if type_rule
+          constraint = type_rule.last
+          param = param.to_sym if params.include? param.to_sym
+          value = params[param]
+
+          if validate(value, :type, constraint)
+            params[param] = case constraint
+                            when :json    then cast_from_json  value
+                            when :bool    then cast_to_bool    value
+                            when :float   then cast_to_float   value
+                            when :integer then cast_to_integer value
+                            else value
+                            end
+          end
+        end
+      end
+    end
+
     def build_error_messages
       @error_messages = print_errors
     end

data/lib/valideizer/error_printer.rb

@@ -20,7 +20,7 @@ module Valideizer
       when :ot            then "Should be other than #{constraint}."
       when :range         then "Out of range. Should be in #{constraint.to_s} range."
       when :enum          then "Out of enum. Possible values #{constraint.to_s}."
-      when :type          then "Should be #{constraint} type. Current type: `#{value}`."
+      when :type          then "Should be #{constraint} type. Current type: `#{value.class}`."
       when :array_type    then "Should be array of #{constraint} type."
       when :custom_type   then "Should be #{constraint} type."
       when :regexp        then "Couldn't be matched by #{constraint}."

data/lib/valideizer/rules.rb

@@ -21,23 +21,23 @@ module Valideizer
       default
     ]
 
-    def validate(param, rule, constraint)
+    def validate(value, rule, constraint)
       begin
       case rule
-      when :eql           then validate_eql           param, constraint
-      when :gt            then validate_gt            param, constraint
-      when :gte           then validate_gte           param, constraint
-      when :lt            then validate_lt            param, constraint
-      when :lte           then validate_lte           param, constraint
-      when :ot            then validate_ot            param, constraint
-      when :range         then validate_range         param, constraint
-      when :enum          then validate_enum          param, constraint
-      when :type          then validate_type          param, constraint
-      when :array_type    then validate_array_type    param, constraint
-      when :custom_type   then validate_custom_type   param, constraint
-      when :regexp        then validate_regexp        param, constraint
-      when :length        then validate_length        param, constraint
-      when :active_record then validate_active_record param, constraint
+      when :eql           then validate_eql           value, constraint
+      when :gt            then validate_gt            value, constraint
+      when :gte           then validate_gte           value, constraint
+      when :lt            then validate_lt            value, constraint
+      when :lte           then validate_lte           value, constraint
+      when :ot            then validate_ot            value, constraint
+      when :range         then validate_range         value, constraint
+      when :enum          then validate_enum          value, constraint
+      when :type          then validate_type          value, constraint
+      when :array_type    then validate_array_type    value, constraint
+      when :custom_type   then validate_custom_type   value, constraint
+      when :regexp        then validate_regexp        value, constraint
+      when :length        then validate_length        value, constraint
+      when :active_record then validate_active_record value, constraint
       else true
       end
       rescue
@@ -47,72 +47,90 @@ module Valideizer
 
     private
 
-    def validate_eql(param, constraint)
-      param == constraint
+    def validate_eql(value, constraint)
+      value == constraint
     end
 
-    def validate_gt(param, constraint)
-      param > constraint
+    def validate_gt(value, constraint)
+      value > constraint
     end
 
-    def validate_gte(param, constraint)
-      param >= constraint
+    def validate_gte(value, constraint)
+      value >= constraint
     end
 
-    def validate_lt(param, constraint)
-      param < constraint
+    def validate_lt(value, constraint)
+      value < constraint
     end
 
-    def validate_lte(param, constraint)
-      param <= constraint
+    def validate_lte(value, constraint)
+      value <= constraint
     end
 
-    def validate_ot(param, constraint)
-      param != constraint
+    def validate_ot(value, constraint)
+      value != constraint
     end
 
-    def validate_range(param, constraint)
+    def validate_range(value, constraint)
       raise 'Must be a range' unless constraint.is_a? Range
-      constraint.include? param
+      constraint.include? value
     end
 
-    def validate_enum(param, constraint)
+    def validate_enum(value, constraint)
       raise 'Must be an array' unless constraint.is_a? Array
-      constraint.include? param
+      constraint.include? value
     end
 
-    def validate_type(param, constraint)
+    def validate_type(value, constraint)
       if constraint.is_a? Array
-        constraint.each { |type| return true if type_check(param, type)}
+        constraint.each { |type| return true if type_check(value, type)}
       else
-        type_check(param, constraint)
+        type_check(value, constraint)
       end
     end
 
-    def type_check(param, type)
+    def type_check(value, type)
       case type
-      when :integer then param.is_a? Integer
-      when :float   then param.is_a? Float
-      when :string  then param.is_a? String
-      when :array   then param.is_a? Array
-      when :hash    then param.is_a? Hash
-      when :bool    then bool_check(param)
-      when :json    then json_check(param)
-      else raise "Wrong check type #{param}"
+      when :string  then value.is_a? String
+      when :array   then value.is_a? Array
+      when :hash    then value.is_a? Hash
+      when :integer then integer_check(value)
+      when :float   then float_check(value)
+      when :bool    then bool_check(value)
+      when :json    then json_check(value)
+      else raise "Wrong check type #{value}"
       end
     end
 
-    def bool_check(param)
-      [0, 1].include?(param) || ['true', 'false'].include?(param.to_s.downcase)
+    def integer_check(value)
+      casted_value = value.to_i rescue nil
+      if casted_value && (casted_value == 0 && value.to_s.strip == '0' || casted_value != 0)
+        true
+      else
+        false
+      end
+    end
+
+    def float_check(value)
+      casted_value = value.to_f rescue nil
+      if casted_value && (casted_value == 0 && value.to_s.strip == '0' || casted_value != 0)
+        true
+      else
+        false
+      end
+    end
+
+    def bool_check(value)
+      ['0', '1'].include?(value.to_s.strip) || ['true', 'false'].include?(value.to_s.downcase.strip)
     end
 
-    def json_check(param)
-      [Hash, Array].include?((JSON.parse param rescue nil).class)
+    def json_check(value)
+      [Hash, Array].include?((JSON.parse value rescue nil).class)
     end
 
-    def validate_array_type(param, constraint)
-      if param.is_a? Array
-        param.each do  |v|
+    def validate_array_type(value, constraint)
+      if value.is_a? Array
+        value.each do  |v|
           if v.is_a?(Array)
             validate_array_type(v, constraint)
           else
@@ -126,25 +144,25 @@ module Valideizer
       end
     end
 
-    def validate_regexp(param, regexp)
-      raise 'Must be a string' unless param.is_a? String
-      param.match? regexp
+    def validate_regexp(value, regexp)
+      raise 'Must be a string' unless value.is_a? String
+      value.match? regexp
     end
 
-    def validate_custom_type(param, constraint)
-      param.is_a? constraint
+    def validate_custom_type(value, constraint)
+      value.is_a? constraint
     end
 
-    def validate_length(param, constraint)
-      if [Array, Hash, String].include? param.class
+    def validate_length(value, constraint)
+      if [Array, Hash, String].include? value.class
         if constraint.is_a? Hash
           raise 'Hash params can not be empty.' if constraint.empty?
           res = true
-          res &= param.length >= constraint[:min] unless constraint[:min].nil?
-          res &= param.length <= constraint[:max] unless constraint[:max].nil?
+          res &= value.length >= constraint[:min] unless constraint[:min].nil?
+          res &= value.length <= constraint[:max] unless constraint[:max].nil?
           res
         elsif constraint.is_a? Range
-          constraint.include? param.length
+          constraint.include? value.length
         else
           raise 'Wrong constraint for :length option. Must be range or hash {min: 0, max: 10}'
         end
@@ -153,10 +171,10 @@ module Valideizer
       end
     end
 
-    def validate_active_record(param, constraint)
+    def validate_active_record(value, constraint)
         klass = constraint
         if klass.is_a? ActiveModel || (klass = constraint.to_s.constantize).is_a?(ActiveModel)
-          klass.find_by_id(param).present?
+          klass.find_by_id(value).present?
         else
           raise "#{constraint} is not a valid ActiveRecord model"
        end

data/lib/valideizer/version.rb

@@ -1,3 +1,3 @@
 module Valideizer
-  VERSION = "1.1.5"
+  VERSION = "1.1.6"
 end

data/lib/valideizer.rb

@@ -4,6 +4,7 @@ require_relative 'valideizer/rails.rb'
 require_relative 'valideizer/version.rb'
 require_relative 'valideizer/error_printer.rb'
 require_relative 'valideizer/holder.rb'
+require_relative 'valideizer/caster.rb'
 
 module Valideizer; end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: valideizer
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 1.1.6
 platform: ruby
 authors:
 - Arthur 'ArtK0DE' Korochansky
@@ -32,6 +32,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/valideizer.rb
+- lib/valideizer/caster.rb
 - lib/valideizer/core.rb
 - lib/valideizer/error_printer.rb
 - lib/valideizer/holder.rb