valideizer 1.1.9 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14545dce6ae6d5c5fc1df9deee0a1663b5e1d2eb86b52abf4804045538b453b7
-  data.tar.gz: 0b99531d4a7897ac09f3c572c2266897b9bef945c91f5d6030ce85633063ac89
+  metadata.gz: af9eb189f03b2ee23f2f688fc05ba140828d27c994b8e09c9ab3c148a2510cce
+  data.tar.gz: 27197cedb634dcf3a3dcb95599270c7ce7764507f55f147c8ee9921b9fb9d063
 SHA512:
-  metadata.gz: 2d763dcae2a1b36faffab0024404b28d8064e3852d8ff8cd4212d388d42540442b0a4a7b814d76badfa4bd6656e8970bee1477ad94ab073f91e034d8ac2051ab
-  data.tar.gz: 53580c7f4e8e343eda72be22fd2b69093d44e13fc26a12c4a67180bbf34a89acc5e537b7f1f920c1668e8789dc246a120e9923df7ff840f141d6cf32085c9f8a
+  metadata.gz: 49debeda89e3f5f1a538b0ea67d2b9dfb27a725c67069a012e8e2d1a52d8119cbae42b6bffb776665d029c03c6ca4a5cd58f678175213d767febedf987da0ff9
+  data.tar.gz: 19b27f84237bf5baae8319d427b686504b7933aa6d76f40f2696f828bc6f6693bb2e1c105916506e0e47a5dd8ba2d4283a1099daed972e1e594cb8f361bc73a0

data/lib/valideizer/caster.rb

@@ -0,0 +1,33 @@
+require 'time'
+
+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_time(value)
+      Time.parse(value) rescue nil
+    end
+
+    def cast_to_time_with_format(value, format)
+      Time.strptime(value, format) rescue nil
+    end
+
+    def cast_to_boolean(value)
+      if %w(1 true).include?(value.to_s.downcase)
+        true
+      elsif %w(0 false).include?(value.to_s.downcase)
+        false
+      end
+    end
+  end
+end

data/lib/valideizer/core.rb

@@ -1,29 +1,43 @@
 require 'valideizer/rules'
 require 'valideizer/error_printer'
 require 'valideizer/caster'
+require 'valideizer/rules_checker'
 
 module Valideizer
   class Core
     include Valideizer::Rules
+    include Valideizer::RulesChecker
     include Valideizer::Caster
     include Valideizer::ErrorPrinter
 
-    def initialize
+    attr_accessor :rules
+
+    def initialize(autocast: true)
+      @autocast = autocast
+      @rules = {}
+      reinit_errrors
+    end
+
+    # Cleanes rules and errors
+    def clean!
       @rules = {}
       reinit_errrors
     end
 
+    # Adds new rule for validation
     def add_rule(param, *rules)
+      check_rule_set(rules[0])
       @rules[param.to_s] = rules[0]
     end
 
     alias valideize add_rule
 
+    # Validates and recasts params
     def valideized?(params)
       pre_process params
 
       params.each do |param, value|
-        next unless nil_check(param, value)
+        next unless null_check(param, value)
         @rules[param.to_s].each do |type, constraint|
           begin
             push_error(param, value, type, constraint) unless validate(value, type, constraint)
@@ -41,6 +55,7 @@ module Valideizer
       end
     end
 
+    # Prints error messages
     def errors
       build_error_messages
       @error_messages
@@ -80,17 +95,17 @@ module Valideizer
       end
     end
 
-    def nil_check(param, value)
-      if !value.nil? || value.nil? && has_allow_nil_rule(param)
+    def null_check(param, value)
+      if !value.nil? || value.nil? && has_allow_null_rule(param)
         true
       else
-        push_error(param, :nil, nil, nil)
+        push_error(param, :null, nil, nil)
         false
       end
     end
 
