valideizer 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f3229a51579000464c6d27a4a08ad6d7a76e8634efae33b5e6beff9cbc239ed1
+  data.tar.gz: f252e175f557360fc875538340b1bf381d7169a724c4f5117c6af89bfd405928
+SHA512:
+  metadata.gz: a6682014a99bb3cdc5b5a72764e132498fb3eb8347e9bd50468bac55d320b03c312d8dd3eb454872a31abdc2dc51638eb46f01bb07767629b198b6034ad022c7
+  data.tar.gz: 167c1b26d637267bc9ba90f999d9b56b3d9f60b74be60f20d5878c8fbe972fc8efd8c1e301a38bbbc95a2457ccb53e93a520fa7a1e81532eb1334984d40dd4fe

data/lib/valideizer/core.rb

@@ -0,0 +1,80 @@
+require 'valideizer/rules'
+require 'valideizer/error_printer'
+
+module Valideizer
+  class Core
+    include Valideizer::Rules
+    include Valideizer::ErrorPrinter
+
+    def initialize
+      @rules = {}
+      reinit_errrors
+    end
+
+    def add_rule(param, *rules)
+      @rules[param] = rules[0]
+    end
+
+    alias valideize add_rule
+
+    def valideized?(params)
+      reinit_errrors
+      setup_defaults(params)
+      params.each do |param, value|
+        next unless nil_check(param, value)
+
+        @rules[param].each do |type, constraint|
+          begin
+          push_error(param, value, type, constraint) unless validate(value, type, constraint)
+          rescue ArgumentError => ex
+            puts ex
+          end
+        end
+      end
+
+      @errors.empty?
+    end
+
+    def errors
+      build_error_messages
+      @error_messages
+    end
+
+    private
+
+    def reinit_errrors
+      @errors = {}
+      @error_messages = []
+    end
+
+    def push_error(param, value, type, constraint)
+      @errors[param] = [] unless @errors.member? param
+      @errors[param].push(type: type, value: value, constraint: constraint)
+    end
+
+    def setup_defaults(params)
+      @rules.each do |param, rules|
+        default_rule  = rules.find { |r, _c| r == :default }
+        params[param] = default_rule.last unless default_rule.nil?
+      end
+    end
+
+    def nil_check(param, value)
+      if !value.nil? || value.nil? && has_allow_nil_rule(param)
+        true
+      else
+        push_error(param, :nil, nil, nil)
+        false
+      end
+    end
+
+    def has_allow_nil_rule(param)
+      nil_rule = @rules[param].find { |r, _c| r == :nil }
+      nil_rule.nil? ? false : nil_rule.last
+    end
+
+    def build_error_messages
+      @error_messages = print_errors
+    end
+  end
+end

data/lib/valideizer/error_printer.rb

@@ -0,0 +1,52 @@
+module Valideizer
+  module ErrorPrinter
+    PREFIX = "Validation error:".freeze
+
+    protected
+
+    def print_errors
+      @errors.map { |param_name, errors| errors.each { |error| { message: print_error(param_name, error) }}}
+    end
+
+    private
+
+    def print_option(type, constraint, value)
+      case type
+      when :eql           then "Should be equal to #{constraint}."
+      when :gt            then "Should be greater than #{constraint}."
+      when :gte           then "Should be greater than or equal to #{constraint}."
+      when :lt            then "Should be less than #{constraint}."
+      when :lte           then "Should be less than or equal to #{constraint}."
+      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 :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}."
+      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."
+      else ''
+      end
+    end
+
+    def print_postfix(type, value)
+      "Current value: `#{value}`." if %i[type array_type custom_type active_record length].include?(type)
+    end
+
+    # Validation error: :some param. Should be greater or equal than 200. Current value (100).
+
+    def print_error(param_name, error)
+      message = ""
+      message << PREFIX
+      message << "`#{param_name}`" + "\s" + "param."
+      message << "\s"
+      message << print_option(error[:type], error[:constraint], error[:value])
+      message << "\s"
+      message << (print_postfix(error[:type], error[:value]) || '')
+
+      message
+    end
+  end
+end

data/lib/valideizer/rails.rb