-    def has_allow_nil_rule(param)
-      nil_rule = @rules[param.to_s]&.find { |r, _c| r == :nil }
+    def has_allow_null_rule(param)
+      nil_rule = @rules[param.to_s]&.find { |r, _c| r == :null }
       nil_rule.nil? ? false : nil_rule.last
     end
 
@@ -102,36 +117,41 @@ module Valideizer
         type_rule = rules.find { |r, _c| r == :type }
         recast(params, key, type_rule.last) if type_rule
 
+        datetime_rule = rules.find { |r, _c| r == :format }
+        params[key] = cast_to_time_with_format(params[key],
+          datetime_rule.last) if datetime_rule
+
         regexp_rule = rules.find { |r, _c| r == :regexp }
         regexp_groups_substitution(params, key, regexp_rule.last) if regexp_rule
       end
     end
 
-
     def recast(params, key, type)
       value = params[key]
       params[key] = case type
-                    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
+        when :json     then cast_from_json  value
+        when :boolean  then cast_to_boolean value
+        when :float    then cast_to_float   value
+        when :integer  then cast_to_integer value
+        when :datetime then cast_to_time    value
+        else value
+      end
     end
 
     def regexp_groups_substitution(params, key, regexp)
       value = params[key]
-
       matched = value.match regexp
       return if matched.nil?
 
       params[key] = if matched.named_captures.any?
-                      matched.named_captures
-                    elsif matched.captures.count > 1
-                      matched.captures
-                    elsif matched.captures.count == 1
-                      matched.captures[0]
-                    end
+        matched.named_captures
+      elsif matched.captures.count > 1
+        matched.captures
+      elsif matched.captures.count == 1
+        matched.captures[0]
+      else
+        value
+      end
     end
 
     def build_error_messages

data/lib/valideizer/error_printer.rb

@@ -26,7 +26,8 @@ module Valideizer
       when :regexp        then "Couldn't be matched by #{constraint}."
       when :length        then "Length must be #{constraint}. Current value: `#{value}`, length: #{value.length}."
       when :active_record then "Couldn't find #{constraint} with ID=#{value}."
-      when :nil           then "Can not be nil or empty."
+      when :null          then "Can not be nil or empty."
+      when :format        then "Don't match current time pattern #{constraint}"
       else ''
       end
     end

data/lib/valideizer/holder.rb

@@ -4,12 +4,25 @@ module Valideizer
   class Holder
     include Singleton
 
+    CALLBACK_TYPE = 'callback'.freeze
+    METHOD_TYPE   = 'render_method'.freeze
+    RENDER_TYPE   = 'render_block'.freeze
+
     attr_accessor :valideizers
     attr_accessor :callback_method
     attr_accessor :callback_controller
+    attr_accessor :render_method
+    attr_accessor :render_controller
+    attr_accessor :render_block
+    attr_accessor :output_type
+    attr_accessor :status
 
     def initialize
       @valideizers = {}
     end
+
+    def raise_exception
+      raise "You've already defined #{@output_type}"
+    end
   end
 end

data/lib/valideizer/rails.rb

@@ -10,26 +10,50 @@ module Valideizer
       base.before_action :valideize!
 
       base.class_eval do
-        def self.valideize(method, &options_block)
-          method = method.to_s
-          holder = Valideizer::Holder.instance
-          holder.valideizers[controller_path] = {} if holder.valideizers[controller_path].nil?
+        class << self
+          def valideize(*methods, &options_block)
+            methods.each do |method|
+              method = method.to_s
+              holder = Valideizer::Holder.instance
+              holder.valideizers[controller_path] = {} if holder.valideizers[controller_path].nil?
 
-          # raise "Action #{method} is not defined in #{controller_name}" unless action_methods.include? method.to_s
+              # raise "Action #{method} is not defined in #{controller_name}" unless action_methods.include? method.to_s
 
-          if holder.valideizers[controller_path][method].nil?
-            holder.valideizers[controller_path][method] = Valideizer::Core.new
+              if holder.valideizers[controller_path][method].nil?
+                holder.valideizers[controller_path][method] = Valideizer::Core.new
+              end
+
+              valideizer = holder.valideizers[controller_path][method]
+              valideizer.instance_eval(&options_block)
+            end
           end
 
-          valideizer = holder.valideizers[controller_path][method]
-          valideizer.instance_eval(&options_block)
-        end
+          def valideizer_callback(method_name)
+            holder = Valideizer::Holder.instance
+            unless holder.output_type.present?
+              # holder.raise_exception
+              holder.callback_controller = controller_path
+              holder.callback_method = method_name.to_s
+              holder.output_type = Valideizer::Holder::CALLBACK_TYPE
+            end
+          end
 
-        def self.valideizer_callback(method_name)
-          holder = Valideizer::Holder.instance
-          unless holder.callback_controller.present?
-            holder.callback_controller = controller_path
-            holder.callback_method = method_name.to_s
+          def valideizer_method(method_name)
+            holder = Valideizer::Holder.instance
+            unless holder.output_type.present?
+              holder.render_controller = controller_path
+              holder.render_method = method_name.to_s
+              holder.output_type = Valideizer::Holder::METHOD_TYPE
+            end
+          end
+
+          def valideizer_render(status = 400, &block)
+            holder = Valideizer::Holder.instance
+            unless holder.output_type.present?
+              holder.status = status
+              holder.render_block = block
+              holder.output_type = Valideizer::Holder::RENDER_TYPE
+            end
           end
         end
       end
@@ -37,11 +61,17 @@ module Valideizer
 
     def valideize!
       valideizer = holder.valideizers[controller_path][action_name] rescue nil
-      return unless valideizer
+      return if valideizer.nil?
 
-      unless valideizer.nil? || holder.callback_method.nil?
-        redirect_to(controller: holder.callback_controller,
-          action: holder.callback_method, errors: valideizer.errors) unless valideizer.valideized?(params)
+      unless valideizer.valideized?(params)
+        case holder.output_type
+        when Valideizer::Holder::CALLBACK_TYPE
+          redirect_to controller: holder.callback_controller, action: holder.callback_method, errors: valideizer.errors
+        when Valideizer::Holder::RENDER_TYPE
+          render json: instance_exec(valideizer.errors, &holder.render_block), status: holder.status
+        else
+          render json: valideizer.errors, status: 400
+        end
       end
     end
 

data/lib/valideizer/rules.rb

@@ -1,26 +1,8 @@
 require 'json'
+require 'time'
 
 module Valideizer
   module Rules
-    RULES = %i[
-      eql
-      gt
-      gte
-      lt
-      lte
-      ot
-      range
-      enum
-      type
-      array_type
-      custom_type
-      active_record
-      length
-      regexp
-      nil
-      default
-    ]
-
     def validate(value, rule, constraint)
       begin
       case rule
@@ -38,6 +20,7 @@ module Valideizer
       when :regexp        then validate_regexp        value, constraint
       when :length        then validate_length        value, constraint
       when :active_record then validate_active_record value, constraint
+      when :format        then validate_time_format   value, constraint
       else true
       end
       rescue
@@ -99,17 +82,23 @@ module Valideizer
 
     def type_check(value, type)
       case type
-      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)
+      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 :boolean  then boolean_check(value)
+      when :json     then json_check(value)
+      when :datetime then date_time_check(value)
       else raise "Wrong check type #{value}"
       end
     end
 
+    def date_time_check(value)
+      Time.parse(value) rescue return(false)
+      true
+    end
+
     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)
@@ -128,7 +117,7 @@ module Valideizer
       end
     end
 
-    def bool_check(value)
+    def boolean_check(value)
       ['0', '1'].include?(value.to_s.strip) || ['true', 'false'].include?(value.to_s.downcase.strip)
     end
 
@@ -187,5 +176,10 @@ module Valideizer
           raise "#{constraint} is not a valid ActiveRecord model"
        end
     end
+
+    def validate_time_format(value, constraint)
+      Time.strptime(value, constraint) rescue return(false)
+      true
+    end
   end
 end