@@ -0,0 +1,32 @@
+require 'valideizer/core'
+
+module Valideizer
+  module Rails
+    def valideize(method, &options_block)
+      @valideizers = {} unless @valideizers.present?
+
+      @valideizers[method] = Valideizer::Core.new
+      @valideizers[method].instance_exec(options_block)
+    end
+
+    def valideize!
+      valideizer = @valideizers[action_name]
+      if valideizer.present? && @valideizer_callback.present?
+        redirect_to(controller: controller_name,
+          action: @valideizer_callback, errors: valideizer.errors) unless validiezer.valideize?(params)
+      end
+    end
+
+    def valideized?(params)
+      @valideizers[action_name].valideized? params
+    end
+
+    def valideizer_errors
+      @valideizers[action_name].errors
+    end
+
+    def validezier_callback(method_name)
+      @valideizer_callback = method_name
+    end
+  end
+end

data/lib/valideizer/rules.rb

@@ -0,0 +1,160 @@
+require 'json'
+
+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(param, rule, constraint)
+      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
+      end
+    end
+
+    private
+
+    def validate_eql(param, constraint)
+      param == constraint
+    end
+
+    def validate_gt(param, constraint)
+      param > constraint
+    end
+
+    def validate_gte(param, constraint)
+      param >= constraint
+    end
+
+    def validate_lt(param, constraint)
+      param < constraint
+    end
+
+    def validate_lte(param, constraint)
+      param <= constraint
+    end
+
+    def validate_ot(param, constraint)
+      param != constraint
+    end
+
+    def validate_range(param, constraint)
+      raise 'Must be a range' unless constraint.is_a? Range
+      constraint.include? param
+    end
+
+    def validate_enum(param, constraint)
+      raise 'Must be an array' unless constraint.is_a? Array
+      constraint.include? param
+    end
+
+    def validate_type(param, constraint)
+      if constraint.is_a? Array
+        constraint.each { |type| return true if type_check(param, type)}
+      else
+        type_check(param, constraint)
+      end
+    end
+
+    def type_check(param, type)
+      res = 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}"
+      end
+    end
+
+    def bool_check(param)
+      [0, 1].include?(param) || ['true', 'false'].include?(param.to_s.downcase)
+    end
+
+    def json_check(param)
+      [Hash, Array].include?((JSON.parse param rescue nil).class)
+    end
+
+    def validate_array_type(param, constraint)
+      if param.is_a? Array
+        param.each do  |v|
+          if v.is_a?(Array)
+            validate_array_type(v, constraint)
+          else
+            return false unless validate_type(v, constraint)
+          end
+        end
+
+        true
+      else
+        false
+      end
+    end
+
+    def validate_regexp(param, regexp)
+      raise 'Must be a string' unless param.is_a? String
+      param.match? regexp
+    end
+
+    def validate_custom_type(param, constraint)
+      param.is_a? constraint
+    end
+
+    def validate_length(param, constraint)
+      if [Array, Hash, String].include? param.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
+        elsif constraint.is_a? Range
+          constraint.include? param.length
+        else
+          raise 'Wrong constraint for :length option. Must be range or hash {min: 0, max: 10}'
+        end
+      else
+        raise 'Must be Array, Hash or String'
+      end
+    end
+
+    def validate_active_record(param, constraint)
+        klass = constraint
+        if klass.is_a? ActiveModel || (klass = constraint.to_s.constantize).is_a?(ActiveModel)
+          klass.find_by_id(param).present?
+        else
+          raise "#{constraint} is not a valid ActiveRecord model"
+       end
+    end
+  end
+end

data/lib/valideizer/version.rb

@@ -0,0 +1,3 @@
+module Valideizer
+  VERSION = "1.0.2"
+end

data/lib/valideizer.rb

@@ -0,0 +1,8 @@
+require_relative 'valideizer/core.rb'
+require_relative 'valideizer/rules.rb'
+require_relative 'valideizer/rails.rb'
+require_relative 'valideizer/version.rb'
+require_relative 'valideizer/error_printer.rb'
+
+module Valideizer; end
+

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: valideizer
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+platform: ruby
+authors:
+- Arthur 'ArtK0DE' Korochansky
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-08-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+description: Small Gem to validate parameters. Can be integrated with Rails controllers
+email:
+- art2rik.desperado@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/valideizer.rb
+- lib/valideizer/core.rb
+- lib/valideizer/error_printer.rb
+- lib/valideizer/rails.rb
+- lib/valideizer/rules.rb
+- lib/valideizer/version.rb
+homepage: https://github.com/artk0de/valideizer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.9
+signing_key: 
+specification_version: 4
+summary: Small Gem to validate parameters
+test_files: []