data/lib/valideizer/rules_checker.rb

@@ -0,0 +1,90 @@
+module Valideizer
+  module RulesChecker
+    RULES_EXCEPTIONS = %i[null default]
+
+    RULES_W_FRIENDLY = {
+      eql:           %i[type default null],
+      ot:            %i[type default null],
+      gt:            %i[type default null lt lte],
+      gte:           %i[type default null lt lte],
+      lt:            %i[type default null gt gte],
+      lte:           %i[type default null gt gte],
+      range:         %i[type default null],
+      enum:          %i[type default null],
+      type:          %i[default null eql ot gt gte lt lte range enum regexp length format],
+      array_type:    %i[default null length],
+      custom_type:   %i[default null],
+      active_record: %i[default null],
+      length:        %i[type array],
+      regexp:        %i[type default null],
+      null:          %i[all],
+      default:       %i[all],
+      format:        %i[type default null],
+    }.freeze
+
+    VALID_TYPE_RULES = {
+      integer:  %i[eql gt gte lt lte ot range enum null default],
+      float:    %i[eql gt gte lt lte ot range enum null default],
+      string:   %i[enum length eql ot regexp null default],
+      datetime: %i[null default format],
+      json:     %i[null default],
+      boolean:  %i[null default],
+      hash:     %i[null default length],
+      array:    %i[null default length],
+    }.freeze
+
+    def check_rule_set(rules)
+      errors = []
+      check_wrong_rules(rules, errors)
+      check_conflicting_rules(rules, errors)
+      check_type_rules(rules, errors)
+
+      raise errors.join('. ') if errors.any?
+    end
+
+    private
+
+    def check_wrong_rules(rules, errors)
+      rules.each_key do |rule_name|
+        unless RULES_W_FRIENDLY.include? rule_name
+          errors << "Wrong rule: :#{rule_name}"
+          rules.delete rule_name
+        end
+      end
+
+    end
+
+    def check_conflicting_rules(rules, errors)
+      rules.each_key do |rule_name|
+        incompatibles = []
+        next if RULES_EXCEPTIONS.include?(rule_name)
+        rules.each_key do |check_rule|
+          next if rule_name == check_rule || RULES_EXCEPTIONS.include?(check_rule)
+          incompatibles << check_rule unless RULES_W_FRIENDLY[rule_name].include?(check_rule)
+        end
+        if incompatibles.any?
+          errors << ":#{rule_name} incompatible with #{incompatibles.join(', ')} rules"
+        end
+      end
+    end
+
+    def check_type_rules(rules, errors)
+      return unless rules.include?(:type)
+
+      unless VALID_TYPE_RULES.include? rules[:type]
+        errors << ":#{rules[:type]} isn't avalaible type"
+        return
+      end
+
+      incompatibles = []
+      rules.each_key do |rule_name|
+        next if rule_name == :type || RULES_EXCEPTIONS.include?(rule_name)
+        incompatibles << rule_name unless VALID_TYPE_RULES[rules[:type]].include? rule_name
+      end
+
+      if incompatibles.any?
+        errors << "Type :#{rules[:type]} is incompatible with #{incompatibles.join(", ")} parameters"
+      end
+    end
+  end
+end

data/lib/valideizer/version.rb

@@ -1,3 +1,3 @@
 module Valideizer
-  VERSION = "1.1.9"
+  VERSION = "1.2.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: valideizer
 version: !ruby/object:Gem::Version
-  version: 1.1.9
+  version: 1.2.1
 platform: ruby
 authors:
 - Arthur 'ArtK0DE' Korochansky
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-15 00:00:00.000000000 Z
+date: 2019-11-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -32,11 +32,13 @@ 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
 - lib/valideizer/rails.rb
 - lib/valideizer/rules.rb
+- lib/valideizer/rules_checker.rb
 - lib/valideizer/version.rb
 homepage: https://github.com/artk0de/valideizer
 licenses:
@@ -57,8 +59,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.9
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Small Gem to validate parameters